diff --git a/docs/org.eclipse.jst.j2ee.doc.user/.cvsignore b/docs/org.eclipse.jst.j2ee.doc.user/.cvsignore
index c14487c..0598c54 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/.cvsignore
+++ b/docs/org.eclipse.jst.j2ee.doc.user/.cvsignore
@@ -1 +1,2 @@
 build.xml
+org.eclipse.jst.j2ee.doc.user_1.0.0.jar
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/build.properties b/docs/org.eclipse.jst.j2ee.doc.user/build.properties
index e0147fd..5c47011 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/build.properties
+++ b/docs/org.eclipse.jst.j2ee.doc.user/build.properties
@@ -5,5 +5,7 @@
                plugin.xml,\
                plugin.properties,\
                META-INF/,\
-               about.html/
+               about.html/,\
+               about.html,\
+               org.eclipse.jst.j2ee.doc.userindex.html
 src.includes = build.properties,\
\ No newline at end of file
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/images/ProjectExplorer.gif b/docs/org.eclipse.jst.j2ee.doc.user/images/ProjectExplorer.gif
index 0877107..c51d9d9 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/images/ProjectExplorer.gif
+++ b/docs/org.eclipse.jst.j2ee.doc.user/images/ProjectExplorer.gif
Binary files differ
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/jst_j2ee_toc.xml b/docs/org.eclipse.jst.j2ee.doc.user/jst_j2ee_toc.xml
index f0a5a5f..7614ada 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/jst_j2ee_toc.xml
+++ b/docs/org.eclipse.jst.j2ee.doc.user/jst_j2ee_toc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <?NLS  TYPE="org.eclipse.help.toc"?>
-<toc label="J2EE applications - open source" topic="topics/ph-j2eeapp.html">
+<toc label="J2EE applications - WTP" topic="topics/ph-j2eeapp.html">
    <topic label="J2EE Applications" href="topics/ph-j2eeapp.html">
       <topic label="J2EE architecture" href="topics/cjarch.html"/>
       <topic label="J2EE perspective" href="topics/cjpers.html"/>
@@ -8,9 +8,6 @@
       <topic label="Working with projects" href="topics/ph-projects.html">
          <topic label="Enterprise application projects" href="topics/cjearproj.html"/>
          <topic label="Application client projects" href="topics/cjappcliproj.html"/>
-         <topic label="Creating an enterprise application project" href="topics/tjear.html"/>
-         <topic label="Creating an application client project" href="topics/tjappproj.html"/>
-         <topic label="Creating a connector project" href="topics/tjrar.html"/>
          <topic label="Specifying target servers for J2EE projects" href="topics/tjtargetserver.html"/>
          <topic label="Importing and exporting projects and files" href="topics/ph-importexport.html">
             <topic label="Exporting an application client project" href="topics/tjexpapp.html"/>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/org.eclipse.jst.j2ee.doc.userindex.html b/docs/org.eclipse.jst.j2ee.doc.user/org.eclipse.jst.j2ee.doc.userindex.html
index 5e26b25..4246f65 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/org.eclipse.jst.j2ee.doc.userindex.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/org.eclipse.jst.j2ee.doc.userindex.html
@@ -13,8 +13,8 @@
 <!-- US Government Users Restricted Rights -->
 <!-- Use, duplication or disclosure restricted by -->
 <!-- GSA ADP Schedule Contract with IBM Corp. -->
-<link rel="stylesheet" type="text/css" href="ibmdita.css" />
-<link rel="stylesheet" type="text/css" href="common.css" />
+<link rel="stylesheet" type="text/css" href="../org.eclipse.wst.doc.user/ibmdita.css" />
+<link rel="stylesheet" type="text/css" href="../org.eclipse.wst.doc.user/common.css" />
 <title>Index</title>
 </head>
 <body>
@@ -80,8 +80,6 @@
 </li>
 <li>connector projects
 <ul class="indexlist">
-<li><a href="topics/tjrar.html#tjrar">creating</a>
-</li>
 <li><a href="topics/tjexprar.html#tjexprar">exporting</a>
 </li>
 <li><a href="topics/tjimprar.html#tjimprar">importing</a>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/plugin.properties b/docs/org.eclipse.jst.j2ee.doc.user/plugin.properties
index 99da499..c9a4b11 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/plugin.properties
+++ b/docs/org.eclipse.jst.j2ee.doc.user/plugin.properties
@@ -1,5 +1,6 @@
+# NLS_MESSAGEFORMAT_VAR
 # ==============================================================================
 # Translation Instruction: section to be translated
 # ==============================================================================
-Plugin.name = JST documentation for J2EE tools
+Plugin.name = J2EE tools documentation
 Plugin.providerName = Eclipse.org
\ No newline at end of file
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/cjarch.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/cjarch.html
index 3f07b53..462f432 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/cjarch.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/cjarch.html
@@ -4,9 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -25,8 +22,6 @@
 <h1 class="topictitle1">J2EE architecture</h1>
 <div><p>The Java™ 2 Platform, Enterprise Edition (J2EE) provides
 a standard for developing multitier, enterprise services.</p>
-<p>The Java™ 2 Platform, Enterprise Edition (J2EE) provides a standard for
-developing multitier, enterprise services.</p>
 <p>The economy and technology of today have intensified the need for faster,
 more efficient, and larger-scale information management solutions. The J2EE
 specification satisfies these challenges by providing a programming model
@@ -63,7 +58,6 @@
 <div><a href="../topics/cjappcliproj.html">Application client projects</a></div>
 </div>
 <div class="reltasks"><strong>Related tasks</strong><br />
-<div><a href="../topics/tjear.html">Creating an enterprise application project</a></div>
 <div><a href="../topics/tjimpear.html" title="Enterprise application projects are deployed into EAR files. You can import an enterprise application project by importing it from a deployed EAR file.">Importing an enterprise application EAR file</a></div>
 <div><a href="../topics/tjexpear.html" title="Enterprise applications are deployed in the form of an EAR file. Use the Export wizard to export an enterprise application project into an EAR file for deployment.">Exporting an enterprise application into an EAR file</a></div>
 <div><a href="../topics/tjappproj.html" title="You can use a wizard to create a new application client project and add it to a new or existing enterprise application project.">Creating an application client project</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/cjearproj.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/cjearproj.html
index afc9c6d..b75c4d6 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/cjearproj.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/cjearproj.html
@@ -4,7 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -81,7 +80,6 @@
 <div><a href="../topics/cjarch.html" title="The Java 2 Platform, Enterprise Edition (J2EE) provides a standard for developing multitier, enterprise services.">J2EE architecture</a></div>
 </div>
 <div class="reltasks"><strong>Related tasks</strong><br />
-<div><a href="../topics/tjear.html">Creating an enterprise application project</a></div>
 <div><a href="../topics/tjimpear.html" title="Enterprise application projects are deployed into EAR files. You can import an enterprise application project by importing it from a deployed EAR file.">Importing an enterprise application EAR file</a></div>
 <div><a href="../topics/tjexpear.html" title="Enterprise applications are deployed in the form of an EAR file. Use the Export wizard to export an enterprise application project into an EAR file for deployment.">Exporting an enterprise application into an EAR file</a></div>
 </div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/cjview.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/cjview.html
index 4a10817..5c08223 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/cjview.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/cjview.html
@@ -40,14 +40,7 @@
 <dt class="dlterm">Dynamic Web Projects</dt>
 <dd>Shows a hierarchical model of all dynamic Web modules.</dd>
 <dt class="dlterm">EJB Projects</dt>
-<dd>Shows a hierarchical model of all EJB projects. Each EJB project contains
-the following sub-folders for organizing the different types of beans and
-the mappings: <ul><li><span class="uicontrol">Session Beans</span></li>
-<li><span class="uicontrol">Entity Beans</span></li>
-<li><span class="uicontrol">Message-Driven Beans</span></li>
-<li><span class="uicontrol">Maps</span></li>
-</ul>
-</dd>
+<dd>Shows a hierarchical model of all EJB projects.</dd>
 <dt class="dlterm">Other Projects</dt>
 <dd>Shows any non-J2EE module projects, such as Java projects. These Java projects
 can be any of the following types: <ul><li>Utility projects for existing Enterprise Application projects in your
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antejb.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antejb.html
index 5e325b6..44b0cdc 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antejb.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antejb.html
@@ -3,7 +3,8 @@
   PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html lang="en-us" xml:lang="en-us">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><!-- /*******************************************************************************
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antgeneral.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antgeneral.html
index 0a54669..2796a66 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antgeneral.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-antgeneral.html
@@ -4,16 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-importexport.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-importexport.html
index d1c1276..910e8b3 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-importexport.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-importexport.html
@@ -4,9 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-projects.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-projects.html
index 4ea0b73..82f0768 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-projects.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-projects.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -34,14 +32,6 @@
 to as an EAR file.</li>
 <li class="ulchildlink"><strong><a href="../topics/cjappcliproj.html">Application client projects</a></strong><br />
 </li>
-<li class="ulchildlink"><strong><a href="../topics/tjear.html">Creating an enterprise application project</a></strong><br />
-</li>
-<li class="ulchildlink"><strong><a href="../topics/tjappproj.html">Creating an application client project</a></strong><br />
-You can use a wizard to create a new application client project
-and add it to a new or existing enterprise application project.</li>
-<li class="ulchildlink"><strong><a href="../topics/tjrar.html">Creating a connector project</a></strong><br />
-A connector is a J2EE standard extension mechanism for containers
-to provide connectivity to enterprise information systems (EISs).</li>
 <li class="ulchildlink"><strong><a href="../topics/tjtargetserver.html">Specifying target servers for J2EE projects</a></strong><br />
 When you develop J2EE applications, the workbench requires that
 you specify the server runtime environments for your J2EE projects. The target
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-ref.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-ref.html
index 6994033..a50de28 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-ref.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/ph-ref.html
@@ -3,7 +3,8 @@
   PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html lang="en-us" xml:lang="en-us">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><!-- /*******************************************************************************
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/rvalidators.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/rvalidators.html
index 2d64410..35793ce 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/rvalidators.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/rvalidators.html
@@ -35,6 +35,10 @@
 </ul>
 </td>
 </tr>
+<tr><td valign="top" width="50%" headers="d0e24 ">Connector Validator</td>
+<td valign="top" width="50%" headers="d0e26 ">The Connector validator checks for invalid J2EE specification
+levels in connector projects.</td>
+</tr>
 <tr><td align="left" valign="top" width="50%" headers="d0e24 ">DTD Validator</td>
 <td align="left" valign="top" width="50%" headers="d0e26 ">The DTD validator determines whether the
 current state of a DTD is semantically valid. XML files are validated according
@@ -71,9 +75,8 @@
 </ul>
 </td>
 </tr>
-<tr><td valign="top" width="50%" headers="d0e24 ">Connector Validator</td>
-<td valign="top" width="50%" headers="d0e26 ">The Connector validator checks for invalid J2EE specification
-levels in connector projects.</td>
+<tr><td valign="top" width="50%" headers="d0e24 ">EL Syntax Validator</td>
+<td valign="top" width="50%" headers="d0e26 ">&nbsp;</td>
 </tr>
 <tr><td align="left" valign="top" width="50%" headers="d0e24 ">HTML Syntax Validator</td>
 <td align="left" valign="top" width="50%" headers="d0e26 ">The HTML Syntax Validator validates HTML
@@ -88,8 +91,8 @@
 in a project by translating them into the corresponding Java code
 and then checking the Java code for compile errors.</td>
 </tr>
-<tr><td align="left" valign="top" width="50%" headers="d0e24 ">WAR Validator</td>
-<td align="left" valign="top" width="50%" headers="d0e26 ">The WAR Validator validates the following
+<tr><td align="left" valign="top" width="50%" headers="d0e24 ">War Validator</td>
+<td align="left" valign="top" width="50%" headers="d0e26 ">The War Validator validates the following
 web project resources:   <ul><li>Deployment descriptor (web.xml)</li>
 <li>Servlets</li>
 <li>Security roles</li>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantaxbn.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantaxbn.html
index 5d2e3e2..5630f62 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantaxbn.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantaxbn.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcapturebuildmessages.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcapturebuildmessages.html
index d3a0fd0..50793a5 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcapturebuildmessages.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcapturebuildmessages.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -104,8 +95,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcompilew.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcompilew.html
index 3852e73..1f52ea6 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcompilew.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantcompilew.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -69,8 +60,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbd.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbd.html
index 9cad6c7..94bafeb 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbd.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbd.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbe.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbe.html
index 9f759f4..880f9d0 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbe.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantejbe.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautobuild.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautobuild.html
index 68a900c..68dd432 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautobuild.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautobuild.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautodeploy.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautodeploy.html
index ad15e36..0d10cfd 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautodeploy.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantexampleautodeploy.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetj.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetj.html
index 3ce1902..053a7c0 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetj.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetj.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -69,8 +60,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetp.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetp.html
index e5a435f..5868e5c 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetp.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantgetp.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -104,8 +95,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tanthome.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tanthome.html
index 91cecf3..6a36ba4 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tanthome.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tanthome.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantproj.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantproj.html
index 2fa41dd..a002d78 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantproj.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantproj.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -24,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>projectBuild</title>
 </head>
 <body id="tantproj"><a name="tantproj"><!-- --></a>
@@ -109,8 +99,8 @@
 <div><a href="../topics/tantgetp.html" title="This task gets the specified project information.">getProjectData</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectgeterrors.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectgeterrors.html
index 9be2342..d8f28af 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectgeterrors.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectgeterrors.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -24,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>projectGetErrors</title>
 </head>
 <body id="tantprojectgeterrors"><a name="tantprojectgeterrors"><!-- --></a>
@@ -98,8 +88,8 @@
 <div><a href="../topics/tantgetp.html" title="This task gets the specified project information.">getProjectData</a></div>
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectimport.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectimport.html
index 46187ef..bb8f788 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectimport.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectimport.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -73,8 +64,8 @@
 <div><a href="../topics/tantgetp.html" title="This task gets the specified project information.">getProjectData</a></div>
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetbuild.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetbuild.html
index 12ca40f..227058b 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetbuild.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetbuild.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -99,7 +90,7 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetimport.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetimport.html
index 15cb809..7690d65 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetimport.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantprojectsetimport.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -116,7 +107,7 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantsetd.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantsetd.html
index 08dd654..a610b95 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantsetd.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantsetd.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -24,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>setDebugInfo</title>
 </head>
 <body id="tantsetd"><a name="tantsetd"><!-- --></a>
@@ -92,8 +82,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
 <div><a href="../topics/tantworkspacepreferencefile.html" title="This task reads a property file containing Eclipse workspace preferences and sets those preferences.">workspacePreferenceFile</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacebuild.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacebuild.html
index bc41367..79def77 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacebuild.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacebuild.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -100,8 +91,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
 <div><a href="../topics/tantworkspacepreferencefile.html" title="This task reads a property file containing Eclipse workspace preferences and sets those preferences.">workspacePreferenceFile</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacegeterrors.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacegeterrors.html
index 687caa1..cb413f4 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacegeterrors.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacegeterrors.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -24,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>workspaceGetErrors</title>
 </head>
 <body id="tantworkspacegeterrors"><a name="tantworkspacegeterrors"><!-- --></a>
@@ -94,8 +84,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacepreferencefile.html" title="This task reads a property file containing Eclipse workspace preferences and sets those preferences.">workspacePreferenceFile</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferencefile.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferencefile.html
index bb52c36..84dc7a3 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferencefile.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferencefile.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -89,8 +80,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceget.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceget.html
index 0149087..ed0812a 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceget.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceget.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -79,8 +70,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceset.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceset.html
index e4b4bb5..fcd618f 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceset.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tantworkspacepreferenceset.html
@@ -4,15 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -99,8 +90,8 @@
 <div><a href="../topics/tantproj.html" title="This task builds the specified project.">projectBuild</a></div>
 <div><a href="../topics/tantprojectgeterrors.html" title="This task gets the errors for the specified project. It is a subset of the projectBuild task (it does not do a build, it just gets project errors regardless of how they were created)">projectGetErrors</a></div>
 <div><a href="../topics/tantprojectimport.html" title="This task imports an existing file system project into a workspace.">projectImport</a></div>
-<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&#34;PSF&#34;). The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
-<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &#34;Project Set Export&#34; command.">projectSetImport</a></div>
+<div><a href="../topics/tantprojectsetbuild.html" title="This task builds a set of Eclipse projects using an existing Eclipse team Project Set File (&quot;PSF&quot;). The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command, and then the task projectSetImport must have been used to import those projects into a workspace.">projectSetBuild</a></div>
+<div><a href="../topics/tantprojectsetimport.html" title="This task imports an existing Eclipse team Project Set File (PSF) into a workspace. The PSF must have been first created using an Eclipse team &quot;Project Set Export&quot; command.">projectSetImport</a></div>
 <div><a href="../topics/tantsetd.html" title="This task sets the internal Java compilation debug level, and returns the current settings.">setDebugInfo</a></div>
 <div><a href="../topics/tantworkspacebuild.html" title="This task builds the entire workspace.">workspaceBuild</a></div>
 <div><a href="../topics/tantworkspacegeterrors.html" title="This task gets the errors for the entire workspace. It is a subset of the workspaceBuild task (it does not do a build, it just gets workspace errors regardless of how they were created).">workspaceGetErrors</a></div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjant.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjant.html
index c5fb792..445b487 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjant.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjant.html
@@ -4,7 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantheadless.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantheadless.html
index c901b69..4daaff6 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantheadless.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantheadless.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantupgrade.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantupgrade.html
index 9956630..69b0b38 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantupgrade.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjantupgrade.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjappproj.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjappproj.html
index d3a8d7f..25a406e 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjappproj.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjappproj.html
@@ -57,11 +57,7 @@
 <li class="stepexpand"><span>Click <span class="uicontrol">Finish</span>.</span></li>
 </ol>
 </div>
-<div>
-<div class="familylinks">
-<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/ph-projects.html" title="The workbench can work with many different types of projects. The following topics cover creating and managing some of the types of projects related to J2EE development.">Working with projects</a></div>
-</div>
-<div class="relconcepts"><strong>Related concepts</strong><br />
+<div><div class="relconcepts"><strong>Related concepts</strong><br />
 <div><a href="../topics/cjarch.html" title="The Java 2 Platform, Enterprise Edition (J2EE) provides a standard for developing multitier, enterprise services.">J2EE architecture</a></div>
 <div><a href="../topics/cjappcliproj.html">Application client projects</a></div>
 </div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjexpear.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjexpear.html
index d1e32ca..f91f3d7 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjexpear.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjexpear.html
@@ -64,7 +64,6 @@
 <div><a href="../topics/cjearproj.html" title="An enterprise application project contains the hierarchy of resources that are required to deploy a J2EE enterprise application, often referred to as an EAR file.">Enterprise application projects</a></div>
 </div>
 <div class="reltasks"><strong>Related tasks</strong><br />
-<div><a href="../topics/tjear.html">Creating an enterprise application project</a></div>
 <div><a href="../topics/tjimpear.html" title="Enterprise application projects are deployed into EAR files. You can import an enterprise application project by importing it from a deployed EAR file.">Importing an enterprise application EAR file</a></div>
 </div>
 </div></body>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjimpear.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjimpear.html
index 3b6118b..82afd2a 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjimpear.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjimpear.html
@@ -15,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>Importing an enterprise application EAR file</title>
 </head>
 <body id="tjimpear"><a name="tjimpear"><!-- --></a>
@@ -77,7 +76,6 @@
 <div><a href="../topics/cjcircle.html">Cyclical dependencies between J2EE modules</a></div>
 </div>
 <div class="reltasks"><strong>Related tasks</strong><br />
-<div><a href="../topics/tjear.html">Creating an enterprise application project</a></div>
 <div><a href="../topics/tjexpear.html" title="Enterprise applications are deployed in the form of an EAR file. Use the Export wizard to export an enterprise application project into an EAR file for deployment.">Exporting an enterprise application into an EAR file</a></div>
 <div><a href="../topics/tjcircleb.html" title="You can resolve cyclical dependencies after an EAR is imported.">Correcting cyclical dependencies after an EAR is imported</a></div>
 </div>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjtargetserver.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjtargetserver.html
index 382104f..28ac71f 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjtargetserver.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjtargetserver.html
@@ -3,7 +3,8 @@
   PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html lang="en-us" xml:lang="en-us">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><!-- /*******************************************************************************
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjval.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjval.html
index 5aae0a5..1aa45fe 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjval.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjval.html
@@ -4,11 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
-
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalauto.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalauto.html
index 501460c..9d538e7 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalauto.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalauto.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -17,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>Enabling automatic code validation</title>
 </head>
 <body id="tjvalauto"><a name="tjvalauto"><!-- --></a>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalbuild.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalbuild.html
index 6fabc84..62d7ae7 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalbuild.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalbuild.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvaldisable.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvaldisable.html
index 9539116..623ee55 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvaldisable.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvaldisable.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -17,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>Disabling a validator</title>
 </head>
 <body id="tjvaldisable"><a name="tjvaldisable"><!-- --></a>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalglobalpref.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalglobalpref.html
index 234e6a2..29f4d21 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalglobalpref.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalglobalpref.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
@@ -17,7 +15,6 @@
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/ -->
 <link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />
-
 <title>Overriding global validation preferences</title>
 </head>
 <body id="tjvalglobalpref"><a name="tjvalglobalpref"><!-- --></a>
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalmanual.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalmanual.html
index d8147bf..6e3ef4d 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalmanual.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalmanual.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalselect.html b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalselect.html
index c6a395a..c64e97d 100644
--- a/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalselect.html
+++ b/docs/org.eclipse.jst.j2ee.doc.user/topics/tjvalselect.html
@@ -4,8 +4,6 @@
 <html lang="en-us" xml:lang="en-us">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
-
 <!-- /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
diff --git a/docs/org.eclipse.jst.j2ee.infopop/META-INF/MANIFEST.MF b/docs/org.eclipse.jst.j2ee.infopop/META-INF/MANIFEST.MF
index f7b7e34..0803318 100644
--- a/docs/org.eclipse.jst.j2ee.infopop/META-INF/MANIFEST.MF
+++ b/docs/org.eclipse.jst.j2ee.infopop/META-INF/MANIFEST.MF
@@ -3,9 +3,6 @@
 Bundle-Name: %Plugin.name
 Bundle-SymbolicName: org.eclipse.jst.j2ee.infopop; singleton:=true
 Bundle-Version: 1.0.0
-Bundle-Activator: org.eclipse.core.internal.compatibility.PluginActivator
 Bundle-Vendor: Eclipse.org
 Bundle-Localization: plugin
-Require-Bundle: org.eclipse.core.runtime;bundle-version="2.1",
- org.eclipse.core.runtime.compatibility
 Eclipse-AutoStart: true
diff --git a/docs/org.eclipse.jst.j2ee.infopop/ProjectCreateWizard_HelpContexts.xml b/docs/org.eclipse.jst.j2ee.infopop/ProjectCreateWizard_HelpContexts.xml
deleted file mode 100644
index 113b11e..0000000
--- a/docs/org.eclipse.jst.j2ee.infopop/ProjectCreateWizard_HelpContexts.xml
+++ /dev/null
@@ -1,110 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?NLS type="org.eclipse.help.contexts"?>
-<!-- /*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/ -->
-<contexts>
-<context id="APPCLIENT_NEW_APPCLIENT_WIZARD_PAGE1">
-<description>Use this wizard to create a new application Client project. 
-
-On this page, name the application client project, and select the workspace location to store the project files.  
-
-Select the <b>Show Advanced</b> button to specify any of the following:
-<ul>
-    <li>The <b>Target server</b>.</li>
-    <li>The <b>Module Version (J2EE specification level)</b>.</li>
-    <li>Automatically add the Application Client  project to an enterprise application project.</li>
-    </ul> 
-</description>
-<!--topic label="Creating an application client project" href="../com.ibm.etools.j2eeapp.doc/topics/tjappproj.html"/-->
-<!--topic label="J2EE architecture" href="../com.ibm.etools.j2eeapp.doc/topics/cjarch.html"/-->
-</context>
-
-<context id="EAR_NEW_EAR_WIZARD_PAGE1">
-<description>Use this wizard to create an enterprise application (EAR) project. An enterprise application project can contain one or more J2EE modules, including application client modules, EJB modules, Connector modules, or Web module. 
-
-On this page, name the EAR application project, and select the workspace location to store the project files.  
-
-Select the <b>Show Advanced</b> button to select a <b>Target server</b> or the <b>Module Version</b> (J2EE specification level) that you want to use for the new enterprise application project.
-
-To add J2EE modules to the enterprise application project, click <b>Next</b>.  If you do not want to add J2EE modules during the creation of the enterprise application project, click <b>Finish</b>.
-J2EE modules can be added to an enterprise application project at any time. Once the enterprise application project has been created, right-click and select <b>Properties > EAR modules</b> to
-add or delete EAR modules from the project. 
-</description>
-<!--topic label="Creating an enterprise application project" href="../com.ibm.etools.j2eeapp.doc/topics/tjear.html"/-->
-<!--topic label="J2EE architecture" href="../com.ibm.etools.j2eeapp.doc/topics/cjarch.html"/-->
-</context>
-
-<context id="NEW_EAR_ADD_MODULES_PAGE">
-<description>Use this page to select available J2EE modules to add to the new enterprise application. Click the <b>New Module</b> button  to create new modules. 
-
-J2EE modules can be added to an enterprise application project at any time. Once the enterprise application project has been created, right-click and select <b>Properties > EAR modules</b> to
-add or delete EAR modules from the project.                                    
-</description>
-<!--topic label="Creating an enterprise application project" href="..//topics/tjear.html"/-->
-<!--topic label="J2EE architecture" href="../com.ibm.etools.j2eeapp.doc/topics/cjarch.html"/-->
-</context>
-
-<context id="EAR_NEW_MODULE_PROJECTS_PAGE">
-<description>Use this page to create new J2EE modules to add to the new enterprise application. The wizard can generate a set of default J2EE modules or individual customized J2EE modules.
-</description>
-<!--topiclabel="Creating an enterprise application project" href="../com.ibm.etools.j2eeapp.doc/topics/tjear.html"/-->
-<!--topic label="J2EE architecture" href="../com.ibm.etools.j2eeapp.doc/topics/cjarch.html"/-->
-</context>
-
-
-<context id="EJB_NEW_EJB_WIZARD_PAGE1">
-<description>Use this wizard to create a new EJB project. An EJB project provides a logical group to organize enterprise beans. 
-
-On this page, name the EJB project, and select the workspace location to store the project files.  
-
-Select the <b>Show Advanced</b> button to specify any of the following:
-<ul>
-    <li>The <b>Target server</b>.</li>
-    <li>The <b>EJB version</b>.</li>
-    <li>Automatically add the EJB project to an enterprise application project.</li>
-    <li>Create an EJB Client JAR module to hold remote and local home interfaces and classes. </li>
-    <li>Add support for annotated Java classes.</li>
-    </ul> 
-
-If you selected the <b>Create an EJB Client JAR module to hold the client interfaces and classes</b>, click <b>Next</b> to define the EJB Client JAR module name. 
-Otherwise, click <b>Finish</b>.
-</description>
-<!-- add link for annotated Java classes-->
-<!--topic label="Creating an EJB project" href="../com.ibm.etools.ejb.assembly.doc/topics/tecrtpro.html"/-->
-<!--topic label="EJB architecture" href="../com.ibm.etools.ejb.doc/topics/cearch.html"/-->
-<!--topic label="EJB client projects" href="../com.ibm.etools.ejb.assembly.doc/topics/ceclientjars.html"/-->
-
-</context>
-
-<context id="EJB_NEW_EJB_WIZARD_PAGE2">
-<description>Use this page to specify the name of the EJB client JAR module, as well as the name of the JAR file (<b>Client JAR URI</b>).
-</description>
-<!--topic label="Creating an EJB project" href="../com.ibm.etools.ejb.assembly.doc/topics/tecrtpro.html"/-->
-<!--topic label="EJB client projects" href="../com.ibm.etools.ejb.assembly.doc/topics/ceclientjars.html"/-->
-</context>
-
-
-<context id="JCA_NEWIZARD_PAGE1">
-<description>Use this wizard to create a Connector project. The J2EE Connector Architecture (JCA) specifies how a J2EE application component accesses a connection-based resource. 
-
-On this page, name the Connector project, and select the workspace location to store the project files.  
-
-Select the <b>Show Advanced</b> button to specify any of the following:
-<ul>
-    <li>The <b>Target server</b>.</li>
-    <li>The <b>JCA version</b>.</li>
-    <li>Automatically add the Connector project to an enterprise application project.</li>
-    </ul> 
-</description>
-<!-- link to 'Connector projects' topic in com.ibm.etools.rad.migration.doc/topics/rv6connectjca.html-->
-<!--topic label="Creating a connector project" href="../com.ibm.etools.j2ee.doc/topics/tjrar.html"/-->
-</context>
-</contexts>
\ No newline at end of file
diff --git a/docs/org.eclipse.jst.j2ee.infopop/plugin.xml b/docs/org.eclipse.jst.j2ee.infopop/plugin.xml
deleted file mode 100644
index fd009c6..0000000
--- a/docs/org.eclipse.jst.j2ee.infopop/plugin.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?NLS TYPE="org.eclipse.help.contexts"?>
-<!-- /*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/ -->
-<plugin>
-   
-   <extension point="org.eclipse.help.contexts">
-	<contexts file="ExportWizard_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-	<contexts file="ImportWizard_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-	<contexts file="J2EEGeneral_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-	<contexts file="ProjectCreateWizard_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-	<contexts file="EJBCreateWizard_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-   	<!--<contexts file="DeleteBean_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" /> -->
-	<contexts file="ValidationProjPrefs_HelpContexts.xml" plugin="org.eclipse.wst.validation" />
-	<contexts file="ValidationPrefs_HelpContexts.xml" plugin="org.eclipse.wst.validation" />
-	<contexts file="ProjectPrefs_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-	<contexts file="Preferences_HelpContexts.xml" plugin="org.eclipse.jst.j2ee" />
-   </extension>
-
-</plugin>
diff --git a/features/org.eclipse.jem-feature/.project b/features/org.eclipse.jem-feature/.project
deleted file mode 100644
index 04e071f..0000000
--- a/features/org.eclipse.jem-feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem-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/features/org.eclipse.jem-feature/build.properties b/features/org.eclipse.jem-feature/build.properties
deleted file mode 100644
index d2cc70f..0000000
--- a/features/org.eclipse.jem-feature/build.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               epl-v10.html,\
-               eclipse_update_120.jpg,\
-               license.html
-
-
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/.classpath b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/.classpath
deleted file mode 100644
index f8dad69..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/.classpath
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry exported="true" kind="lib" path="event"/>
-</classpath>
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/.project b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/.project
deleted file mode 100644
index 8c8107f..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>com.ibm.etools.emf.event</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.jdt.core.javanature</nature>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/META-INF/MANIFEST.MF b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/META-INF/MANIFEST.MF
deleted file mode 100644
index 8a22b83..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,14 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: Event Model
-Bundle-SymbolicName: com.ibm.etools.emf.event; singleton:=true
-Bundle-Version: 3.0.0.2
-Bundle-Activator: org.eclipse.core.internal.compatibility.PluginActivator
-Bundle-Localization: plugin
-Export-Package: com.ibm.etools.emf.event,
- com.ibm.etools.emf.event.impl,
- com.ibm.etools.emf.event.util
-Require-Bundle: org.eclipse.emf.ecore,
- org.eclipse.core.runtime.compatibility,
- org.eclipse.core.runtime;bundle-version="2.1"
-Eclipse-AutoStart: true
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/about.html b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/build.properties b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/build.properties
deleted file mode 100644
index 35cb23d..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/build.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = plugin.xml,\
-               about.html,\
-               META-INF/,\
-               com/,\
-               model/,\
-               .
-jars.compile.order = .
-source.. = event/
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Add.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Add.class
deleted file mode 100644
index 17b5bdb..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Add.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/AddMany.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/AddMany.class
deleted file mode 100644
index c053bf6..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/AddMany.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Change$Setting.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Change$Setting.class
deleted file mode 100644
index fe24814..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Change$Setting.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Change.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Change.class
deleted file mode 100644
index 7fe913c..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Change.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/ChangeUtil.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/ChangeUtil.class
deleted file mode 100644
index c7c7899..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/ChangeUtil.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EObjectDescriptor.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EObjectDescriptor.class
deleted file mode 100644
index 0d659b7..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EObjectDescriptor.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Event.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Event.class
deleted file mode 100644
index c361b71..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Event.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventFactory.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventFactory.class
deleted file mode 100644
index 25dcfcb..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventFactory.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventKind.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventKind.class
deleted file mode 100644
index 893be66..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventKind.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventPackage.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventPackage.class
deleted file mode 100644
index 6dc91a9..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventPackage.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventUtil.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventUtil.class
deleted file mode 100644
index a98222f..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/EventUtil.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/FeatureKind.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/FeatureKind.class
deleted file mode 100644
index 50b23c6..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/FeatureKind.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Move.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Move.class
deleted file mode 100644
index 95f1d42..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Move.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/NotifierKind.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/NotifierKind.class
deleted file mode 100644
index 5fb13bc..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/NotifierKind.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Remove.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Remove.class
deleted file mode 100644
index 9433b3d..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Remove.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/RemoveMany.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/RemoveMany.class
deleted file mode 100644
index 8bff8f6..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/RemoveMany.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Set.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Set.class
deleted file mode 100644
index 19ad02e..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Set.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Setting.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Setting.class
deleted file mode 100644
index a03e43e..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Setting.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Unset.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Unset.class
deleted file mode 100644
index 4d4a1aa..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/Unset.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/AddImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/AddImpl.class
deleted file mode 100644
index 5cffa91..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/AddImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/AddManyImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/AddManyImpl.class
deleted file mode 100644
index ecf8c2b..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/AddManyImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeHelper.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeHelper.class
deleted file mode 100644
index 9aa403f..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeHelper.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeImpl$SettingImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeImpl$SettingImpl.class
deleted file mode 100644
index 0af8abf..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeImpl$SettingImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeImpl.class
deleted file mode 100644
index 4334dd2..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeUtilImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeUtilImpl.class
deleted file mode 100644
index 0085e62..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/ChangeUtilImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EObjectDescriptorImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EObjectDescriptorImpl.class
deleted file mode 100644
index d524ebf..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EObjectDescriptorImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventAdapter.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventAdapter.class
deleted file mode 100644
index 0f7bcb5..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventAdapter.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventFactoryImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventFactoryImpl.class
deleted file mode 100644
index fc343e2..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventFactoryImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventHelper.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventHelper.class
deleted file mode 100644
index f642201..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventHelper.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventImpl.class
deleted file mode 100644
index c7c4493..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventPackageImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventPackageImpl.class
deleted file mode 100644
index 4406c9b..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventPackageImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventReaderHelper.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventReaderHelper.class
deleted file mode 100644
index e1f7e6b..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventReaderHelper.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl$BackwardEventIterator.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl$BackwardEventIterator.class
deleted file mode 100644
index ba6d2da..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl$BackwardEventIterator.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl$ForwardEventIterator.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl$ForwardEventIterator.class
deleted file mode 100644
index 755b83e..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl$ForwardEventIterator.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl.class
deleted file mode 100644
index d356053..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventUtilImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventWriterHelper$EObjectData.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventWriterHelper$EObjectData.class
deleted file mode 100644
index 4d24d95..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventWriterHelper$EObjectData.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventWriterHelper.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventWriterHelper.class
deleted file mode 100644
index cd01db2..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/EventWriterHelper.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/MoveImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/MoveImpl.class
deleted file mode 100644
index 2fa43df..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/MoveImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/RemoveImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/RemoveImpl.class
deleted file mode 100644
index 3162871..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/RemoveImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/RemoveManyImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/RemoveManyImpl.class
deleted file mode 100644
index 5cb5312..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/RemoveManyImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/SetImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/SetImpl.class
deleted file mode 100644
index 3e78366..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/SetImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/SettingImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/SettingImpl.class
deleted file mode 100644
index a9e1de2..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/SettingImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/UnsetImpl.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/UnsetImpl.class
deleted file mode 100644
index 82a223d..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/impl/UnsetImpl.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventAdapterFactory$1.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventAdapterFactory$1.class
deleted file mode 100644
index 59acfe9..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventAdapterFactory$1.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventAdapterFactory.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventAdapterFactory.class
deleted file mode 100644
index aee179d..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventAdapterFactory.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventSwitch.class b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventSwitch.class
deleted file mode 100644
index dbe729f..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/event/com/ibm/etools/emf/event/util/EventSwitch.class
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/model/event.mdl b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/model/event.mdl
deleted file mode 100644
index 3277b13..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/model/event.mdl
+++ /dev/null
@@ -1,5029 +0,0 @@
-
-(object Petal
-    version    	42
-    _written   	"Rose 4.5.8163.3"
-    charSet    	0)
-
-(object Design "Logical View"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    defaults   	(object defaults
-	rightMargin 	0.250000
-	leftMargin 	0.250000
-	topMargin  	0.250000
-	bottomMargin 	0.500000
-	pageOverlap 	0.250000
-	clipIconLabels 	TRUE
-	autoResize 	TRUE
-	snapToGrid 	TRUE
-	gridX      	16
-	gridY      	16
-	defaultFont 	(object Font
-	    size       	10
-	    face       	"Arial"
-	    bold       	FALSE
-	    italics    	FALSE
-	    underline  	FALSE
-	    strike     	FALSE
-	    color      	0
-	    default_color 	TRUE)
-	showMessageNum 	1
-	showClassOfObject 	TRUE
-	notation   	"Unified")
-    root_usecase_package 	(object Class_Category "Use Case View"
-	quid       	"3B1FE4BB00C5"
-	exportControl 	"Public"
-	global     	TRUE
-	logical_models 	(list unit_reference_list)
-	logical_presentations 	(list unit_reference_list
-	    (object UseCaseDiagram "Main"
-		quid       	"3B1FE4C60144"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    root_category 	(object Class_Category "Logical View"
-	quid       	"3B1FE4BB008A"
-	exportControl 	"Public"
-	global     	TRUE
-	subsystem  	"Component View"
-	quidu      	"3B1FE4BB00C6"
-	logical_models 	(list unit_reference_list
-	    (object Association "$UNNAMED$0"
-		quid       	"3E25D35F00CD"
-		roles      	(list role_list
-		    (object Role "addedEObjects"
-			attributes 	(list Attribute_Set)
-			quid       	"3E25D36000F7"
-			label      	"addedEObjects"
-			supplier   	"Logical View::ecore::EObject"
-			quidu      	"3C4F1C860123"
-			client_cardinality 	(value cardinality "0..n")
-			Containment 	"By Value"
-			is_navigable 	TRUE)
-		    (object Role "$UNNAMED$1"
-			attributes 	(list Attribute_Set)
-			quid       	"3E25D36000F8"
-			supplier   	"Logical View::Event::Event"
-			quidu      	"3BCC796B0129"
-			is_aggregate 	TRUE)))
-	    (object Class_Category "ecore"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$VABASE_PLUGINS_PATH\\org.eclipse.emf.ecore\\src\\model\\org.eclipse.emf.Ecore.cat"
-		quid       	"39A5ED04004E")
-	    (object Class_Category "Event"
-		quid       	"3E2C51040188"
-		exportControl 	"Public"
-		logical_models 	(list unit_reference_list
-		    (object Class "Event"
-			quid       	"3BCC796B0129"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "eventKind"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE)
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isVolatile"
-					value      	TRUE)
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isChangeable"
-					value      	FALSE))
-				quid       	"3DD0052F03A1"
-				type       	"EventKind"
-				exportControl 	"Implementation")
-			    (object ClassAttribute "notifierURI"
-				quid       	"3E5955180270"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "featureName"
-				quid       	"3E2701CB011D"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "notifier"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7916F60246"
-				type       	"Notifier"
-				exportControl 	"Implementation"))
-			language   	"C++"
-			abstract   	TRUE)
-		    (object Class "JavaObject"
-			quid       	"3BF407B80040"
-			stereotype 	"datatype"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "java.lang.Object"
-				quid       	"3BF407DB0018"
-				stereotype 	"javaclass"
-				exportControl 	"Public"))
-			language   	"C++")
-		    (object Class "EventKind"
-			quid       	"3E2336250182"
-			stereotype 	"enumeration"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "set"
-				quid       	"3E23366400F7"
-				exportControl 	"Public")
-			    (object ClassAttribute "unset"
-				quid       	"3E2336650134"
-				exportControl 	"Public")
-			    (object ClassAttribute "add"
-				quid       	"3E2336660349"
-				exportControl 	"Public")
-			    (object ClassAttribute "remove"
-				quid       	"3E233668012F"
-				exportControl 	"Public")
-			    (object ClassAttribute "addMany"
-				quid       	"3E23366901DA"
-				exportControl 	"Public")
-			    (object ClassAttribute "removeMany"
-				quid       	"3E23366D0262"
-				exportControl 	"Public")
-			    (object ClassAttribute "move"
-				quid       	"3E233681008A"
-				exportControl 	"Public"))
-			language   	"Java")
-		    (object Class "Add"
-			quid       	"3E25CD5F033B"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D3E10279"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "position"
-				quid       	"3E25F7350165"
-				type       	"int"
-				initv      	"-1"
-				exportControl 	"Public")
-			    (object ClassAttribute "literal"
-				quid       	"3E2D8E9203B4"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "object"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7A631302F5"
-				type       	"JavaObject"
-				exportControl 	"Implementation"))
-			language   	"Java")
-		    (object Class "AddMany"
-			quid       	"3E25CD6403C5"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D3E503AB"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "positions"
-				quid       	"3E2D8E9A0275"
-				stereotype 	"0..*"
-				type       	"int"
-				exportControl 	"Public")
-			    (object ClassAttribute "literals"
-				quid       	"3E7A637602ED"
-				stereotype 	"0..*"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "objects"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7A6336006A"
-				stereotype 	"0..*"
-				type       	"JavaObject"
-				exportControl 	"Implementation"))
-			language   	"Java")
-		    (object Class "Set"
-			quid       	"3E25CD7D02DA"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D4010383"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "oldLiteral"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isUnsettable"
-					value      	TRUE))
-				quid       	"3E2D8E71019A"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "oldObject"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE)
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isUnsettable"
-					value      	TRUE))
-				quid       	"3E7A63AE008B"
-				type       	"JavaObject"
-				exportControl 	"Implementation")
-			    (object ClassAttribute "newLiteral"
-				quid       	"3E2D8E8000A1"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "newObject"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7A63B5032A"
-				type       	"JavaObject"
-				exportControl 	"Implementation"))
-			language   	"Java")
-		    (object Class "Unset"
-			quid       	"3E25CD830166"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D3FB0294"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "literal"
-				quid       	"3E2D8E88030F"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "object"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7A639C0251"
-				type       	"JavaObject"
-				exportControl 	"Implementation"))
-			language   	"Java")
-		    (object Class "Remove"
-			quid       	"3E25CD8A0383"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D3EA00EB"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "position"
-				quid       	"3E25CDAB0272"
-				type       	"int"
-				initv      	"-1"
-				exportControl 	"Public")
-			    (object ClassAttribute "literal"
-				quid       	"3E2D8EAE0260"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "object"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7A635002AC"
-				type       	"JavaObject"
-				exportControl 	"Implementation"))
-			language   	"Java")
-		    (object Class "RemoveMany"
-			quid       	"3E25CD9200E6"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D3F60016"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "positions"
-				quid       	"3E25D04C02A2"
-				stereotype 	"0..*"
-				type       	"int"
-				exportControl 	"Public")
-			    (object ClassAttribute "literals"
-				quid       	"3E2D8EB801BA"
-				stereotype 	"0..*"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "objects"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7A635803E4"
-				stereotype 	"0..*"
-				type       	"JavaObject"
-				exportControl 	"Implementation"))
-			language   	"Java")
-		    (object Class "Move"
-			quid       	"3E25CDC00345"
-			superclasses 	(list inheritance_relationship_list
-			    (object Inheritance_Relationship
-				quid       	"3E25D3F201A1"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "oldPosition"
-				quid       	"3E25CDC60004"
-				type       	"int"
-				initv      	"-1"
-				exportControl 	"Public")
-			    (object ClassAttribute "newPosition"
-				quid       	"3E25CDCB030F"
-				type       	"int"
-				initv      	"-1"
-				exportControl 	"Public"))
-			language   	"Java")
-		    (object Class "Notifier"
-			quid       	"3E26EC5E01E8"
-			stereotype 	"datatype"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "org.eclipse.emf.common.notify.Notifier"
-				quid       	"3E26EC9600DA"
-				stereotype 	"javaclass"
-				exportControl 	"Public"))
-			language   	"Java")
-		    (object Class "Resource"
-			quid       	"3E272527006F"
-			stereotype 	"datatype"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "org.eclipse.emf.ecore.resource.Resource"
-				quid       	"3E272539011F"
-				stereotype 	"javaclass"
-				exportControl 	"Public"))
-			language   	"Java")
-		    (object Class "Setting"
-			quid       	"3E39A511000E"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "refName"
-				quid       	"3E65541A0335"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "value"
-				quid       	"3E39A5330003"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "position"
-				quid       	"3E6553B1024E"
-				type       	"int"
-				initv      	"-1"
-				exportControl 	"Public"))
-			language   	"Java")
-		    (object Class "EObjectDescriptor"
-			quid       	"3E6672E90396"
-			class_attributes 	(list class_attribute_list
-			    (object ClassAttribute "eventId"
-				quid       	"3E667335038C"
-				type       	"String"
-				exportControl 	"Public")
-			    (object ClassAttribute "eObjectPosition"
-				quid       	"3E677EF301FA"
-				type       	"int"
-				initv      	"-1"
-				exportControl 	"Public"))
-			language   	"Java")
-		    (object Association "$UNNAMED$2"
-			quid       	"3E655451004F"
-			roles      	(list role_list
-			    (object Role "addedDescriptors"
-				quid       	"3E6554510348"
-				label      	"addedDescriptors"
-				supplier   	"Logical View::Event::EObjectDescriptor"
-				quidu      	"3E6672E90396"
-				client_cardinality 	(value cardinality "0..n")
-				Containment 	"By Value"
-				is_navigable 	TRUE)
-			    (object Role "$UNNAMED$3"
-				quid       	"3E6554510349"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"
-				is_aggregate 	TRUE)))
-		    (object Association "$UNNAMED$4"
-			quid       	"3E6554800382"
-			roles      	(list role_list
-			    (object Role "removedDescriptors"
-				quid       	"3E65548102BB"
-				label      	"removedDescriptors"
-				supplier   	"Logical View::Event::EObjectDescriptor"
-				quidu      	"3E6672E90396"
-				client_cardinality 	(value cardinality "0..n")
-				Containment 	"By Value"
-				is_navigable 	TRUE)
-			    (object Role "$UNNAMED$5"
-				quid       	"3E65548102BC"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"
-				is_aggregate 	TRUE)))
-		    (object Association "$UNNAMED$6"
-			quid       	"3E6673470319"
-			roles      	(list role_list
-			    (object Role "settings"
-				quid       	"3E66734802A3"
-				label      	"settings"
-				supplier   	"Logical View::Event::Setting"
-				quidu      	"3E39A511000E"
-				client_cardinality 	(value cardinality "0..n")
-				Containment 	"By Value"
-				is_navigable 	TRUE)
-			    (object Role "$UNNAMED$7"
-				quid       	"3E66734802AD"
-				supplier   	"Logical View::Event::EObjectDescriptor"
-				quidu      	"3E6672E90396"
-				is_aggregate 	TRUE)))
-		    (object Association "$UNNAMED$8"
-			quid       	"3E404FD2031E"
-			roles      	(list role_list
-			    (object Role "removedEObjects"
-				quid       	"3E404FD303A1"
-				label      	"removedEObjects"
-				supplier   	"Logical View::ecore::EObject"
-				quidu      	"3C4F1C860123"
-				client_cardinality 	(value cardinality "0..n")
-				Containment 	"By Value"
-				is_navigable 	TRUE)
-			    (object Role "$UNNAMED$9"
-				quid       	"3E404FD303A2"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"
-				is_aggregate 	TRUE)))
-		    (object Association "$UNNAMED$10"
-			quid       	"3E7916CE016C"
-			roles      	(list role_list
-			    (object Role "feature"
-				attributes 	(list Attribute_Set
-				    (object Attribute
-					tool       	"Ecore"
-					name       	"isTransient"
-					value      	TRUE))
-				quid       	"3E7916D70043"
-				label      	"feature"
-				supplier   	"Logical View::ecore::EStructuralFeature"
-				quidu      	"3903D59D0230"
-				client_cardinality 	(value cardinality "0..1")
-				is_navigable 	TRUE)
-			    (object Role "$UNNAMED$11"
-				quid       	"3E7916D7004D"
-				supplier   	"Logical View::Event::Event"
-				quidu      	"3BCC796B0129"))))
-		logical_presentations 	(list unit_reference_list
-		    (object ClassDiagram "Main"
-			quid       	"3E2C517A0192"
-			title      	"Main"
-			zoom       	100
-			max_height 	28350
-			max_width  	21600
-			origin_x   	0
-			origin_y   	0
-			items      	(list diagram_item_list
-			    (object ClassView "Class" "Logical View::Event::EventKind" @1
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(2064, 1968)
-				label      	(object ItemLabel
-				    Parent_View 	@1
-				    location   	(1902, 1759)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	324
-				    justify    	0
-				    label      	"EventKind")
-				stereotype 	(object ItemLabel
-				    Parent_View 	@1
-				    location   	(1902, 1709)
-				    fill_color 	13434879
-				    anchor     	10
-				    nlines     	1
-				    max_width  	324
-				    justify    	0
-				    label      	"<<enumeration>>")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	11599792
-				quidu      	"3E2336250182"
-				compartment 	(object Compartment
-				    Parent_View 	@1
-				    location   	(1902, 1819)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	8
-				    max_width  	287)
-				width      	342
-				height     	542
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Move" @2
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1696, 1120)
-				label      	(object ItemLabel
-				    Parent_View 	@2
-				    location   	(1480, 1014)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	432
-				    justify    	0
-				    label      	"Move")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CDC00345"
-				compartment 	(object Compartment
-				    Parent_View 	@2
-				    location   	(1480, 1074)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	3
-				    max_width  	443)
-				width      	450
-				height     	236
-				annotation 	8
-				autoResize 	TRUE)
-			    (object NoteView @3
-				location   	(400, 320)
-				label      	(object ItemLabel
-				    Parent_View 	@3
-				    location   	(112, 229)
-				    fill_color 	13434879
-				    nlines     	3
-				    max_width  	540
-				    label      	"The eventKind attribute, notifier attribute and feature reference are all transient")
-				line_color 	3342489
-				fill_color 	16777088
-				width      	600
-				height     	194)
-			    (object ClassView "Class" "Logical View::Event::RemoveMany" @4
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1952, 1504)
-				label      	(object ItemLabel
-				    Parent_View 	@4
-				    location   	(1657, 1373)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	590
-				    justify    	0
-				    label      	"RemoveMany")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CD9200E6"
-				compartment 	(object Compartment
-				    Parent_View 	@4
-				    location   	(1657, 1433)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	4
-				    max_width  	600)
-				width      	608
-				height     	286
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Remove" @5
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1408, 1504)
-				label      	(object ItemLabel
-				    Parent_View 	@5
-				    location   	(1211, 1373)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	394
-				    justify    	0
-				    label      	"Remove")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CD8A0383"
-				compartment 	(object Compartment
-				    Parent_View 	@5
-				    location   	(1211, 1433)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	4
-				    max_width  	403)
-				width      	412
-				height     	286
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::AddMany" @6
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(848, 1504)
-				label      	(object ItemLabel
-				    Parent_View 	@6
-				    location   	(553, 1373)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	590
-				    justify    	0
-				    label      	"AddMany")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CD6403C5"
-				compartment 	(object Compartment
-				    Parent_View 	@6
-				    location   	(553, 1433)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	4
-				    max_width  	600)
-				width      	608
-				height     	286
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Add" @7
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(240, 1504)
-				label      	(object ItemLabel
-				    Parent_View 	@7
-				    location   	(43, 1373)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	394
-				    justify    	0
-				    label      	"Add")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CD5F033B"
-				compartment 	(object Compartment
-				    Parent_View 	@7
-				    location   	(43, 1433)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	4
-				    max_width  	403)
-				width      	412
-				height     	286
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Unset" @8
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1136, 1120)
-				label      	(object ItemLabel
-				    Parent_View 	@8
-				    location   	(939, 1014)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	394
-				    justify    	0
-				    label      	"Unset")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CD830166"
-				compartment 	(object Compartment
-				    Parent_View 	@8
-				    location   	(939, 1074)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	3
-				    max_width  	403)
-				width      	412
-				height     	236
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Set" @9
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(560, 1168)
-				label      	(object ItemLabel
-				    Parent_View 	@9
-				    location   	(322, 1012)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	476
-				    justify    	0
-				    label      	"Set")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E25CD7D02DA"
-				compartment 	(object Compartment
-				    Parent_View 	@9
-				    location   	(322, 1072)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	5
-				    max_width  	484)
-				width      	494
-				height     	336
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Notifier" @10
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(576, 2112)
-				label      	(object ItemLabel
-				    Parent_View 	@10
-				    location   	(69, 2053)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	1014
-				    justify    	0
-				    label      	"Notifier")
-				stereotype 	(object ItemLabel
-				    Parent_View 	@10
-				    location   	(69, 2003)
-				    fill_color 	13434879
-				    anchor     	10
-				    nlines     	1
-				    max_width  	1014
-				    justify    	0
-				    label      	"<<datatype>>")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	8454016
-				quidu      	"3E26EC5E01E8"
-				compartment 	(object Compartment
-				    Parent_View 	@10
-				    location   	(69, 2113)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	2
-				    max_width  	1028)
-				width      	1032
-				height     	242
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Setting" @11
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1984, 288)
-				label      	(object ItemLabel
-				    Parent_View 	@11
-				    location   	(1807, 157)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	354
-				    justify    	0
-				    label      	"Setting")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E39A511000E"
-				compartment 	(object Compartment
-				    Parent_View 	@11
-				    location   	(1807, 217)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	4
-				    max_width  	365)
-				width      	372
-				height     	286
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::EObjectDescriptor" @12
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(2000, 768)
-				label      	(object ItemLabel
-				    Parent_View 	@12
-				    location   	(1750, 662)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	500
-				    justify    	0
-				    label      	"EObjectDescriptor")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3E6672E90396"
-				compartment 	(object Compartment
-				    Parent_View 	@12
-				    location   	(1750, 722)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	3
-				    max_width  	512)
-				width      	518
-				height     	236
-				annotation 	8
-				autoResize 	TRUE)
-			    (object AssociationViewNew "$UNNAMED$6" @13
-				location   	(1984, 540)
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E6673470319"
-				roleview_list 	(list RoleViews
-				    (object RoleView "settings" @14
-					Parent_View 	@13
-					location   	(32, 108)
-					label      	(object SegLabel @15
-					    Parent_View 	@14
-					    location   	(1864, 483)
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	168
-					    justify    	0
-					    label      	"+settings"
-					    pctDist    	0.522936
-					    height     	121
-					    orientation 	0)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E66734802A3"
-					client     	@13
-					supplier   	@11
-					line_style 	3
-					origin_attachment 	(1984, 540)
-					terminal_attachment 	(1984, 431)
-					label      	(object SegLabel @16
-					    Parent_View 	@14
-					    location   	(2055, 480)
-					    anchor     	2
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	15
-					    justify    	0
-					    label      	"0..*"
-					    pctDist    	0.548148
-					    height     	71
-					    orientation 	1))
-				    (object RoleView "$UNNAMED$7" @17
-					Parent_View 	@13
-					location   	(32, 108)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E66734802AD"
-					client     	@13
-					supplier   	@12
-					line_style 	3
-					origin_attachment 	(1984, 540)
-					terminal_attachment 	(1984, 650))))
-			    (object ClassView "Class" "Logical View::ecore::EObject" @18
-				ShowCompartmentStereotypes 	TRUE
-				location   	(320, 736)
-				label      	(object ItemLabel
-				    Parent_View 	@18
-				    location   	(231, 661)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	178
-				    justify    	0
-				    label      	"EObject")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3C4F1C860123"
-				width      	196
-				height     	174
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::ecore::EStructuralFeature" @19
-				ShowCompartmentStereotypes 	TRUE
-				SuppressAttribute 	TRUE
-				SuppressOperation 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1024, 288)
-				font       	(object Font
-				    italics    	TRUE)
-				label      	(object ItemLabel
-				    Parent_View 	@19
-				    location   	(835, 238)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	378
-				    justify    	0
-				    label      	"EStructuralFeature")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3903D59D0230"
-				width      	396
-				height     	124
-				annotation 	8
-				autoResize 	TRUE)
-			    (object ClassView "Class" "Logical View::Event::Event" @20
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				ShowOperationSignature 	TRUE
-				location   	(1024, 688)
-				font       	(object Font
-				    italics    	TRUE)
-				label      	(object ItemLabel
-				    Parent_View 	@20
-				    location   	(801, 532)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	446
-				    justify    	0
-				    label      	"Event")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	13434879
-				quidu      	"3BCC796B0129"
-				compartment 	(object Compartment
-				    Parent_View 	@20
-				    location   	(801, 592)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	5
-				    max_width  	453)
-				width      	464
-				height     	336
-				annotation 	8
-				autoResize 	TRUE)
-			    (object InheritTreeView "" @21
-				location   	(1027, 948)
-				line_color 	3342489
-				fill_color 	13434879
-				supplier   	@20
-				vertices   	(list Points
-				    (1027, 948)
-				    (1027, 856)))
-			    (object InheritView "" @22
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D3F201A1"
-				client     	@2
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(1652, 1002)
-				terminal_attachment 	(1652, 948)
-				drawSupplier 	@21)
-			    (object InheritView "" @23
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D3EA00EB"
-				client     	@5
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(1415, 1361)
-				terminal_attachment 	(1415, 948)
-				drawSupplier 	@21)
-			    (object InheritView "" @24
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D3FB0294"
-				client     	@8
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(1121, 1002)
-				terminal_attachment 	(1121, 948)
-				drawSupplier 	@21)
-			    (object InheritView "" @25
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D3E10279"
-				client     	@7
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(256, 1361)
-				terminal_attachment 	(256, 948)
-				drawSupplier 	@21)
-			    (object InheritView "" @26
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D3E503AB"
-				client     	@6
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(849, 1361)
-				terminal_attachment 	(849, 948)
-				drawSupplier 	@21)
-			    (object AttachView "" @27
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@3
-				supplier   	@20
-				line_style 	0)
-			    (object AssociationViewNew "$UNNAMED$2" @28
-				location   	(1498, 681)
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E655451004F"
-				roleview_list 	(list RoleViews
-				    (object RoleView "addedDescriptors" @29
-					Parent_View 	@28
-					location   	(650, 249)
-					label      	(object SegLabel @30
-					    Parent_View 	@29
-					    location   	(1562, 585)
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	348
-					    justify    	0
-					    label      	"+addedDescriptors"
-					    pctDist    	0.267857
-					    height     	97
-					    orientation 	0)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E6554510348"
-					client     	@28
-					supplier   	@12
-					line_style 	3
-					origin_attachment 	(1498, 681)
-					terminal_attachment 	(1741, 681)
-					label      	(object SegLabel @31
-					    Parent_View 	@29
-					    location   	(1649, 647)
-					    anchor     	2
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	15
-					    justify    	0
-					    label      	"0..*"
-					    pctDist    	0.625431
-					    height     	35
-					    orientation 	0))
-				    (object RoleView "$UNNAMED$3" @32
-					Parent_View 	@28
-					location   	(650, 249)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E6554510349"
-					client     	@28
-					supplier   	@20
-					line_style 	3
-					origin_attachment 	(1498, 681)
-					terminal_attachment 	(1256, 681))))
-			    (object AssociationViewNew "$UNNAMED$4" @33
-				location   	(1498, 803)
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E6554800382"
-				roleview_list 	(list RoleViews
-				    (object RoleView "removedDescriptors" @34
-					Parent_View 	@33
-					location   	(650, 371)
-					label      	(object SegLabel @35
-					    Parent_View 	@34
-					    location   	(1540, 763)
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	384
-					    justify    	0
-					    label      	"+removedDescriptors"
-					    pctDist    	0.176136
-					    height     	41
-					    orientation 	0)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E65548102BB"
-					client     	@33
-					supplier   	@12
-					line_style 	3
-					origin_attachment 	(1498, 803)
-					terminal_attachment 	(1741, 803)
-					label      	(object SegLabel @36
-					    Parent_View 	@34
-					    location   	(1647, 856)
-					    anchor     	2
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	15
-					    justify    	0
-					    label      	"0..*"
-					    pctDist    	0.619318
-					    height     	53
-					    orientation 	1))
-				    (object RoleView "$UNNAMED$5" @37
-					Parent_View 	@33
-					location   	(650, 371)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E65548102BC"
-					client     	@33
-					supplier   	@20
-					line_style 	3
-					origin_attachment 	(1498, 803)
-					terminal_attachment 	(1256, 803))))
-			    (object AssociationViewNew "$UNNAMED$8" @38
-				location   	(605, 812)
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E404FD2031E"
-				roleview_list 	(list RoleViews
-				    (object RoleView "removedEObjects" @39
-					Parent_View 	@38
-					location   	(141, -4)
-					label      	(object SegLabel @40
-					    Parent_View 	@39
-					    location   	(476, 850)
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	348
-					    justify    	0
-					    label      	"+removedEObjects"
-					    pctDist    	0.687204
-					    height     	38
-					    orientation 	0)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E404FD303A1"
-					client     	@38
-					supplier   	@18
-					line_style 	3
-					origin_attachment 	(605, 812)
-					terminal_attachment 	(418, 812)
-					label      	(object SegLabel @41
-					    Parent_View 	@39
-					    location   	(502, 782)
-					    anchor     	2
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	15
-					    justify    	0
-					    label      	"0..*"
-					    pctDist    	0.554502
-					    height     	31
-					    orientation 	1))
-				    (object RoleView "$UNNAMED$9" @42
-					Parent_View 	@38
-					location   	(141, -4)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E404FD303A2"
-					client     	@38
-					supplier   	@20
-					line_style 	3
-					origin_attachment 	(605, 812)
-					terminal_attachment 	(792, 812))))
-			    (object AssociationViewNew "$UNNAMED$0" @43
-				location   	(605, 650)
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D35F00CD"
-				roleview_list 	(list RoleViews
-				    (object RoleView "$UNNAMED$1" @44
-					Parent_View 	@43
-					location   	(-323, -1206)
-					label      	(object SegLabel @45
-					    Parent_View 	@44
-					    location   	(755, 609)
-					    hidden     	TRUE
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	450
-					    justify    	0
-					    label      	""
-					    pctDist    	0.800000
-					    height     	42
-					    orientation 	0)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E25D36000F8"
-					client     	@43
-					supplier   	@20
-					line_style 	3
-					origin_attachment 	(605, 650)
-					terminal_attachment 	(792, 650))
-				    (object RoleView "addedEObjects" @46
-					Parent_View 	@43
-					location   	(-323, -1206)
-					label      	(object SegLabel @47
-					    Parent_View 	@46
-					    location   	(465, 598)
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	300
-					    justify    	0
-					    label      	"+addedEObjects"
-					    pctDist    	0.753555
-					    height     	53
-					    orientation 	1)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E25D36000F7"
-					client     	@43
-					supplier   	@18
-					line_style 	3
-					origin_attachment 	(605, 650)
-					terminal_attachment 	(418, 650)
-					label      	(object SegLabel @48
-					    Parent_View 	@46
-					    location   	(496, 681)
-					    anchor     	2
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	15
-					    justify    	0
-					    label      	"0..*"
-					    pctDist    	0.582938
-					    height     	31
-					    orientation 	0))))
-			    (object InheritView "" @49
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D3F60016"
-				client     	@4
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(2030, 1361)
-				terminal_attachment 	(2030, 948)
-				drawSupplier 	@21)
-			    (object InheritView "" @50
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E25D4010383"
-				client     	@9
-				supplier   	@20
-				line_style 	3
-				origin_attachment 	(540, 1000)
-				terminal_attachment 	(540, 948)
-				drawSupplier 	@21)
-			    (object AssociationViewNew "$UNNAMED$10" @51
-				location   	(1024, 434)
-				stereotype 	TRUE
-				line_color 	3342489
-				quidu      	"3E7916CE016C"
-				roleview_list 	(list RoleViews
-				    (object RoleView "feature" @52
-					Parent_View 	@51
-					location   	(-16, -366)
-					label      	(object SegLabel @53
-					    Parent_View 	@52
-					    location   	(945, 396)
-					    anchor     	1
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	144
-					    justify    	0
-					    label      	"+feature"
-					    pctDist    	0.467210
-					    height     	80
-					    orientation 	0)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E7916D70043"
-					client     	@51
-					supplier   	@19
-					line_style 	0
-					label      	(object SegLabel @54
-					    Parent_View 	@52
-					    location   	(1093, 437)
-					    anchor     	2
-					    anchor_loc 	1
-					    nlines     	1
-					    max_width  	15
-					    justify    	0
-					    label      	"0..1"
-					    pctDist    	-0.047619
-					    height     	69
-					    orientation 	1))
-				    (object RoleView "$UNNAMED$11" @55
-					Parent_View 	@51
-					location   	(-16, -366)
-					stereotype 	TRUE
-					line_color 	3342489
-					quidu      	"3E7916D7004D"
-					client     	@51
-					supplier   	@20
-					line_style 	0)))
-			    (object NoteView @56
-				location   	(1216, 1808)
-				label      	(object ItemLabel
-				    Parent_View 	@56
-				    location   	(969, 1736)
-				    fill_color 	13434879
-				    nlines     	2
-				    max_width  	459
-				    label      	"All attributes of type JavaObject are transient")
-				line_color 	3342489
-				fill_color 	16777088
-				width      	519
-				height     	156)
-			    (object ClassView "Class" "Logical View::Event::JavaObject" @57
-				ShowCompartmentStereotypes 	TRUE
-				IncludeAttribute 	TRUE
-				IncludeOperation 	TRUE
-				location   	(1504, 2112)
-				label      	(object ItemLabel
-				    Parent_View 	@57
-				    location   	(1196, 2053)
-				    fill_color 	13434879
-				    nlines     	1
-				    max_width  	616
-				    justify    	0
-				    label      	"JavaObject")
-				stereotype 	(object ItemLabel
-				    Parent_View 	@57
-				    location   	(1196, 2003)
-				    fill_color 	13434879
-				    anchor     	10
-				    nlines     	1
-				    max_width  	616
-				    justify    	0
-				    label      	"<<datatype>>")
-				icon_style 	"Icon"
-				line_color 	3342489
-				fill_color 	8454016
-				quidu      	"3BF407B80040"
-				compartment 	(object Compartment
-				    Parent_View 	@57
-				    location   	(1196, 2113)
-				    icon_style 	"Icon"
-				    fill_color 	13434879
-				    anchor     	2
-				    nlines     	2
-				    max_width  	625)
-				width      	634
-				height     	242
-				annotation 	8
-				autoResize 	TRUE)
-			    (object AttachView "" @58
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@56
-				supplier   	@7
-				vertices   	(list Points
-				    (956, 1856)
-				    (268, 1856)
-				    (268, 1647))
-				line_style 	3
-				origin_attachment 	(1216, 1729)
-				terminal_attachment 	(446, 1504))
-			    (object AttachView "" @59
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@56
-				supplier   	@6
-				line_style 	3
-				origin_attachment 	(996, 1729)
-				terminal_attachment 	(996, 1647))
-			    (object AttachView "" @60
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@56
-				supplier   	@5
-				line_style 	3
-				origin_attachment 	(1427, 1729)
-				terminal_attachment 	(1427, 1647))
-			    (object AttachView "" @61
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@56
-				supplier   	@9
-				vertices   	(list Points
-				    (956, 1775)
-				    (490, 1775)
-				    (490, 1336))
-				line_style 	3
-				origin_attachment 	(1216, 1729)
-				terminal_attachment 	(807, 1168))
-			    (object AttachView "" @62
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@56
-				supplier   	@4
-				vertices   	(list Points
-				    (1475, 1828)
-				    (1744, 1828)
-				    (1744, 1647))
-				line_style 	3
-				origin_attachment 	(1216, 1729)
-				terminal_attachment 	(1648, 1504))
-			    (object AttachView "" @63
-				stereotype 	TRUE
-				line_color 	3342489
-				client     	@56
-				supplier   	@8
-				line_style 	3
-				origin_attachment 	(1168, 1729)
-				terminal_attachment 	(1168, 1238)))))))
-	logical_presentations 	(list unit_reference_list
-	    (object ClassDiagram "Main"
-		quid       	"3B1FE4C60175"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list
-		    (object CategoryView "Logical View::Event" @64
-			location   	(288, 256)
-			label      	(object ItemLabel
-			    Parent_View 	@64
-			    location   	(144, 172)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"Event")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"3E2C51040188"
-			width      	300
-			height     	180)
-		    (object CategoryView "Logical View::ecore" @65
-			location   	(736, 272)
-			label      	(object ItemLabel
-			    Parent_View 	@65
-			    location   	(592, 188)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"ecore")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"39A5ED04004E"
-			width      	300
-			height     	180)))))
-    root_subsystem 	(object SubSystem "Component View"
-	quid       	"3B1FE4BB00C6"
-	physical_models 	(list unit_reference_list)
-	physical_presentations 	(list unit_reference_list
-	    (object Module_Diagram "Main"
-		quid       	"3B1FE4C60143"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    process_structure 	(object Processes
-	quid       	"3B1FE4BB00C7"
-	ProcsNDevs 	(list
-	    (object Process_Diagram "Deployment View"
-		quid       	"3B1FE4BB00D9"
-		title      	"Deployment View"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    properties 	(object Properties
-	attributes 	(list Attribute_Set
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"classifierName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"operationName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"attributeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isID"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"referenceName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isResolveProxies"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"DDL"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"DDL"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"DDL"
-			name       	"Directory"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"DataBase"
-			value      	("DataBaseSet" 800))
-		    (object Attribute
-			tool       	"DDL"
-			name       	"DataBaseSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"DDL"
-				name       	"ANSI"
-				value      	800)
-			    (object Attribute
-				tool       	"DDL"
-				name       	"Oracle"
-				value      	801)
-			    (object Attribute
-				tool       	"DDL"
-				name       	"SQLServer"
-				value      	802)
-			    (object Attribute
-				tool       	"DDL"
-				name       	"Sybase"
-				value      	803)
-			    (object Attribute
-				tool       	"DDL"
-				name       	"Watcom"
-				value      	804)))
-		    (object Attribute
-			tool       	"DDL"
-			name       	"PrimaryKeyColumnName"
-			value      	"Id")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"PrimaryKeyColumnType"
-			value      	"NUMBER(5)")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"ViewName"
-			value      	"V_")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"TableName"
-			value      	"T_")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"InheritSuffix"
-			value      	"_V")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"DropClause"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"DDL"
-			name       	"BaseViews"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"DDL"
-			name       	"DDLScriptFilename"
-			value      	"DDL1.SQL")))
-	    (object Attribute
-		tool       	"DDL"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"DDL"
-			name       	"ColumnType"
-			value      	"VARCHAR")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"DDL"
-			name       	"NullsOK"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"DDL"
-			name       	"PrimaryKey"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"DDL"
-			name       	"Unique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"DDL"
-			name       	"CompositeUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"DDL"
-			name       	"CheckConstraint"
-			value      	"")))
-	    (object Attribute
-		tool       	"DDL"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"framework"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"IDL"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"StopOnError"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"Directory"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GeneratePreserveRegions"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"ImplementationType"
-			value      	"")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"ConstValue"
-			value      	"")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateDefaultSpecifier"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"DefaultSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IDLElement"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IDLSpecificationType"
-			value      	("IDLSpecSet" 22))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IDLSpecSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Interface"
-				value      	22)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Typedef"
-				value      	54)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Enumeration"
-				value      	8)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Const"
-				value      	71)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Exception"
-				value      	61)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Struct"
-				value      	51)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Union"
-				value      	81)))))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"CmIdentification"
-			value      	(value Text "  %X%  @(#) plugins/org.eclipse.emf.ecore.event/src/model/event.mdl, emf.ecore, org.eclipse.dev, 20030225_1656SL"))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateIDLModule"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"CmIdentification"
-			value      	(value Text "  %X%  @(#) plugins/org.eclipse.emf.ecore.event/src/model/event.mdl, emf.ecore, org.eclipse.dev, 20030225_1656SL"))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"OperationIsOneWay"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"Context"
-			value      	"")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"Raises"
-			value      	"")))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"CaseSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IsConst"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"ConstValue"
-			value      	"")))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"NameIfUnlabeled"
-			value      	"the_$supplier")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateForwardReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"BoundedHasRelType"
-			value      	("HasRelTypeSet" 47))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"HasRelTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"NameIfUnlabeled"
-			value      	"the_$supplier")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateForwardReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"IDL"
-			name       	"BoundedRoleType"
-			value      	("AssocTypeSet" 47))
-		    (object Attribute
-			tool       	"IDL"
-			name       	"AssocTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"IDL"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Uses"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"GenerateForwardReference"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"IDL"
-			name       	"Directory"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"IDL"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Java"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Directory"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UsePrefixes"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"InstanceVariablePrefix"
-			value      	"m_")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ClassVariablePrefix"
-			value      	"s_")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultAttributeDataType"
-			value      	"int")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultOperationReturnType"
-			value      	"void")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Private"
-				value      	64)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"CmIdentification"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"AdditionalImports"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"CmIdentification"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"AdditionalImports"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Abstract"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Native"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Synchronized"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Transient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Volatile"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Transient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Volatile"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"propertyId"
-		value      	"360000002")
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"DDLScriptFilename"
-			value      	"DDL1.SQL")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"DropClause"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"PrimaryKeyColumnName"
-			value      	"_ID")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"PrimaryKeyColumnType"
-			value      	"NUMBER(5,0)")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"SchemaNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"SchemaNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TableNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TypeNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TypeNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ViewNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ViewNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"VarrayNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"VarrayNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NestedTableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NestedTableNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ObjectTableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ObjectTableNameSuffix"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsSchema"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OID"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"WhereClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CheckConstraint"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypeLength"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypePrecision"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypeScale"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionOfREFS"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"MethodKind"
-			value      	("MethodKindSet" 1903))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OverloadID"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsReadNoDataState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsReadNoProcessState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsWriteNoDataState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsWriteNoProcessState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsSelfish"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerType"
-			value      	("TriggerTypeSet" 1801))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerEvent"
-			value      	("TriggerEventSet" 1601))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerText"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerReferencingNames"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerForEach"
-			value      	("TriggerForEachSet" 1701))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerWhenClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"MethodKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"MapMethod"
-				value      	1901)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"OrderMethod"
-				value      	1902)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Function"
-				value      	1903)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Procedure"
-				value      	1904)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Operator"
-				value      	1905)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Constructor"
-				value      	1906)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Destructor"
-				value      	1907)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Trigger"
-				value      	1908)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Calculated"
-				value      	1909)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"AFTER"
-				value      	1801)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"BEFORE"
-				value      	1802)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSTEAD OF"
-				value      	1803)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerForEachSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"ROW"
-				value      	1701)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"STATEMENT"
-				value      	1702)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerEventSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT"
-				value      	1601)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"UPDATE"
-				value      	1602)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"DELETE"
-				value      	1603)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR UPDATE"
-				value      	1604)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR DELETE"
-				value      	1605)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"UPDATE OR DELETE"
-				value      	1606)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR UPDATE OR DELETE"
-				value      	1607)))))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NullsAllowed"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Precision"
-			value      	"2")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Scale"
-			value      	"6")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsIndex"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsPrimaryKey"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CompositeUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CheckConstraint"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Repository"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"cg"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"UseMSVC"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GeneratePreserveRegions"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ImplementationType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ClassKey"
-			value      	"class")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"PutBodiesInSpec"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDefaultConstructor"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DefaultConstructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExplicitDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateCopyConstructor"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyConstructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExplicitCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDestructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DestructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DestructorKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssignmentOperation"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssignmentVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssignmentKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssignmentOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEqualityOperations"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"EqualityVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"EqualityKind"
-			value      	("FriendKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineEqualityOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateRelationalOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"RelationalVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"RelationalKind"
-			value      	("FriendKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineRelationalOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateStorageMgmtOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StorageMgmtVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineStorageMgmtOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSubscriptOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSubscriptOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDereferenceOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDereferenceOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateIndirectionOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineIndirectionOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateStreamOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StreamVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineStreamOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ThreeKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"KindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FriendKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"DeclareAndDefine"
-				value      	199)
-			    (object Attribute
-				tool       	"cg"
-				name       	"DeclareOnly"
-				value      	205)
-			    (object Attribute
-				tool       	"cg"
-				name       	"DoNotDeclare"
-				value      	206)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"VisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ConstValue"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDefaultSpecifier"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DefaultSpecifier"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CmIdentification"
-			value      	(value Text "  %X%  @(#) plugins/org.eclipse.emf.ecore.event/src/model/event.mdl, emf.ecore, org.eclipse.dev, 20030225_1656SL"))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExtensionlessFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeFormat"
-			value      	(value Text 
-|// $package
-|#include "$file"
-|
-			))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludePrecompiledHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeOrder"
-			value      	"AMIR")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyle"
-			value      	("InliningStyleSet" 207))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"InClassDeclaration"
-				value      	208)
-			    (object Attribute
-				tool       	"cg"
-				name       	"FollowingClassDeclaration"
-				value      	207)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"TypesDefined"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeClosure"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CmIdentification"
-			value      	(value Text "  %X%  @(#) plugins/org.eclipse.emf.ecore.event/src/model/event.mdl, emf.ecore, org.eclipse.dev, 20030225_1656SL"))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExtensionlessFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeFormat"
-			value      	(value Text 
-|// $package
-|#include "$file"
-|
-			))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludePrecompiledHeader"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeOrder"
-			value      	"AMIR")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyle"
-			value      	("InliningStyleSet" 207))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"InClassDeclaration"
-				value      	208)
-			    (object Attribute
-				tool       	"cg"
-				name       	"FollowingClassDeclaration"
-				value      	207)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"TypesDefined"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeClosure"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationKind"
-			value      	("OperationKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsConst"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsExplicit"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"BodyAnnotations"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsOneWay"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Context"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"Raises"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"Ordered"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$supplier")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateForwardReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedHasRelType"
-			value      	("HasRelTypeSet" 47))
-		    (object Attribute
-			tool       	"cg"
-			name       	"HasRelTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$targetClass")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"InstanceArguments"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerGet"
-			value      	"$data.get($keys)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerSet"
-			value      	"$data.set($keys,$value)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedContainer"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassContainer"
-			value      	"$supplier *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassInitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetSetByReference"
-			value      	("QualifiedGetSetByReferenceSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetSetByReferenceSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_GetSetByReference"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateQualifiedGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineQualifiedGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateQualifiedSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedSetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedSetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineQualifiedSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberName"
-			value      	"$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssocClassGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassSetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassSetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssocClassSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassForwardReferenceOnly"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateForwardReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedRoleType"
-			value      	("AssocTypeSet" 47))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtAttributeVisibility"
-				value      	211)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CaseSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"IsReadOnly"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Uses"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"BodyReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateForwardReference"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DirectoryIsOnSearchList"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"PrecompiledHeader"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"IsNamespace"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Indent"
-			value      	2)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Version"
-			value      	"5.0")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCClassTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCClassTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Interface_Part"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Connection_Part"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Class_Factory"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CObjectFunctionality"
-			value      	("CObjectFunctionalitySet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CObjectFunctionalitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dynamic"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dyncreate"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Serial"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOverrideGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDataGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DATA_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateFieldGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_FIELD_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMessageGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMessageMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MESSAGE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEFactory"
-			value      	("OLEFactorySet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEFactorySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Built_in"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Simple"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Licensed"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEName"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEClassID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOLECtlType"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLECtlType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOLETypeLib"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibMajor"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibMinor"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GeneratePropPageIDs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEPropPageIDs"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDispatchMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockProperties"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockFunctions"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DispatchDefValue"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDispIdEnum"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISP_ID_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInterfaceMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"INTERFACE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"InitInterface"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateEventMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockEvents"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateEventSinkMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PropNotifySinks"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateConnectionMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CONNECTION_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"ConnectionPointIID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"InheritanceType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLECommands"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MFCDeclares"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MFCImplements"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"ATL_Declares"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateCOMMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"COM_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateConnectionPointMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CONNECTION_POINT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMsgMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GeneratePropertyMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PROPERTY_MAP_Entries"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCOperationTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCOperationTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Virtual_Override"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Message_Handler"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dispatch_Handler"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Event_Firing_Function"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Event_Sink_Handler"
-				value      	5)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Std_OLE_Method"
-				value      	6)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Command_Parser"
-				value      	7)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Get_Function"
-				value      	8)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Set_Function"
-				value      	9)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Notify_Function"
-				value      	10)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Macro_Generated_Function"
-				value      	11)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MESSAGE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"BodyImage"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateIncludesGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_INCLUDES_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInsertLocation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateIncludesGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_INCLUDES_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInsertLocation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"SCC"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"TypeLibImporter"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"propertyId"
-		value      	"783606378")
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"CreatableSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Private"
-				value      	221)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"PublicNotCreatable"
-				value      	213)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"SingleUse"
-				value      	214)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"GlobalSingleUse"
-				value      	215)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"MultiUse"
-				value      	219)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"GlobalMultiUse"
-				value      	220)))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionBase"
-			value      	"0")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionExplicit"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionCompare"
-			value      	("CompareSet" 202))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Creatable"
-			value      	("CreatableSet" 221))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateInitialization"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateTermination"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"CollectionClass"
-			value      	"Collection")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"CompareSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"None"
-				value      	202)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Binary"
-				value      	203)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Text"
-				value      	204)))))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OperationName"
-			value      	"$operation")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"LibraryName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"AliasName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"IsStatic"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ExitCode"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"IsConst"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"New"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"WithEvents"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Subscript"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"NameIfUnlabeled"
-			value      	"the$supplier")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateGetOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateSetOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateLetOperation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"New"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"WithEvents"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Subscript"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"NameIfUnlabeled"
-			value      	"the$supplier")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateGetOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateSetOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"GenerateLetOperation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImplementsDelegation"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProjectFile"
-			value      	"")))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"VisualStudio"
-		name       	"HiddenTool"
-		value      	FALSE))
-	quid       	"3B1FE4BB00C8"))
diff --git a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/plugin.xml b/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/plugin.xml
deleted file mode 100644
index a0ce824..0000000
--- a/features/org.eclipse.jem-feature/com.ibm.etools.emf.event/plugin.xml
+++ /dev/null
@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<plugin>
-
-   
-<!-- build-level = "20030806_1713SL" *** With fix 10028 merged in. -->
-    <extension
-         point="org.eclipse.emf.ecore.generated_package">
-      <package
-            uri="event.xmi"
-            class="com.ibm.etools.emf.event.impl.EventPackageImpl">
-      </package>
-   </extension>
-
-</plugin>
diff --git a/features/org.eclipse.jem-feature/feature.properties b/features/org.eclipse.jem-feature/feature.properties
deleted file mode 100644
index 4e7791e..0000000
--- a/features/org.eclipse.jem-feature/feature.properties
+++ /dev/null
@@ -1,131 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/Attic/feature.properties,v $
-# $Revision: 1.7 $  $Date: 2005/08/24 23:02:14 $
-#
-
-
-# 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=Java EMF Model
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-# "updateSiteName" property - label for the update site
-updateSiteName=Visual Editor update site
-
-# "description" property - description of the feature
-description=Java EMF Model, including BeanInfo, Java Model, Proxy support (with remote vm and IDE vm support).
-
-# "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\
-January 28, 2004\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 apportioned into plug-ins ("Plug-ins"), plug-in fragments\n\
-("Fragments"), and features ("Features"). A Feature is a bundle of one or\n\
-more Plug-ins and/or Fragments and associated material. Files named\n\
-"feature.xml" may contain a list of the names and version numbers of the\n\
-Plug-ins and/or Fragments associated with a Feature. Plug-ins and Fragments\n\
-are located in directories named "plugins" and Features are located in\n\
-directories named "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\
-   - Subdirectories 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 CPL 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
-########### end of license property ##########################################
diff --git a/features/org.eclipse.jem-feature/feature.xml b/features/org.eclipse.jem-feature/feature.xml
deleted file mode 100644
index c36923b..0000000
--- a/features/org.eclipse.jem-feature/feature.xml
+++ /dev/null
@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jem"
-      label="%featureName"
-      version="1.2.0"
-      provider-name="%providerName"
-      image="eclipse_update_120.jpg">
-
-   <description>
-      %description
-   </description>
-
-   <license url="%licenseURL">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://update.eclipse.org/tools/ve/updates/1.0/"/>
-      <discovery label="%updateSiteName" url="http://update.eclipse.org/tools/ve/updates/1.0/"/>
-   </url>
-
-   <requires>
-      <import feature="org.eclipse.jdt" version="3.1.0"/>
-      <import feature="org.eclipse.emf" version="2.1.0"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.jem.beaninfo"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jem.proxy"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jem"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jem.workbench"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="com.ibm.etools.emf.event"
-         download-size="0"
-         install-size="0"
-         version="3.0.0.2"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jem.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jem.util"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/features/org.eclipse.jem-feature/license.html b/features/org.eclipse.jem-feature/license.html
deleted file mode 100644
index 3259fb9..0000000
--- a/features/org.eclipse.jem-feature/license.html
+++ /dev/null
@@ -1,73 +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>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 &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>
-
-<p>Content may be apportioned into plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;). A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. 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 a Feature.   Plug-ins and Fragments are located in directories
-   named &quot;plugins&quot; and Features are located in directories named &quot;features&quot;.</p>
-  
-<p>Features may also include other Features (&quot;Included Features&quot;). Files named &quot;feature.xml&quot; 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 &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>Subdirectories 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;.
-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>
-</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/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/build.properties b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/build.properties
deleted file mode 100644
index f8d4bb8..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = epl-v10.html,\
-               eclipse_update_120.jpg,\
-               feature.properties,\
-               feature.xml,\
-               license.html
-generate.feature@org.eclipse.jem.source=org.eclipse.jem
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/eclipse_update_120.jpg b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/epl-v10.html b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.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/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/feature.properties b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/feature.properties
deleted file mode 100644
index 0155277..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/feature.properties
+++ /dev/null
@@ -1,131 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/Attic/feature.properties,v $
-# $Revision: 1.7 $  $Date: 2005/08/24 23:02:14 $
-#
-
-
-# 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=Java EMF Model SDK
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-# "updateSiteName" property - label for the update site
-updateSiteName=Visual Editor update site
-
-# "description" property - description of the feature
-description=Binaries and API documentation and source zips for the Visual Editor.
-
-# "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\
-January 28, 2004\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 apportioned into plug-ins ("Plug-ins"), plug-in fragments\n\
-("Fragments"), and features ("Features"). A Feature is a bundle of one or\n\
-more Plug-ins and/or Fragments and associated material. Files named\n\
-"feature.xml" may contain a list of the names and version numbers of the\n\
-Plug-ins and/or Fragments associated with a Feature. Plug-ins and Fragments\n\
-are located in directories named "plugins" and Features are located in\n\
-directories named "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\
-   - Subdirectories 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 CPL 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
-########### end of license property ##########################################
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/feature.xml b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/feature.xml
deleted file mode 100644
index 53776ff..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/feature.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jem.sdk"
-      label="%featureName"
-      version="1.2.0"
-      provider-name="%providerName"
-      image="eclipse_update_120.jpg">
-
-   <description>
-      %description
-   </description>
-
-   <license url="%licenseURL">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://update.eclipse.org/tools/ve/updates/1.0/"/>
-      <discovery label="%updateSiteName" url="http://update.eclipse.org/tools/ve/updates/1.0/"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jem"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jem.source"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jem.sdk"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/license.html b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/license.html
deleted file mode 100644
index 3259fb9..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk-feature/license.html
+++ /dev/null
@@ -1,73 +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>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 &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>
-
-<p>Content may be apportioned into plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;). A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. 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 a Feature.   Plug-ins and Fragments are located in directories
-   named &quot;plugins&quot; and Features are located in directories named &quot;features&quot;.</p>
-  
-<p>Features may also include other Features (&quot;Included Features&quot;). Files named &quot;feature.xml&quot; 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 &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>Subdirectories 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;.
-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>
-</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/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/.project b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/.project
deleted file mode 100644
index 4f232d3..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem.sdk</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/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/META-INF/MANIFEST.MF b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/META-INF/MANIFEST.MF
deleted file mode 100644
index b046177..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jem.sdk
-Bundle-Version: 1.2.0
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.html b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.ini b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.ini
deleted file mode 100644
index a21a3ec..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.ini
+++ /dev/null
@@ -1,29 +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 (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/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.mappings b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/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/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.properties b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.properties
deleted file mode 100644
index 3db39c3..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/about.properties
+++ /dev/null
@@ -1,29 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/Attic/about.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 23:02:14 $
-#
-
-
-# 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=Java EMF Model SDK\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others. 2000, 2004.  All rights reserved.\n\
-Visit http://www.eclipse.org/vep
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/build.properties b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/build.properties
deleted file mode 100644
index de73a29..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/build.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = about.html,\
-               about.ini,\
-               about.mappings,\
-               about.properties,\
-               eclipse32.gif,\
-               plugin.xml,\
-               plugin.properties,\
-               META-INF/
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/eclipse32.gif b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/plugin.properties b/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/plugin.properties
deleted file mode 100644
index 229b18f..0000000
--- a/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/plugin.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/org.eclipse.jem.sdk/Attic/plugin.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 23:02:14 $
-#
-
-
-pluginName=Java EMF Model SDK
-providerName = Eclipse.org
diff --git a/features/org.eclipse.jem-feature/sourceTemplateFeature/build.properties b/features/org.eclipse.jem-feature/sourceTemplateFeature/build.properties
deleted file mode 100644
index d2cc70f..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplateFeature/build.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               epl-v10.html,\
-               eclipse_update_120.jpg,\
-               license.html
-
-
diff --git a/features/org.eclipse.jem-feature/sourceTemplateFeature/eclipse_update_120.jpg b/features/org.eclipse.jem-feature/sourceTemplateFeature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplateFeature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/sourceTemplateFeature/epl-v10.html b/features/org.eclipse.jem-feature/sourceTemplateFeature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/features/org.eclipse.jem-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>
\ No newline at end of file
diff --git a/features/org.eclipse.jem-feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.jem-feature/sourceTemplateFeature/feature.properties
deleted file mode 100644
index 2ef4482..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplateFeature/feature.properties
+++ /dev/null
@@ -1,131 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/sourceTemplateFeature/Attic/feature.properties,v $
-# $Revision: 1.8 $  $Date: 2005/08/24 23:02:14 $
-#
-
-
-# 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=Java EMF Model Source
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-# "updateSiteName" property - label for the update site
-updateSiteName=Visual Editor update site
-
-# "description" property - description of the feature
-description=API documentation and source zips for the Java EMF Model.
-
-# "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\
-January 28, 2004\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 apportioned into plug-ins ("Plug-ins"), plug-in fragments\n\
-("Fragments"), and features ("Features"). A Feature is a bundle of one or\n\
-more Plug-ins and/or Fragments and associated material. Files named\n\
-"feature.xml" may contain a list of the names and version numbers of the\n\
-Plug-ins and/or Fragments associated with a Feature. Plug-ins and Fragments\n\
-are located in directories named "plugins" and Features are located in\n\
-directories named "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\
-   - Subdirectories 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 CPL 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
-########### end of license property ##########################################
diff --git a/features/org.eclipse.jem-feature/sourceTemplateFeature/license.html b/features/org.eclipse.jem-feature/sourceTemplateFeature/license.html
deleted file mode 100644
index 3259fb9..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplateFeature/license.html
+++ /dev/null
@@ -1,73 +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>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 &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>
-
-<p>Content may be apportioned into plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;). A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material. 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 a Feature.   Plug-ins and Fragments are located in directories
-   named &quot;plugins&quot; and Features are located in directories named &quot;features&quot;.</p>
-  
-<p>Features may also include other Features (&quot;Included Features&quot;). Files named &quot;feature.xml&quot; 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 &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>Subdirectories 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;.
-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>
-</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/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.html b/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.html
deleted file mode 100644
index dae413b..0000000
--- a/features/org.eclipse.jem-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>February 24, 2005</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>
\ No newline at end of file
diff --git a/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.ini b/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.ini
deleted file mode 100644
index a21a3ec..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.ini
+++ /dev/null
@@ -1,29 +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 (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/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.mappings b/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/features/org.eclipse.jem-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@
\ No newline at end of file
diff --git a/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.properties b/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.properties
deleted file mode 100644
index e8fa279..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplatePlugin/about.properties
+++ /dev/null
@@ -1,28 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/sourceTemplatePlugin/Attic/about.properties,v $
-# $Revision: 1.6 $  $Date: 2005/08/24 23:02:14 $
-#
-
-# 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=Java EMF Model SDK\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others. 2000, 2004.  All rights reserved.\n\
-Visit http://www.eclipse.org/vep
diff --git a/features/org.eclipse.jem-feature/sourceTemplatePlugin/build.properties b/features/org.eclipse.jem-feature/sourceTemplatePlugin/build.properties
deleted file mode 100644
index 9610287..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplatePlugin/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = plugin.xml,\
-               plugin.properties,\
-               about.html,\
-               about.ini,\
-               about.mappings,\
-               about.properties,\
-               eclipse32.gif,\
-               src/,\
-               META-INF/
-sourcePlugin = true
diff --git a/features/org.eclipse.jem-feature/sourceTemplatePlugin/eclipse32.gif b/features/org.eclipse.jem-feature/sourceTemplatePlugin/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplatePlugin/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/features/org.eclipse.jem-feature/sourceTemplatePlugin/plugin.properties b/features/org.eclipse.jem-feature/sourceTemplatePlugin/plugin.properties
deleted file mode 100644
index 5cd9155..0000000
--- a/features/org.eclipse.jem-feature/sourceTemplatePlugin/plugin.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/features/org.eclipse.jem-feature/sourceTemplatePlugin/Attic/plugin.properties,v $
-# $Revision: 1.4 $  $Date: 2005/08/24 23:02:14 $
-#
-
-
-pluginName = Java EMF Model Source
-providerName = Eclipse.org
diff --git a/features/org.eclipse.jem-feature/.cvsignore b/features/org.eclipse.jst.enterprise_core.feature/.cvsignore
similarity index 100%
copy from features/org.eclipse.jem-feature/.cvsignore
copy to features/org.eclipse.jst.enterprise_core.feature/.cvsignore
diff --git a/features/org.eclipse.jst.enterprise_core.feature/.project b/features/org.eclipse.jst.enterprise_core.feature/.project
new file mode 100644
index 0000000..b522b47
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.enterprise_core.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/features/org.eclipse.jst.enterprise_core.feature/build.properties b/features/org.eclipse.jst.enterprise_core.feature/build.properties
new file mode 100644
index 0000000..e2a1fcf
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.enterprise_core.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.enterprise_core.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.enterprise_core.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.enterprise_core.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.enterprise_core.feature/feature.xml b/features/org.eclipse.jst.enterprise_core.feature/feature.xml
new file mode 100644
index 0000000..a30b771
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/feature.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.enterprise_core.feature"
+      label="org.eclipse.jst.enterprise_core.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+   <license url="license.html">
+      %license
+   </license>
+
+   <requires>
+      <import feature="org.eclipse.platform" version="3.1.1" match="equivalent"/>
+      <import feature="org.eclipse.emf" version="2.1.1" match="equivalent"/>
+      <import feature="org.eclipse.jem" version="1.1.0.1" match="equivalent"/>
+      <import feature="org.eclipse.jst.web_core.feature" version="1.0.0" match="equivalent"/>
+      <import feature="org.eclipse.jst.common_core.feature" version="1.0.0" match="equivalent"/>
+      <import feature="org.eclipse.jst.server_core.feature" version="1.0.0" match="equivalent"/>
+      <import feature="org.eclipse.wst.ws_core.feature" version="1.0.0"/>
+      <import feature="org.uddi4j.feature" version="2.0.3" match="greaterOrEqual"/>
+      <import feature="org.eclipse.emf.ecore.sdo" version="2.1.1" match="equivalent"/>
+   </requires>
+
+   <plugin
+         id="org.eclipse.jst.j2ee.webservice"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.j2ee.ejb"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.j2ee.jca"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/features/org.eclipse.jst.enterprise_core.feature/license.html b/features/org.eclipse.jst.enterprise_core.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/build.properties b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/build.properties
new file mode 100644
index 0000000..f249e9f
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/build.properties
@@ -0,0 +1,16 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+bin.includes =\
+epl-v10.html,\
+eclipse_update_120.jpg,\
+feature.xml,\
+feature.properties,\
+license.html
diff --git a/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/eclipse_update_120.jpg b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/eclipse_update_120.jpg
new file mode 100644
index 0000000..17bb8e3
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/epl-v10.html b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/epl-v10.html
new file mode 100644
index 0000000..022ad29
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/epl-v10.html
@@ -0,0 +1,328 @@
+<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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/license.html b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/license.html
new file mode 100644
index 0000000..c6af966
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplateFeature/license.html
@@ -0,0 +1,79 @@
+<!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>March 17, 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 &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>
+</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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.html b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.html
new file mode 100644
index 0000000..0a8aea0
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.html
@@ -0,0 +1,27 @@
+<!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>February 24, 2005</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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.ini b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.ini
new file mode 100644
index 0000000..2dee36a
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.ini
@@ -0,0 +1,31 @@
+# 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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.mappings b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.mappings
new file mode 100644
index 0000000..0dfb735
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.mappings
@@ -0,0 +1,6 @@
+# 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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.properties b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.properties
new file mode 100644
index 0000000..88a06c5
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/about.properties
@@ -0,0 +1,26 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - 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=Web Standard Tools SDK\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/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/build.properties b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/build.properties
new file mode 100644
index 0000000..f95b457
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/build.properties
@@ -0,0 +1,2 @@
+bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
+sourcePlugin = true
diff --git a/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/eclipse32.gif b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/eclipse32.gif
new file mode 100644
index 0000000..0282f5d
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/eclipse32.gif
Binary files differ
diff --git a/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/eclipse32.png b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/eclipse32.png
new file mode 100644
index 0000000..50ae49d
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/eclipse32.png
Binary files differ
diff --git a/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/plugin.properties b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/plugin.properties
new file mode 100644
index 0000000..165af04
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_core.feature/sourceTemplatePlugin/plugin.properties
@@ -0,0 +1,12 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+pluginName=Web Standard Tools SDK - Common Component
+providerName=Eclipse.org
diff --git a/features/org.eclipse.jst.enterprise_sdk.feature/.cvsignore b/features/org.eclipse.jst.enterprise_sdk.feature/.cvsignore
new file mode 100644
index 0000000..95a8d29
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_sdk.feature/.cvsignore
@@ -0,0 +1,4 @@
+features
+plugins
+build.xml
+org.eclipse.jst.enterprise_sdk.feature_1.0.0.bin.dist.zip
diff --git a/features/org.eclipse.jst.enterprise_sdk.feature/.project b/features/org.eclipse.jst.enterprise_sdk.feature/.project
new file mode 100644
index 0000000..44e6982
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_sdk.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.enterprise_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/features/org.eclipse.jst.enterprise_sdk.feature/build.properties b/features/org.eclipse.jst.enterprise_sdk.feature/build.properties
new file mode 100644
index 0000000..41f5d2a
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_sdk.feature/build.properties
@@ -0,0 +1,8 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+
+generate.feature@org.eclipse.jst.enterprise_ui.feature.source=org.eclipse.jst.enterprise_ui.feature
+
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.enterprise_sdk.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.enterprise_sdk.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.enterprise_sdk.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.enterprise_sdk.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.enterprise_sdk.feature/feature.xml b/features/org.eclipse.jst.enterprise_sdk.feature/feature.xml
new file mode 100644
index 0000000..12cd376
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_sdk.feature/feature.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.enterprise_sdk.feature"
+      label="org.eclipse.jst.enterprise_sdk.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+
+
+   <license url="license.html">
+      %license
+   </license>
+
+
+
+   <includes
+         id="org.eclipse.jst.enterprise_ui.feature.source"
+         version="0.0.0"/>
+
+</feature>
diff --git a/features/org.eclipse.jst.enterprise_sdk.feature/license.html b/features/org.eclipse.jst.enterprise_sdk.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_sdk.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jem-feature/.cvsignore b/features/org.eclipse.jst.enterprise_ui.feature/.cvsignore
similarity index 100%
copy from features/org.eclipse.jem-feature/.cvsignore
copy to features/org.eclipse.jst.enterprise_ui.feature/.cvsignore
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/.project b/features/org.eclipse.jst.enterprise_ui.feature/.project
new file mode 100644
index 0000000..9569563
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.enterprise_ui.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/features/org.eclipse.jst.enterprise_ui.feature/build.properties b/features/org.eclipse.jst.enterprise_ui.feature/build.properties
new file mode 100644
index 0000000..e2a1fcf
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.enterprise_ui.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.enterprise_ui.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.enterprise_ui.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.enterprise_ui.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/license.html b/features/org.eclipse.jst.enterprise_ui.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/build.properties b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/build.properties
new file mode 100644
index 0000000..2ff9234
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/build.properties
@@ -0,0 +1,19 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+bin.includes =\
+epl-v10.html,\
+eclipse_update_120.jpg,\
+feature.xml,\
+feature.properties,\
+license.html
+
+generate.feature@org.eclipse.jst.enterprise_core.feature.source = org.eclipse.jst.enterprise_core.feature
+
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/eclipse_update_120.jpg b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/eclipse_update_120.jpg
new file mode 100644
index 0000000..17bb8e3
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/epl-v10.html b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/epl-v10.html
new file mode 100644
index 0000000..022ad29
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/epl-v10.html
@@ -0,0 +1,328 @@
+<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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/feature.properties
new file mode 100644
index 0000000..01950e3
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/feature.properties
@@ -0,0 +1,132 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - 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=Eclipse JDT Plug-in Developer Resources
+
+# "providerName" property - name of the company that provides the feature
+providerName=Eclipse.org
+
+# "updateSiteName" property - label for the update site
+updateSiteName=Eclipse.org update site
+
+# "description" property - description of the feature
+description=API documentation and source code zips for Eclipse Java development tools.
+
+# "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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/feature.xml b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/feature.xml
new file mode 100644
index 0000000..46aa64d
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/feature.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+	primary="false"
+	label="org.eclipse.jst.enterprise_ui.feature.source"
+	id="org.eclipse.jst.enterprise_ui.feature.source"
+	version="1.0.0">
+	<description>
+		%description
+	</description>
+	<copyright url="http://www.example.com/copyright">
+		%copyright
+	</copyright>
+	<license url="license.html">%license</license>
+	
+	<includes
+         id="org.eclipse.jst.enterprise_core.feature.source"
+         version="0.0.0"/>
+    <plugin
+         id="org.eclipse.jst.enterprise_ui.feature.source"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>   
+                          
+</feature>
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/license.html b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/license.html
new file mode 100644
index 0000000..c6af966
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplateFeature/license.html
@@ -0,0 +1,79 @@
+<!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>March 17, 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 &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>
+</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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.html b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.html
new file mode 100644
index 0000000..0a8aea0
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.html
@@ -0,0 +1,27 @@
+<!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>February 24, 2005</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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.ini b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.ini
new file mode 100644
index 0000000..2dee36a
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.ini
@@ -0,0 +1,31 @@
+# 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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.mappings b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.mappings
new file mode 100644
index 0000000..0dfb735
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.mappings
@@ -0,0 +1,6 @@
+# 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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.properties b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.properties
new file mode 100644
index 0000000..88a06c5
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/about.properties
@@ -0,0 +1,26 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - 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=Web Standard Tools SDK\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/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/build.properties b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/build.properties
new file mode 100644
index 0000000..5895597
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/build.properties
@@ -0,0 +1,3 @@
+
+bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
+sourcePlugin = true
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/eclipse32.gif b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/eclipse32.gif
new file mode 100644
index 0000000..0282f5d
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/eclipse32.gif
Binary files differ
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/eclipse32.png b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/eclipse32.png
new file mode 100644
index 0000000..50ae49d
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/eclipse32.png
Binary files differ
diff --git a/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/plugin.properties b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/plugin.properties
new file mode 100644
index 0000000..0e83dbb
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_ui.feature/sourceTemplatePlugin/plugin.properties
@@ -0,0 +1,12 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+pluginName=Web Standard Tools SDK - WST XML Component
+providerName=Eclipse.org
diff --git a/features/org.eclipse.jst.enterprise_userdoc.feature/.cvsignore b/features/org.eclipse.jst.enterprise_userdoc.feature/.cvsignore
new file mode 100644
index 0000000..4b5f609
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_userdoc.feature/.cvsignore
@@ -0,0 +1,2 @@
+build.xml
+org.eclipse.jst.enterprise_userdoc.feature_1.0.0.jar
diff --git a/features/org.eclipse.jst.enterprise_userdoc.feature/.project b/features/org.eclipse.jst.enterprise_userdoc.feature/.project
new file mode 100644
index 0000000..ffcfb55
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_userdoc.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.enterprise_userdoc.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/features/org.eclipse.jst.enterprise_userdoc.feature/build.properties b/features/org.eclipse.jst.enterprise_userdoc.feature/build.properties
new file mode 100644
index 0000000..e2a1fcf
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_userdoc.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.enterprise_userdoc.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.enterprise_userdoc.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.enterprise_userdoc.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.enterprise_userdoc.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.enterprise_userdoc.feature/feature.xml b/features/org.eclipse.jst.enterprise_userdoc.feature/feature.xml
new file mode 100644
index 0000000..196cfe8
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_userdoc.feature/feature.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.enterprise_userdoc.feature"
+      label="org.eclipse.jst.enterprise_userdoc.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+
+
+   <license url="license.html">
+      %license
+   </license>
+
+   <plugin
+         id="org.eclipse.jst.ejb.doc.user"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+         
+   <plugin
+         id="org.eclipse.jst.j2ee.doc.user"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+         
+   <plugin
+         id="org.eclipse.jst.ws.axis.ui.doc.user"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+         
+   <plugin
+         id="org.eclipse.jst.ws.consumption.ui.doc.user"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+   
+   <plugin
+         id="org.eclipse.jst.ws.doc.user"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+
+
+</feature>
diff --git a/features/org.eclipse.jst.enterprise_userdoc.feature/license.html b/features/org.eclipse.jst.enterprise_userdoc.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.enterprise_userdoc.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jem-feature/.cvsignore b/features/org.eclipse.jst.web_core.feature/.cvsignore
similarity index 100%
copy from features/org.eclipse.jem-feature/.cvsignore
copy to features/org.eclipse.jst.web_core.feature/.cvsignore
diff --git a/features/org.eclipse.jst.web_core.feature/.project b/features/org.eclipse.jst.web_core.feature/.project
new file mode 100644
index 0000000..5eac7ba
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.web_core.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/features/org.eclipse.jst.web_core.feature/build.properties b/features/org.eclipse.jst.web_core.feature/build.properties
new file mode 100644
index 0000000..e2a1fcf
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.web_core.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.web_core.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.web_core.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.web_core.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.web_core.feature/feature.xml b/features/org.eclipse.jst.web_core.feature/feature.xml
new file mode 100644
index 0000000..42ab86e
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/feature.xml
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.web_core.feature"
+      label="org.eclipse.jst.web_core.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+   <license url="license.html">
+      %license
+   </license>
+
+   <requires>
+      <import feature="org.eclipse.platform" version="3.1.1" match="equivalent"/>
+      <import feature="org.eclipse.emf" version="2.1.1" match="equivalent"/>
+      <import feature="org.eclipse.jdt" version="3.1.1" match="equivalent"/>
+      <import feature="org.eclipse.jem" version="1.1.0.1" match="equivalent"/>
+      <import feature="org.eclipse.jst.common_core.feature" version="1.0.0" match="equivalent"/>
+      <import feature="org.eclipse.jst.server_core.feature" version="1.0.0" match="equivalent"/>
+      <import feature="org.eclipse.wst.web_core.feature" version="1.0.0"/>
+   </requires>
+
+   <plugin
+         id="org.eclipse.jst.common.annotations.core"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.common.annotations.controller"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.common.frameworks"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.common.navigator.java"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.j2ee.web"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.jsp.core"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.j2ee.core"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.j2ee"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/features/org.eclipse.jst.web_core.feature/license.html b/features/org.eclipse.jst.web_core.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/build.properties b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/build.properties
new file mode 100644
index 0000000..f249e9f
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/build.properties
@@ -0,0 +1,16 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+bin.includes =\
+epl-v10.html,\
+eclipse_update_120.jpg,\
+feature.xml,\
+feature.properties,\
+license.html
diff --git a/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/eclipse_update_120.jpg b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/eclipse_update_120.jpg
new file mode 100644
index 0000000..17bb8e3
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/epl-v10.html b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/epl-v10.html
new file mode 100644
index 0000000..022ad29
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/epl-v10.html
@@ -0,0 +1,328 @@
+<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/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/license.html b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/license.html
new file mode 100644
index 0000000..c6af966
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplateFeature/license.html
@@ -0,0 +1,79 @@
+<!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>March 17, 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 &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>
+</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/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.html b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.html
new file mode 100644
index 0000000..0a8aea0
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.html
@@ -0,0 +1,27 @@
+<!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>February 24, 2005</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/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.ini b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.ini
new file mode 100644
index 0000000..2dee36a
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.ini
@@ -0,0 +1,31 @@
+# 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/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.mappings b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.mappings
new file mode 100644
index 0000000..0dfb735
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.mappings
@@ -0,0 +1,6 @@
+# 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/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.properties b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.properties
new file mode 100644
index 0000000..88a06c5
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/about.properties
@@ -0,0 +1,26 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - 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=Web Standard Tools SDK\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/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/build.properties b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/build.properties
new file mode 100644
index 0000000..f95b457
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/build.properties
@@ -0,0 +1,2 @@
+bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
+sourcePlugin = true
diff --git a/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/eclipse32.gif b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/eclipse32.gif
new file mode 100644
index 0000000..0282f5d
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/eclipse32.gif
Binary files differ
diff --git a/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/eclipse32.png b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/eclipse32.png
new file mode 100644
index 0000000..50ae49d
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/eclipse32.png
Binary files differ
diff --git a/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/plugin.properties b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/plugin.properties
new file mode 100644
index 0000000..165af04
--- /dev/null
+++ b/features/org.eclipse.jst.web_core.feature/sourceTemplatePlugin/plugin.properties
@@ -0,0 +1,12 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+pluginName=Web Standard Tools SDK - Common Component
+providerName=Eclipse.org
diff --git a/features/org.eclipse.jst.web_sdk.feature/.cvsignore b/features/org.eclipse.jst.web_sdk.feature/.cvsignore
new file mode 100644
index 0000000..262183f
--- /dev/null
+++ b/features/org.eclipse.jst.web_sdk.feature/.cvsignore
@@ -0,0 +1,5 @@
+build.xml
+org.eclipse.jst.web_sdk.feature_1.0.0.bin.dist.zip
+features
+plugins
+dev.properties
diff --git a/features/org.eclipse.jst.web_sdk.feature/.project b/features/org.eclipse.jst.web_sdk.feature/.project
new file mode 100644
index 0000000..0aa6f52
--- /dev/null
+++ b/features/org.eclipse.jst.web_sdk.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.web_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/features/org.eclipse.jst.web_sdk.feature/build.properties b/features/org.eclipse.jst.web_sdk.feature/build.properties
new file mode 100644
index 0000000..018dfd8
--- /dev/null
+++ b/features/org.eclipse.jst.web_sdk.feature/build.properties
@@ -0,0 +1,8 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+
+
+generate.feature@org.eclipse.jst.web_ui.feature.source=org.eclipse.jst.web_ui.feature
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.web_sdk.feature/eclipse_update_120.jpg
similarity index 100%
rename from features/org.eclipse.jem-feature/eclipse_update_120.jpg
rename to features/org.eclipse.jst.web_sdk.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.web_sdk.feature/epl-v10.html
similarity index 100%
rename from features/org.eclipse.jem-feature/epl-v10.html
rename to features/org.eclipse.jst.web_sdk.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.web_sdk.feature/feature.xml b/features/org.eclipse.jst.web_sdk.feature/feature.xml
new file mode 100644
index 0000000..90e373f
--- /dev/null
+++ b/features/org.eclipse.jst.web_sdk.feature/feature.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.web_sdk.feature"
+      label="org.eclipse.jst.web_sdk.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+
+
+   <license url="license.html">
+      %license
+   </license>
+
+
+   <includes
+         id="org.eclipse.jst.web_ui.feature.source"
+         version="0.0.0"/>
+
+</feature>
diff --git a/features/org.eclipse.jst.web_sdk.feature/license.html b/features/org.eclipse.jst.web_sdk.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.web_sdk.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jem-feature/.cvsignore b/features/org.eclipse.jst.web_ui.feature/.cvsignore
similarity index 100%
rename from features/org.eclipse.jem-feature/.cvsignore
rename to features/org.eclipse.jst.web_ui.feature/.cvsignore
diff --git a/features/org.eclipse.jst.web_ui.feature/.project b/features/org.eclipse.jst.web_ui.feature/.project
new file mode 100644
index 0000000..75b7697
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.web_ui.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/features/org.eclipse.jst.web_ui.feature/build.properties b/features/org.eclipse.jst.web_ui.feature/build.properties
new file mode 100644
index 0000000..e2a1fcf
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.web_ui.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.web_ui.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.web_ui.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.web_ui.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.web_ui.feature/feature.xml b/features/org.eclipse.jst.web_ui.feature/feature.xml
new file mode 100644
index 0000000..1a249b5
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/feature.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.web_ui.feature"
+      label="org.eclipse.jst.web_ui.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+   <license url="license.html">
+      %license
+   </license>
+
+   <includes
+         id="org.eclipse.jst.web_userdoc.feature"
+         version="0.0.0"/>
+
+   <requires>
+      <import feature="org.eclipse.jst.web_core.feature" version="1.0.0" match="equivalent"/>
+   </requires>
+
+   <plugin
+         id="org.eclipse.jst.common.annotations.ui"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.jsp.ui"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.jst.jsp.ui.infopop"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/features/org.eclipse.jst.web_ui.feature/license.html b/features/org.eclipse.jst.web_ui.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/license.html
@@ -0,0 +1,93 @@
+<!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/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/build.properties b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/build.properties
new file mode 100644
index 0000000..a7c973f
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/build.properties
@@ -0,0 +1,19 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+bin.includes =\
+epl-v10.html,\
+eclipse_update_120.jpg,\
+feature.xml,\
+feature.properties,\
+license.html
+
+generate.feature@org.eclipse.jst.web_core.feature.source = org.eclipse.jst.web_core.feature
+
diff --git a/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/eclipse_update_120.jpg b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/eclipse_update_120.jpg
new file mode 100644
index 0000000..17bb8e3
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/epl-v10.html b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/epl-v10.html
new file mode 100644
index 0000000..022ad29
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/epl-v10.html
@@ -0,0 +1,328 @@
+<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/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/feature.properties
new file mode 100644
index 0000000..01950e3
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/feature.properties
@@ -0,0 +1,132 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - 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=Eclipse JDT Plug-in Developer Resources
+
+# "providerName" property - name of the company that provides the feature
+providerName=Eclipse.org
+
+# "updateSiteName" property - label for the update site
+updateSiteName=Eclipse.org update site
+
+# "description" property - description of the feature
+description=API documentation and source code zips for Eclipse Java development tools.
+
+# "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/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/feature.xml b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/feature.xml
new file mode 100644
index 0000000..718bee5
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/feature.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+	primary="false"
+	label="org.eclipse.jst.web_ui.feature.source"
+	id="org.eclipse.jst.web_ui.feature.source"
+	version="1.0.0">
+	<description>
+		%description
+	</description>
+	<copyright url="http://www.example.com/copyright">
+		%copyright
+	</copyright>
+	<license url="license.html">%license</license>
+	
+	<includes
+         id="org.eclipse.jst.web_core.feature.source"
+         version="0.0.0"/>
+    <plugin
+         id="org.eclipse.jst.web_ui.feature.source"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"/>   
+                          
+</feature>
diff --git a/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/license.html b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/license.html
new file mode 100644
index 0000000..c6af966
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplateFeature/license.html
@@ -0,0 +1,79 @@
+<!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>March 17, 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 &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>
+</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/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.html b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.html
new file mode 100644
index 0000000..0a8aea0
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.html
@@ -0,0 +1,27 @@
+<!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>February 24, 2005</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/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.ini b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.ini
new file mode 100644
index 0000000..2dee36a
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.ini
@@ -0,0 +1,31 @@
+# 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/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.mappings b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.mappings
new file mode 100644
index 0000000..0dfb735
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.mappings
@@ -0,0 +1,6 @@
+# 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/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.properties b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.properties
new file mode 100644
index 0000000..88a06c5
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/about.properties
@@ -0,0 +1,26 @@
+###############################################################################
+# Copyright (c) 2000, 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - 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=Web Standard Tools SDK\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/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/build.properties b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/build.properties
new file mode 100644
index 0000000..5895597
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/build.properties
@@ -0,0 +1,3 @@
+
+bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
+sourcePlugin = true
diff --git a/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/eclipse32.gif b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/eclipse32.gif
new file mode 100644
index 0000000..0282f5d
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/eclipse32.gif
Binary files differ
diff --git a/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/eclipse32.png b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/eclipse32.png
new file mode 100644
index 0000000..50ae49d
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/eclipse32.png
Binary files differ
diff --git a/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/plugin.properties b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/plugin.properties
new file mode 100644
index 0000000..0e83dbb
--- /dev/null
+++ b/features/org.eclipse.jst.web_ui.feature/sourceTemplatePlugin/plugin.properties
@@ -0,0 +1,12 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+pluginName=Web Standard Tools SDK - WST XML Component
+providerName=Eclipse.org
diff --git a/features/org.eclipse.jem-feature/.cvsignore b/features/org.eclipse.jst.web_userdoc.feature/.cvsignore
similarity index 100%
copy from features/org.eclipse.jem-feature/.cvsignore
copy to features/org.eclipse.jst.web_userdoc.feature/.cvsignore
diff --git a/features/org.eclipse.jst.web_userdoc.feature/.project b/features/org.eclipse.jst.web_userdoc.feature/.project
new file mode 100644
index 0000000..5650104
--- /dev/null
+++ b/features/org.eclipse.jst.web_userdoc.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.jst.web_userdoc.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/features/org.eclipse.jst.web_userdoc.feature/build.properties b/features/org.eclipse.jst.web_userdoc.feature/build.properties
new file mode 100644
index 0000000..e2a1fcf
--- /dev/null
+++ b/features/org.eclipse.jst.web_userdoc.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               eclipse_update_120.jpg,\
+               epl-v10.html,\
+               license.html
+src.includes = build.properties
diff --git a/features/org.eclipse.jem-feature/eclipse_update_120.jpg b/features/org.eclipse.jst.web_userdoc.feature/eclipse_update_120.jpg
similarity index 100%
copy from features/org.eclipse.jem-feature/eclipse_update_120.jpg
copy to features/org.eclipse.jst.web_userdoc.feature/eclipse_update_120.jpg
Binary files differ
diff --git a/features/org.eclipse.jem-feature/epl-v10.html b/features/org.eclipse.jst.web_userdoc.feature/epl-v10.html
similarity index 100%
copy from features/org.eclipse.jem-feature/epl-v10.html
copy to features/org.eclipse.jst.web_userdoc.feature/epl-v10.html
diff --git a/features/org.eclipse.jst.web_userdoc.feature/feature.xml b/features/org.eclipse.jst.web_userdoc.feature/feature.xml
new file mode 100644
index 0000000..3a72606
--- /dev/null
+++ b/features/org.eclipse.jst.web_userdoc.feature/feature.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.jst.web_userdoc.feature"
+      label="org.eclipse.jst.web_userdoc.feature"
+      version="1.0.0">
+
+   <description>
+      %description
+   </description>
+
+
+
+   <license url="license.html">
+      %license
+   </license>
+
+
+</feature>
diff --git a/features/org.eclipse.jst.web_userdoc.feature/license.html b/features/org.eclipse.jst.web_userdoc.feature/license.html
new file mode 100644
index 0000000..2347060
--- /dev/null
+++ b/features/org.eclipse.jst.web_userdoc.feature/license.html
@@ -0,0 +1,93 @@
+<!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/plugins/org.eclipse.jem.beaninfo.ui/.project b/plugins/org.eclipse.jem.beaninfo.ui/.project
deleted file mode 100644
index 3898d56..0000000
--- a/plugins/org.eclipse.jem.beaninfo.ui/.project
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem.beaninfo.ui</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-
-	</buildSpec>
-	<natures>
-	</natures>
-</projectDescription>
diff --git a/plugins/org.eclipse.jem.beaninfo.ui/OBSOLETE-moved to org.eclipse.jem.ui b/plugins/org.eclipse.jem.beaninfo.ui/OBSOLETE-moved to org.eclipse.jem.ui
deleted file mode 100644
index e69de29..0000000
--- a/plugins/org.eclipse.jem.beaninfo.ui/OBSOLETE-moved to org.eclipse.jem.ui
+++ /dev/null
diff --git a/plugins/org.eclipse.jem.beaninfo/.classpath b/plugins/org.eclipse.jem.beaninfo/.classpath
deleted file mode 100644
index c305e18..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.classpath
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="beaninfoCommon"/>
-	<classpathentry kind="src" path="beaninfo"/>
-	<classpathentry output="bin_vm_beaninfovm" kind="src" path="vm_beaninfovm"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/plugins/org.eclipse.jem.beaninfo/.cvsignore b/plugins/org.eclipse.jem.beaninfo/.cvsignore
deleted file mode 100644
index 9b8171d..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin
-build.xml
-bin_beaninfocommon
-bin_vm_beaninfovm
diff --git a/plugins/org.eclipse.jem.beaninfo/.options b/plugins/org.eclipse.jem.beaninfo/.options
deleted file mode 100644
index 5b24652..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.options
+++ /dev/null
@@ -1,3 +0,0 @@
-org.eclipse.jem.beaninfo/debug/logtrace=default
-org.eclipse.jem.beaninfo/debug/logtracefile=default
-org.eclipse.jem.beaninfo/debug/loglevel=default
diff --git a/plugins/org.eclipse.jem.beaninfo/.project b/plugins/org.eclipse.jem.beaninfo/.project
deleted file mode 100644
index 7938070..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.project
+++ /dev/null
@@ -1,51 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem.beaninfo</name>
-	<comment></comment>
-	<projects>
-		<project>com.ibm.etools.emf.event</project>
-		<project>org.apache.xerces</project>
-		<project>org.eclipse.compare</project>
-		<project>org.eclipse.core.resources</project>
-		<project>org.eclipse.core.runtime.compatibility</project>
-		<project>org.eclipse.emf.ecore</project>
-		<project>org.eclipse.emf.ecore.xmi</project>
-		<project>org.eclipse.jdt.core</project>
-		<project>org.eclipse.jdt.launching</project>
-		<project>org.eclipse.jem</project>
-		<project>org.eclipse.jem.proxy</project>
-		<project>org.eclipse.jem.workbench</project>
-		<project>org.eclipse.osgi</project>
-	</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>
-		<buildCommand>
-			<name>com.ibm.rtp.tools.rose.builder</name>
-			<arguments>
-				<dictionary>
-					<key>rose</key>
-					<value></value>
-				</dictionary>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>com.ibm.rtp.tools.rose.toolnature</nature>
-	</natures>
-</projectDescription>
diff --git a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.core.resources.prefs b/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 794b7f6..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Wed May 18 16:43:27 EDT 2005
-eclipse.preferences.version=1
-encoding//beaninfo/org/eclipse/jem/internal/beaninfo/core/messages.properties=8859_1
diff --git a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 4a7c7a1..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,282 +0,0 @@
-#Thu Jun 16 12:45:44 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=error
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=1
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=0
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
-org.eclipse.jdt.core.formatter.comment.format_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
-org.eclipse.jdt.core.formatter.comment.line_length=150
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=150
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=tab
-org.eclipse.jdt.core.formatter.tabulation.size=4
diff --git a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 4cff627..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed May 11 16:20:15 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.ignorelowercasenames=true
-org.eclipse.jdt.ui.importorder=java;javax;org;org.eclipse.wtp;org.eclipse.jem;org.eclipse.ve.internal.cdm;org.eclipse.ve.internal.cde;org.eclipse.ve.internal.jcm;org.eclipse.ve.internal.java;org.eclipse.ve;com;
-org.eclipse.jdt.ui.ondemandthreshold=3
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.pde.core.prefs b/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.pde.core.prefs
deleted file mode 100644
index 59dc168..0000000
--- a/plugins/org.eclipse.jem.beaninfo/.settings/org.eclipse.pde.core.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Thu Jun 16 11:09:08 EDT 2005
-eclipse.preferences.version=1
-selfhosting.binExcludes=/org.eclipse.jem.beaninfo/bin_vm_beaninfovm
diff --git a/plugins/org.eclipse.jem.beaninfo/META-INF/MANIFEST.MF b/plugins/org.eclipse.jem.beaninfo/META-INF/MANIFEST.MF
deleted file mode 100644
index d7bee6a..0000000
--- a/plugins/org.eclipse.jem.beaninfo/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,30 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jem.beaninfo; singleton:=true
-Bundle-Version: 1.2.0
-Bundle-Activator: org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Export-Package: org.eclipse.jem.beaninfo.common,
- org.eclipse.jem.beaninfo.vm,
- org.eclipse.jem.internal.beaninfo,
- org.eclipse.jem.internal.beaninfo.adapters,
- org.eclipse.jem.internal.beaninfo.common,
- org.eclipse.jem.internal.beaninfo.core,
- org.eclipse.jem.internal.beaninfo.impl
-Require-Bundle: org.eclipse.jem.proxy,
- com.ibm.etools.emf.event,
- org.eclipse.jdt.core,
- org.eclipse.jem.workbench,
- org.eclipse.core.resources,
- org.eclipse.emf.ecore,
- org.eclipse.jem,
- org.eclipse.emf.ecore.xmi,
- org.eclipse.osgi,
- org.eclipse.ui;resolution:=optional,
- org.eclipse.core.runtime,
- org.eclipse.debug.core,
- org.eclipse.jem.util,
- org.eclipse.emf.ecore.change
-Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jem.beaninfo/about.html b/plugins/org.eclipse.jem.beaninfo/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/plugins/org.eclipse.jem.beaninfo/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeanDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeanDecorator.java
deleted file mode 100644
index 717b5b0..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeanDecorator.java
+++ /dev/null
@@ -1,432 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: BeanDecorator.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.jem.java.JavaClass;
-import java.net.URL;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Bean Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Equivalent to BeanDecorator in java.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperProperties <em>Merge Super Properties</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperMethods <em>Merge Super Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperEvents <em>Merge Super Events</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectProperties <em>Introspect Properties</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectMethods <em>Introspect Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectEvents <em>Introspect Events</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isDoBeaninfo <em>Do Beaninfo</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedPropertyNames <em>Not Inherited Property Names</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedMethodNames <em>Not Inherited Method Names</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedEventNames <em>Not Inherited Event Names</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getCustomizerClass <em>Customizer Class</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator()
- * @model
- * @generated
- */
-
-
-public interface BeanDecorator extends FeatureDecorator{
-	
-	/**
-	 * Returns the value of the '<em><b>Merge Super Properties</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Merge Super Properties</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the properties of super types be merged when asking for eAllAttributes/eAllReferences.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Merge Super Properties</em>' attribute.
-	 * @see #isSetMergeSuperProperties()
-	 * @see #unsetMergeSuperProperties()
-	 * @see #setMergeSuperProperties(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_MergeSuperProperties()
-	 * @model default="true" unsettable="true"
-	 * @generated
-	 */
-	boolean isMergeSuperProperties();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperProperties <em>Merge Super Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Merge Super Properties</em>' attribute.
-	 * @see #isSetMergeSuperProperties()
-	 * @see #unsetMergeSuperProperties()
-	 * @see #isMergeSuperProperties()
-	 * @generated
-	 */
-	void setMergeSuperProperties(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperProperties <em>Merge Super Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetMergeSuperProperties()
-	 * @see #isMergeSuperProperties()
-	 * @see #setMergeSuperProperties(boolean)
-	 * @generated
-	 */
-	void unsetMergeSuperProperties();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperProperties <em>Merge Super Properties</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Merge Super Properties</em>' attribute is set.
-	 * @see #unsetMergeSuperProperties()
-	 * @see #isMergeSuperProperties()
-	 * @see #setMergeSuperProperties(boolean)
-	 * @generated
-	 */
-	boolean isSetMergeSuperProperties();
-
-	/**
-	 * Returns the value of the '<em><b>Merge Super Methods</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Merge Super Behaviors</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the methods of super types be merged when asking for eAllBehaviors.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Merge Super Methods</em>' attribute.
-	 * @see #isSetMergeSuperMethods()
-	 * @see #unsetMergeSuperMethods()
-	 * @see #setMergeSuperMethods(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_MergeSuperMethods()
-	 * @model default="true" unsettable="true"
-	 * @generated
-	 */
-	boolean isMergeSuperMethods();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperMethods <em>Merge Super Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Merge Super Methods</em>' attribute.
-	 * @see #isSetMergeSuperMethods()
-	 * @see #unsetMergeSuperMethods()
-	 * @see #isMergeSuperMethods()
-	 * @generated
-	 */
-	void setMergeSuperMethods(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperMethods <em>Merge Super Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetMergeSuperMethods()
-	 * @see #isMergeSuperMethods()
-	 * @see #setMergeSuperMethods(boolean)
-	 * @generated
-	 */
-	void unsetMergeSuperMethods();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperMethods <em>Merge Super Methods</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Merge Super Methods</em>' attribute is set.
-	 * @see #unsetMergeSuperMethods()
-	 * @see #isMergeSuperMethods()
-	 * @see #setMergeSuperMethods(boolean)
-	 * @generated
-	 */
-	boolean isSetMergeSuperMethods();
-
-	/**
-	 * Returns the value of the '<em><b>Merge Super Events</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Merge Super Events</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the events of super types be merged when asking for eAllEvents.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Merge Super Events</em>' attribute.
-	 * @see #isSetMergeSuperEvents()
-	 * @see #unsetMergeSuperEvents()
-	 * @see #setMergeSuperEvents(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_MergeSuperEvents()
-	 * @model default="true" unsettable="true"
-	 * @generated
-	 */
-	boolean isMergeSuperEvents();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperEvents <em>Merge Super Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Merge Super Events</em>' attribute.
-	 * @see #isSetMergeSuperEvents()
-	 * @see #unsetMergeSuperEvents()
-	 * @see #isMergeSuperEvents()
-	 * @generated
-	 */
-	void setMergeSuperEvents(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperEvents <em>Merge Super Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetMergeSuperEvents()
-	 * @see #isMergeSuperEvents()
-	 * @see #setMergeSuperEvents(boolean)
-	 * @generated
-	 */
-	void unsetMergeSuperEvents();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperEvents <em>Merge Super Events</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Merge Super Events</em>' attribute is set.
-	 * @see #unsetMergeSuperEvents()
-	 * @see #isMergeSuperEvents()
-	 * @see #setMergeSuperEvents(boolean)
-	 * @generated
-	 */
-	boolean isSetMergeSuperEvents();
-
-	/**
-	 * Returns the value of the '<em><b>Introspect Properties</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Introspect Properties</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the properties from the introspection be added to the class. This allows properties to not be introspected and to use only what is defined explicitly in the JavaClass xmi file.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Introspect Properties</em>' attribute.
-	 * @see #setIntrospectProperties(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_IntrospectProperties()
-	 * @model default="true"
-	 * @generated
-	 */
-	boolean isIntrospectProperties();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectProperties <em>Introspect Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Introspect Properties</em>' attribute.
-	 * @see #isIntrospectProperties()
-	 * @generated
-	 */
-	void setIntrospectProperties(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Introspect Methods</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Introspect Behaviors</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the methods from the introspection be added to the class. This allows methods to not be introspected and to use only what is defined explicitly in the JavaClass xmi file.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Introspect Methods</em>' attribute.
-	 * @see #setIntrospectMethods(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_IntrospectMethods()
-	 * @model default="true"
-	 * @generated
-	 */
-	boolean isIntrospectMethods();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectMethods <em>Introspect Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Introspect Methods</em>' attribute.
-	 * @see #isIntrospectMethods()
-	 * @generated
-	 */
-	void setIntrospectMethods(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Introspect Events</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Introspect Events</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the events from the introspection be added to the class. This allows events to not be introspected and to use only what is defined explicitly in the JavaClass xmi file.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Introspect Events</em>' attribute.
-	 * @see #setIntrospectEvents(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_IntrospectEvents()
-	 * @model default="true"
-	 * @generated
-	 */
-	boolean isIntrospectEvents();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectEvents <em>Introspect Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Introspect Events</em>' attribute.
-	 * @see #isIntrospectEvents()
-	 * @generated
-	 */
-	void setIntrospectEvents(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Customizer Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Customizer Class</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Customizer Class</em>' reference.
-	 * @see #setCustomizerClass(JavaClass)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_CustomizerClass()
-	 * @model
-	 * @generated
-	 */
-	JavaClass getCustomizerClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getCustomizerClass <em>Customizer Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Customizer Class</em>' reference.
-	 * @see #getCustomizerClass()
-	 * @generated
-	 */
-	void setCustomizerClass(JavaClass value);
-
-	/**
-	 * Returns the value of the '<em><b>Do Beaninfo</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Do Beaninfo</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This means do we go and get the beaninfo from the remote vm. If false, then it will not try to get the beaninfo. This doesn't prevent introspection through reflection. That is controled by the separate introspect... attributes.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Do Beaninfo</em>' attribute.
-	 * @see #setDoBeaninfo(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_DoBeaninfo()
-	 * @model default="true"
-	 * @generated
-	 */
-	boolean isDoBeaninfo();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isDoBeaninfo <em>Do Beaninfo</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Do Beaninfo</em>' attribute.
-	 * @see #isDoBeaninfo()
-	 * @generated
-	 */
-	void setDoBeaninfo(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Not Inherited Property Names</b></em>' attribute list.
-	 * The list contents are of type {@link java.lang.String}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the list of inherited property names to not use in getAllProperties(). These names are properties that should not be inherited and should not show through. If the inherited property is not on the list then it will show in getAllProperties().
-	 * <p>
-	 * This list will be empty if all properties are inherited or if the mergeSuperProperties flag is false.
-	 * <p>
-	 * Note: This attribute is not meant to be changed by clients. It is an internal attribute.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Not Inherited Property Names</em>' attribute list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_NotInheritedPropertyNames()
-	 * @model type="java.lang.String"
-	 * @generated
-	 */
-	EList getNotInheritedPropertyNames();
-
-	/**
-	 * Returns the value of the '<em><b>Not Inherited Method Names</b></em>' attribute list.
-	 * The list contents are of type {@link java.lang.String}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the list of inherited method names to not use in eAllOperations(). These names are operations that should not be inherited and should not show through. If the inherited operation is not on the list then it will show in getAllOperations().
-	 * <p>
-	 * This list will be empty if all operations are inherited or if the mergeSuperBehaviors flag is false.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Not Inherited Method Names</em>' attribute list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_NotInheritedMethodNames()
-	 * @model type="java.lang.String"
-	 * @generated
-	 */
-	EList getNotInheritedMethodNames();
-
-	/**
-	 * Returns the value of the '<em><b>Not Inherited Event Names</b></em>' attribute list.
-	 * The list contents are of type {@link java.lang.String}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the list of inherited event names to not use in getAllEvents(). These names are events that should not be inherited and should not show through. If the inherited event is not on the list then it will show in getAllEvents().
-	 * <p>
-	 * This list will be empty if all events are inherited or if the mergeSuperEvents flag is false.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Not Inherited Event Names</em>' attribute list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanDecorator_NotInheritedEventNames()
-	 * @model type="java.lang.String"
-	 * @generated
-	 */
-	EList getNotInheritedEventNames();
-
-	/**
-	 * Return the URL of a 16x16 Color icon
-	 */
-	URL getIconURL();
-	
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeanEvent.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeanEvent.java
deleted file mode 100644
index aabdaf4..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeanEvent.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: BeanEvent.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-import org.eclipse.jem.java.JavaEvent;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Bean Event</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Event from Introspection/Reflection.
- * <p>
- * The BeanEvent will be under the JavaClass' events and allEvents feature. Each BeanEvent will be decorated by an EventSetDecorator.
- * <!-- end-model-doc -->
- *
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getBeanEvent()
- * @model
- * @generated
- */
-
-public interface BeanEvent extends JavaEvent{
-
-	
-	
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeaninfoFactory.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeaninfoFactory.java
deleted file mode 100644
index b1d7b52..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeaninfoFactory.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: BeaninfoFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-
-import org.eclipse.emf.ecore.EFactory;
-/**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage
- * @generated
- */
-
-
-public interface BeaninfoFactory extends EFactory{
-	/**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	BeaninfoFactory eINSTANCE = new org.eclipse.jem.internal.beaninfo.impl.BeaninfoFactoryImpl();
-
-	/**
-	 * Returns a new object of class '<em>Feature Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Feature Decorator</em>'.
-	 * @generated
-	 */
-	FeatureDecorator createFeatureDecorator();
-
-	/**
-	 * Returns a new object of class '<em>Event Set Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Event Set Decorator</em>'.
-	 * @generated
-	 */
-	EventSetDecorator createEventSetDecorator();
-
-	/**
-	 * Returns a new object of class '<em>Method Proxy</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Method Proxy</em>'.
-	 * @generated
-	 */
-	MethodProxy createMethodProxy();
-
-	/**
-	 * Returns a new object of class '<em>Property Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Property Decorator</em>'.
-	 * @generated
-	 */
-	PropertyDecorator createPropertyDecorator();
-
-	/**
-	 * Returns a new object of class '<em>Indexed Property Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Indexed Property Decorator</em>'.
-	 * @generated
-	 */
-	IndexedPropertyDecorator createIndexedPropertyDecorator();
-
-	/**
-	 * Returns a new object of class '<em>Bean Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Bean Decorator</em>'.
-	 * @generated
-	 */
-	BeanDecorator createBeanDecorator();
-
-	/**
-	 * Returns a new object of class '<em>Method Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Method Decorator</em>'.
-	 * @generated
-	 */
-	MethodDecorator createMethodDecorator();
-
-	/**
-	 * Returns a new object of class '<em>Parameter Decorator</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Parameter Decorator</em>'.
-	 * @generated
-	 */
-	ParameterDecorator createParameterDecorator();
-
-	/**
-	 * Returns the package supported by this factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the package supported by this factory.
-	 * @generated
-	 */
-	BeaninfoPackage getBeaninfoPackage();
-
-	/**
-	 * Returns a new object of class '<em>Bean Event</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Bean Event</em>'.
-	 * @generated
-	 */
-	BeanEvent createBeanEvent();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeaninfoPackage.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeaninfoPackage.java
deleted file mode 100644
index fd4599d..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/BeaninfoPackage.java
+++ /dev/null
@@ -1,2692 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: BeaninfoPackage.java,v $
- *  $Revision: 1.10 $  $Date: 2005/09/15 20:09:52 $ 
- */
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EcorePackage;
-
-import org.eclipse.jem.java.JavaRefPackage;
-/**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
- * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
- * </ul>
- * <!-- end-user-doc -->
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoFactory
- * @model kind="package"
- * @generated
- */
-
-public interface BeaninfoPackage extends EPackage{
-	/**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNAME = "beaninfo"; //$NON-NLS-1$
-
-	/**
-	 * The package namespace URI.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_URI = "http:///org/eclipse/jem/internal/beaninfo/beaninfo.ecore"; //$NON-NLS-1$
-
-	/**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_PREFIX = "org.eclipse.jem.internal.beaninfo.beaninfo"; //$NON-NLS-1$
-
-	/**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	BeaninfoPackage eINSTANCE = org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl.init();
-
-	
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl <em>Feature Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getFeatureDecorator()
-	 * @generated
-	 */
-	int FEATURE_DECORATOR = 0;
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__EANNOTATIONS = EcorePackage.EANNOTATION__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__SOURCE = EcorePackage.EANNOTATION__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__DETAILS = EcorePackage.EANNOTATION__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__EMODEL_ELEMENT = EcorePackage.EANNOTATION__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__CONTENTS = EcorePackage.EANNOTATION__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__REFERENCES = EcorePackage.EANNOTATION__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__DISPLAY_NAME = EcorePackage.EANNOTATION_FEATURE_COUNT + 0;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__SHORT_DESCRIPTION = EcorePackage.EANNOTATION_FEATURE_COUNT + 1;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__CATEGORY = EcorePackage.EANNOTATION_FEATURE_COUNT + 2;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__EXPERT = EcorePackage.EANNOTATION_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__HIDDEN = EcorePackage.EANNOTATION_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__PREFERRED = EcorePackage.EANNOTATION_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__MERGE_INTROSPECTION = EcorePackage.EANNOTATION_FEATURE_COUNT + 6;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = EcorePackage.EANNOTATION_FEATURE_COUNT + 7;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__IMPLICITLY_SET_BITS = EcorePackage.EANNOTATION_FEATURE_COUNT + 8;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG = EcorePackage.EANNOTATION_FEATURE_COUNT + 9;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl <em>Event Set Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getEventSetDecorator()
-	 * @generated
-	 */
-	int EVENT_SET_DECORATOR = 2;
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.MethodProxyImpl <em>Method Proxy</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.MethodProxyImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getMethodProxy()
-	 * @generated
-	 */
-	int METHOD_PROXY = 7;
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl <em>Property Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getPropertyDecorator()
-	 * @generated
-	 */
-	int PROPERTY_DECORATOR = 5;
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.IndexedPropertyDecoratorImpl <em>Indexed Property Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.IndexedPropertyDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getIndexedPropertyDecorator()
-	 * @generated
-	 */
-	int INDEXED_PROPERTY_DECORATOR = 6;
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl <em>Bean Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getBeanDecorator()
-	 * @generated
-	 */
-	int BEAN_DECORATOR = 1;
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.MethodDecoratorImpl <em>Method Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.MethodDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getMethodDecorator()
-	 * @generated
-	 */
-	int METHOD_DECORATOR = 3;
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.ParameterDecoratorImpl <em>Parameter Decorator</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.ParameterDecoratorImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getParameterDecorator()
-	 * @generated
-	 */
-	int PARAMETER_DECORATOR = 4;
-	/**
-	 * The meta object id for the '<em>Feature Attribute Value</em>' data type.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getFeatureAttributeValue()
-	 * @generated
-	 */
-	int FEATURE_ATTRIBUTE_VALUE = 11;
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR__ATTRIBUTES = EcorePackage.EANNOTATION_FEATURE_COUNT + 10;
-	/**
-	 * The number of structural features of the the '<em>Feature Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_DECORATOR_FEATURE_COUNT = EcorePackage.EANNOTATION_FEATURE_COUNT + 11;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__EANNOTATIONS = FEATURE_DECORATOR__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__SOURCE = FEATURE_DECORATOR__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__DETAILS = FEATURE_DECORATOR__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__EMODEL_ELEMENT = FEATURE_DECORATOR__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__CONTENTS = FEATURE_DECORATOR__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__REFERENCES = FEATURE_DECORATOR__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__DISPLAY_NAME = FEATURE_DECORATOR__DISPLAY_NAME;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__SHORT_DESCRIPTION = FEATURE_DECORATOR__SHORT_DESCRIPTION;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__CATEGORY = FEATURE_DECORATOR__CATEGORY;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__EXPERT = FEATURE_DECORATOR__EXPERT;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__HIDDEN = FEATURE_DECORATOR__HIDDEN;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__PREFERRED = FEATURE_DECORATOR__PREFERRED;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__MERGE_INTROSPECTION = FEATURE_DECORATOR__MERGE_INTROSPECTION;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__IMPLICITLY_SET_BITS = FEATURE_DECORATOR__IMPLICITLY_SET_BITS;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__IMPLICIT_DECORATOR_FLAG = FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG;
-
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__ATTRIBUTES = FEATURE_DECORATOR__ATTRIBUTES;
-	/**
-	 * The feature id for the '<em><b>Merge Super Properties</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__MERGE_SUPER_PROPERTIES = FEATURE_DECORATOR_FEATURE_COUNT + 0;
-	/**
-	 * The feature id for the '<em><b>Merge Super Methods</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__MERGE_SUPER_METHODS = FEATURE_DECORATOR_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Merge Super Events</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__MERGE_SUPER_EVENTS = FEATURE_DECORATOR_FEATURE_COUNT + 2;
-	/**
-	 * The feature id for the '<em><b>Introspect Properties</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__INTROSPECT_PROPERTIES = FEATURE_DECORATOR_FEATURE_COUNT + 3;
-	/**
-	 * The feature id for the '<em><b>Introspect Methods</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__INTROSPECT_METHODS = FEATURE_DECORATOR_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Introspect Events</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__INTROSPECT_EVENTS = FEATURE_DECORATOR_FEATURE_COUNT + 5;
-	/**
-	 * The feature id for the '<em><b>Do Beaninfo</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__DO_BEANINFO = FEATURE_DECORATOR_FEATURE_COUNT + 6;
-	/**
-	 * The feature id for the '<em><b>Not Inherited Property Names</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES = FEATURE_DECORATOR_FEATURE_COUNT + 7;
-
-	/**
-	 * The feature id for the '<em><b>Not Inherited Method Names</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES = FEATURE_DECORATOR_FEATURE_COUNT + 8;
-
-	/**
-	 * The feature id for the '<em><b>Not Inherited Event Names</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES = FEATURE_DECORATOR_FEATURE_COUNT + 9;
-
-	/**
-	 * The feature id for the '<em><b>Customizer Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR__CUSTOMIZER_CLASS = FEATURE_DECORATOR_FEATURE_COUNT + 10;
-	/**
-	 * The number of structural features of the the '<em>Bean Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_DECORATOR_FEATURE_COUNT = FEATURE_DECORATOR_FEATURE_COUNT + 11;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__EANNOTATIONS = FEATURE_DECORATOR__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__SOURCE = FEATURE_DECORATOR__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__DETAILS = FEATURE_DECORATOR__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__EMODEL_ELEMENT = FEATURE_DECORATOR__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__CONTENTS = FEATURE_DECORATOR__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__REFERENCES = FEATURE_DECORATOR__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__DISPLAY_NAME = FEATURE_DECORATOR__DISPLAY_NAME;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__SHORT_DESCRIPTION = FEATURE_DECORATOR__SHORT_DESCRIPTION;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__CATEGORY = FEATURE_DECORATOR__CATEGORY;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__EXPERT = FEATURE_DECORATOR__EXPERT;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__HIDDEN = FEATURE_DECORATOR__HIDDEN;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__PREFERRED = FEATURE_DECORATOR__PREFERRED;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__MERGE_INTROSPECTION = FEATURE_DECORATOR__MERGE_INTROSPECTION;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__IMPLICITLY_SET_BITS = FEATURE_DECORATOR__IMPLICITLY_SET_BITS;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__IMPLICIT_DECORATOR_FLAG = FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG;
-
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__ATTRIBUTES = FEATURE_DECORATOR__ATTRIBUTES;
-	/**
-	 * The feature id for the '<em><b>In Default Event Set</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET = FEATURE_DECORATOR_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Unicast</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__UNICAST = FEATURE_DECORATOR_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Listener Methods Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY = FEATURE_DECORATOR_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.BeanEventImpl <em>Bean Event</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeanEventImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getBeanEvent()
-	 * @generated
-	 */
-	int BEAN_EVENT = 8;
-	/**
-	 * The feature id for the '<em><b>Add Listener Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__ADD_LISTENER_METHOD = FEATURE_DECORATOR_FEATURE_COUNT + 3;
-	/**
-	 * The feature id for the '<em><b>Listener Methods</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__LISTENER_METHODS = FEATURE_DECORATOR_FEATURE_COUNT + 4;
-	/**
-	 * The feature id for the '<em><b>Listener Type</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__LISTENER_TYPE = FEATURE_DECORATOR_FEATURE_COUNT + 5;
-	/**
-	 * The feature id for the '<em><b>Remove Listener Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD = FEATURE_DECORATOR_FEATURE_COUNT + 6;
-	/**
-	 * The feature id for the '<em><b>Event Adapter Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS = FEATURE_DECORATOR_FEATURE_COUNT + 7;
-
-	/**
-	 * The feature id for the '<em><b>Ser List Mthd</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR__SER_LIST_MTHD = FEATURE_DECORATOR_FEATURE_COUNT + 8;
-
-	/**
-	 * The number of structural features of the the '<em>Event Set Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EVENT_SET_DECORATOR_FEATURE_COUNT = FEATURE_DECORATOR_FEATURE_COUNT + 9;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__EANNOTATIONS = FEATURE_DECORATOR__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__SOURCE = FEATURE_DECORATOR__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__DETAILS = FEATURE_DECORATOR__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__EMODEL_ELEMENT = FEATURE_DECORATOR__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__CONTENTS = FEATURE_DECORATOR__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__REFERENCES = FEATURE_DECORATOR__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__DISPLAY_NAME = FEATURE_DECORATOR__DISPLAY_NAME;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__SHORT_DESCRIPTION = FEATURE_DECORATOR__SHORT_DESCRIPTION;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__CATEGORY = FEATURE_DECORATOR__CATEGORY;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__EXPERT = FEATURE_DECORATOR__EXPERT;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__HIDDEN = FEATURE_DECORATOR__HIDDEN;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__PREFERRED = FEATURE_DECORATOR__PREFERRED;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__MERGE_INTROSPECTION = FEATURE_DECORATOR__MERGE_INTROSPECTION;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__IMPLICITLY_SET_BITS = FEATURE_DECORATOR__IMPLICITLY_SET_BITS;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__IMPLICIT_DECORATOR_FLAG = FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG;
-
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__ATTRIBUTES = FEATURE_DECORATOR__ATTRIBUTES;
-	/**
-	 * The feature id for the '<em><b>Parms Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY = FEATURE_DECORATOR_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Parameter Descriptors</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__PARAMETER_DESCRIPTORS = FEATURE_DECORATOR_FEATURE_COUNT + 1;
-	/**
-	 * The feature id for the '<em><b>Ser Parm Desc</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR__SER_PARM_DESC = FEATURE_DECORATOR_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the the '<em>Method Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_DECORATOR_FEATURE_COUNT = FEATURE_DECORATOR_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__EANNOTATIONS = FEATURE_DECORATOR__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__SOURCE = FEATURE_DECORATOR__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__DETAILS = FEATURE_DECORATOR__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__EMODEL_ELEMENT = FEATURE_DECORATOR__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__CONTENTS = FEATURE_DECORATOR__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__REFERENCES = FEATURE_DECORATOR__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__DISPLAY_NAME = FEATURE_DECORATOR__DISPLAY_NAME;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__SHORT_DESCRIPTION = FEATURE_DECORATOR__SHORT_DESCRIPTION;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__CATEGORY = FEATURE_DECORATOR__CATEGORY;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__EXPERT = FEATURE_DECORATOR__EXPERT;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__HIDDEN = FEATURE_DECORATOR__HIDDEN;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__PREFERRED = FEATURE_DECORATOR__PREFERRED;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__MERGE_INTROSPECTION = FEATURE_DECORATOR__MERGE_INTROSPECTION;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__IMPLICITLY_SET_BITS = FEATURE_DECORATOR__IMPLICITLY_SET_BITS;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__IMPLICIT_DECORATOR_FLAG = FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG;
-
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__ATTRIBUTES = FEATURE_DECORATOR__ATTRIBUTES;
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__NAME = FEATURE_DECORATOR_FEATURE_COUNT + 0;
-	/**
-	 * The feature id for the '<em><b>Parameter</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR__PARAMETER = FEATURE_DECORATOR_FEATURE_COUNT + 1;
-	/**
-	 * The number of structural features of the the '<em>Parameter Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARAMETER_DECORATOR_FEATURE_COUNT = FEATURE_DECORATOR_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__EANNOTATIONS = FEATURE_DECORATOR__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__SOURCE = FEATURE_DECORATOR__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__DETAILS = FEATURE_DECORATOR__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__EMODEL_ELEMENT = FEATURE_DECORATOR__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__CONTENTS = FEATURE_DECORATOR__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__REFERENCES = FEATURE_DECORATOR__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__DISPLAY_NAME = FEATURE_DECORATOR__DISPLAY_NAME;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__SHORT_DESCRIPTION = FEATURE_DECORATOR__SHORT_DESCRIPTION;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__CATEGORY = FEATURE_DECORATOR__CATEGORY;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__EXPERT = FEATURE_DECORATOR__EXPERT;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__HIDDEN = FEATURE_DECORATOR__HIDDEN;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__PREFERRED = FEATURE_DECORATOR__PREFERRED;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__MERGE_INTROSPECTION = FEATURE_DECORATOR__MERGE_INTROSPECTION;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__IMPLICITLY_SET_BITS = FEATURE_DECORATOR__IMPLICITLY_SET_BITS;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG = FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG;
-
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__ATTRIBUTES = FEATURE_DECORATOR__ATTRIBUTES;
-	/**
-	 * The feature id for the '<em><b>Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__BOUND = FEATURE_DECORATOR_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Constrained</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__CONSTRAINED = FEATURE_DECORATOR_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Design Time</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__DESIGN_TIME = FEATURE_DECORATOR_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Always Incompatible</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE = FEATURE_DECORATOR_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Filter Flags</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__FILTER_FLAGS = FEATURE_DECORATOR_FEATURE_COUNT + 4;
-	/**
-	 * The feature id for the '<em><b>Field Read Only</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__FIELD_READ_ONLY = FEATURE_DECORATOR_FEATURE_COUNT + 5;
-
-	/**
-	 * The feature id for the '<em><b>Property Editor Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS = FEATURE_DECORATOR_FEATURE_COUNT + 6;
-	/**
-	 * The feature id for the '<em><b>Read Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__READ_METHOD = FEATURE_DECORATOR_FEATURE_COUNT + 7;
-	/**
-	 * The feature id for the '<em><b>Write Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__WRITE_METHOD = FEATURE_DECORATOR_FEATURE_COUNT + 8;
-	/**
-	 * The feature id for the '<em><b>Field</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR__FIELD = FEATURE_DECORATOR_FEATURE_COUNT + 9;
-
-	/**
-	 * The number of structural features of the the '<em>Property Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_DECORATOR_FEATURE_COUNT = FEATURE_DECORATOR_FEATURE_COUNT + 10;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__EANNOTATIONS = PROPERTY_DECORATOR__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Source</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__SOURCE = PROPERTY_DECORATOR__SOURCE;
-
-	/**
-	 * The feature id for the '<em><b>Details</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__DETAILS = PROPERTY_DECORATOR__DETAILS;
-
-	/**
-	 * The feature id for the '<em><b>EModel Element</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT = PROPERTY_DECORATOR__EMODEL_ELEMENT;
-
-	/**
-	 * The feature id for the '<em><b>Contents</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__CONTENTS = PROPERTY_DECORATOR__CONTENTS;
-
-	/**
-	 * The feature id for the '<em><b>References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__REFERENCES = PROPERTY_DECORATOR__REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__DISPLAY_NAME = PROPERTY_DECORATOR__DISPLAY_NAME;
-	/**
-	 * The feature id for the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__SHORT_DESCRIPTION = PROPERTY_DECORATOR__SHORT_DESCRIPTION;
-	/**
-	 * The feature id for the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__CATEGORY = PROPERTY_DECORATOR__CATEGORY;
-	/**
-	 * The feature id for the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__EXPERT = PROPERTY_DECORATOR__EXPERT;
-
-	/**
-	 * The feature id for the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__HIDDEN = PROPERTY_DECORATOR__HIDDEN;
-
-	/**
-	 * The feature id for the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__PREFERRED = PROPERTY_DECORATOR__PREFERRED;
-
-	/**
-	 * The feature id for the '<em><b>Merge Introspection</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__MERGE_INTROSPECTION = PROPERTY_DECORATOR__MERGE_INTROSPECTION;
-	/**
-	 * The feature id for the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY = PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY;
-
-	/**
-	 * The feature id for the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__IMPLICITLY_SET_BITS = PROPERTY_DECORATOR__IMPLICITLY_SET_BITS;
-
-	/**
-	 * The feature id for the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG = PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG;
-
-	/**
-	 * The feature id for the '<em><b>Attributes</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__ATTRIBUTES = PROPERTY_DECORATOR__ATTRIBUTES;
-	/**
-	 * The feature id for the '<em><b>Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__BOUND = PROPERTY_DECORATOR__BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Constrained</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__CONSTRAINED = PROPERTY_DECORATOR__CONSTRAINED;
-
-	/**
-	 * The feature id for the '<em><b>Design Time</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__DESIGN_TIME = PROPERTY_DECORATOR__DESIGN_TIME;
-
-	/**
-	 * The feature id for the '<em><b>Always Incompatible</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE = PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE;
-
-	/**
-	 * The feature id for the '<em><b>Filter Flags</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__FILTER_FLAGS = PROPERTY_DECORATOR__FILTER_FLAGS;
-	/**
-	 * The feature id for the '<em><b>Field Read Only</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__FIELD_READ_ONLY = PROPERTY_DECORATOR__FIELD_READ_ONLY;
-
-	/**
-	 * The feature id for the '<em><b>Property Editor Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS = PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS;
-	/**
-	 * The feature id for the '<em><b>Read Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__READ_METHOD = PROPERTY_DECORATOR__READ_METHOD;
-	/**
-	 * The feature id for the '<em><b>Write Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__WRITE_METHOD = PROPERTY_DECORATOR__WRITE_METHOD;
-	/**
-	 * The feature id for the '<em><b>Field</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__FIELD = PROPERTY_DECORATOR__FIELD;
-
-	/**
-	 * The feature id for the '<em><b>Indexed Read Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD = PROPERTY_DECORATOR_FEATURE_COUNT + 0;
-	/**
-	 * The feature id for the '<em><b>Indexed Write Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD = PROPERTY_DECORATOR_FEATURE_COUNT + 1;
-	/**
-	 * The number of structural features of the the '<em>Indexed Property Decorator</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INDEXED_PROPERTY_DECORATOR_FEATURE_COUNT = PROPERTY_DECORATOR_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__EANNOTATIONS = EcorePackage.EOPERATION__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__NAME = EcorePackage.EOPERATION__NAME;
-	/**
-	 * The feature id for the '<em><b>Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__ORDERED = EcorePackage.EOPERATION__ORDERED;
-
-	/**
-	 * The feature id for the '<em><b>Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__UNIQUE = EcorePackage.EOPERATION__UNIQUE;
-
-	/**
-	 * The feature id for the '<em><b>Lower Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__LOWER_BOUND = EcorePackage.EOPERATION__LOWER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Upper Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__UPPER_BOUND = EcorePackage.EOPERATION__UPPER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__MANY = EcorePackage.EOPERATION__MANY;
-
-	/**
-	 * The feature id for the '<em><b>Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__REQUIRED = EcorePackage.EOPERATION__REQUIRED;
-
-	/**
-	 * The feature id for the '<em><b>EType</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__ETYPE = EcorePackage.EOPERATION__ETYPE;
-
-	/**
-	 * The feature id for the '<em><b>EContaining Class</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__ECONTAINING_CLASS = EcorePackage.EOPERATION__ECONTAINING_CLASS;
-
-	/**
-	 * The feature id for the '<em><b>EParameters</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__EPARAMETERS = EcorePackage.EOPERATION__EPARAMETERS;
-
-	/**
-	 * The feature id for the '<em><b>EExceptions</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__EEXCEPTIONS = EcorePackage.EOPERATION__EEXCEPTIONS;
-
-	/**
-	 * The feature id for the '<em><b>Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY__METHOD = EcorePackage.EOPERATION_FEATURE_COUNT + 0;
-	/**
-	 * The number of structural features of the the '<em>Method Proxy</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_PROXY_FEATURE_COUNT = EcorePackage.EOPERATION_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__EANNOTATIONS = JavaRefPackage.JAVA_EVENT__EANNOTATIONS;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__NAME = JavaRefPackage.JAVA_EVENT__NAME;
-	/**
-	 * The feature id for the '<em><b>Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__ORDERED = JavaRefPackage.JAVA_EVENT__ORDERED;
-
-	/**
-	 * The feature id for the '<em><b>Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__UNIQUE = JavaRefPackage.JAVA_EVENT__UNIQUE;
-
-	/**
-	 * The feature id for the '<em><b>Lower Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__LOWER_BOUND = JavaRefPackage.JAVA_EVENT__LOWER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Upper Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__UPPER_BOUND = JavaRefPackage.JAVA_EVENT__UPPER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__MANY = JavaRefPackage.JAVA_EVENT__MANY;
-
-	/**
-	 * The feature id for the '<em><b>Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__REQUIRED = JavaRefPackage.JAVA_EVENT__REQUIRED;
-
-	/**
-	 * The feature id for the '<em><b>EType</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__ETYPE = JavaRefPackage.JAVA_EVENT__ETYPE;
-
-	/**
-	 * The feature id for the '<em><b>Changeable</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__CHANGEABLE = JavaRefPackage.JAVA_EVENT__CHANGEABLE;
-
-	/**
-	 * The feature id for the '<em><b>Volatile</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__VOLATILE = JavaRefPackage.JAVA_EVENT__VOLATILE;
-
-	/**
-	 * The feature id for the '<em><b>Transient</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__TRANSIENT = JavaRefPackage.JAVA_EVENT__TRANSIENT;
-
-	/**
-	 * The feature id for the '<em><b>Default Value Literal</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__DEFAULT_VALUE_LITERAL = JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE_LITERAL;
-
-	/**
-	 * The feature id for the '<em><b>Default Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__DEFAULT_VALUE = JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE;
-
-	/**
-	 * The feature id for the '<em><b>Unsettable</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__UNSETTABLE = JavaRefPackage.JAVA_EVENT__UNSETTABLE;
-
-	/**
-	 * The feature id for the '<em><b>Derived</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__DERIVED = JavaRefPackage.JAVA_EVENT__DERIVED;
-
-	/**
-	 * The feature id for the '<em><b>EContaining Class</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT__ECONTAINING_CLASS = JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS;
-
-	/**
-	 * The number of structural features of the the '<em>Bean Event</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEAN_EVENT_FEATURE_COUNT = JavaRefPackage.JAVA_EVENT_FEATURE_COUNT + 0;
-
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.impl.FeatureAttributeMapEntryImpl <em>Feature Attribute Map Entry</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.impl.FeatureAttributeMapEntryImpl
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getFeatureAttributeMapEntry()
-	 * @generated
-	 */
-	int FEATURE_ATTRIBUTE_MAP_ENTRY = 9;
-
-	/**
-	 * The feature id for the '<em><b>Key</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_ATTRIBUTE_MAP_ENTRY__KEY = 0;
-
-	/**
-	 * The feature id for the '<em><b>Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE = 1;
-
-	/**
-	 * The number of structural features of the the '<em>Feature Attribute Map Entry</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FEATURE_ATTRIBUTE_MAP_ENTRY_FEATURE_COUNT = 2;
-
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.beaninfo.ImplicitItem <em>Implicit Item</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.beaninfo.ImplicitItem
-	 * @see org.eclipse.jem.internal.beaninfo.impl.BeaninfoPackageImpl#getImplicitItem()
-	 * @generated
-	 */
-	int IMPLICIT_ITEM = 10;
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator <em>Feature Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Feature Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator
-	 * @generated
-	 */
-	EClass getFeatureDecorator();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Display Name</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#getDisplayName()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_DisplayName();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getShortDescription <em>Short Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Short Description</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#getShortDescription()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_ShortDescription();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getCategory <em>Category</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Category</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#getCategory()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_Category();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isExpert <em>Expert</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Expert</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#isExpert()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_Expert();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isHidden <em>Hidden</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Hidden</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#isHidden()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_Hidden();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isPreferred <em>Preferred</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Preferred</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#isPreferred()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_Preferred();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isMergeIntrospection <em>Merge Introspection</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Merge Introspection</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#isMergeIntrospection()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_MergeIntrospection();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isAttributesExplicitEmpty <em>Attributes Explicit Empty</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Attributes Explicit Empty</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#isAttributesExplicitEmpty()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_AttributesExplicitEmpty();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitlySetBits <em>Implicitly Set Bits</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Implicitly Set Bits</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitlySetBits()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_ImplicitlySetBits();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitDecoratorFlag <em>Implicit Decorator Flag</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Implicit Decorator Flag</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitDecoratorFlag()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EAttribute getFeatureDecorator_ImplicitDecoratorFlag();
-
-	/**
-	 * Returns the meta object for the map '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getAttributes <em>Attributes</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the map '<em>Attributes</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.FeatureDecorator#getAttributes()
-	 * @see #getFeatureDecorator()
-	 * @generated
-	 */
-	EReference getFeatureDecorator_Attributes();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator <em>Event Set Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Event Set Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator
-	 * @generated
-	 */
-	EClass getEventSetDecorator();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isInDefaultEventSet <em>In Default Event Set</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>In Default Event Set</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#isInDefaultEventSet()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EAttribute getEventSetDecorator_InDefaultEventSet();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isUnicast <em>Unicast</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Unicast</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#isUnicast()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EAttribute getEventSetDecorator_Unicast();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isListenerMethodsExplicitEmpty <em>Listener Methods Explicit Empty</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Listener Methods Explicit Empty</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#isListenerMethodsExplicitEmpty()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EAttribute getEventSetDecorator_ListenerMethodsExplicitEmpty();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getAddListenerMethod <em>Add Listener Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Add Listener Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#getAddListenerMethod()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EReference getEventSetDecorator_AddListenerMethod();
-
-	/**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerMethods <em>Listener Methods</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Listener Methods</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerMethods()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EReference getEventSetDecorator_ListenerMethods();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerType <em>Listener Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Listener Type</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerType()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EReference getEventSetDecorator_ListenerType();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getRemoveListenerMethod <em>Remove Listener Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Remove Listener Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#getRemoveListenerMethod()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EReference getEventSetDecorator_RemoveListenerMethod();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getEventAdapterClass <em>Event Adapter Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Event Adapter Class</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#getEventAdapterClass()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EReference getEventSetDecorator_EventAdapterClass();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getSerListMthd <em>Ser List Mthd</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Ser List Mthd</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.EventSetDecorator#getSerListMthd()
-	 * @see #getEventSetDecorator()
-	 * @generated
-	 */
-	EReference getEventSetDecorator_SerListMthd();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.MethodProxy <em>Method Proxy</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Method Proxy</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.MethodProxy
-	 * @generated
-	 */
-	EClass getMethodProxy();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.MethodProxy#getMethod <em>Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.MethodProxy#getMethod()
-	 * @see #getMethodProxy()
-	 * @generated
-	 */
-	EReference getMethodProxy_Method();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator <em>Property Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Property Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator
-	 * @generated
-	 */
-	EClass getPropertyDecorator();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isBound <em>Bound</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Bound</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isBound()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EAttribute getPropertyDecorator_Bound();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isConstrained <em>Constrained</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Constrained</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isConstrained()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EAttribute getPropertyDecorator_Constrained();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isDesignTime <em>Design Time</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Design Time</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isDesignTime()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EAttribute getPropertyDecorator_DesignTime();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isAlwaysIncompatible <em>Always Incompatible</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Always Incompatible</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isAlwaysIncompatible()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EAttribute getPropertyDecorator_AlwaysIncompatible();
-
-	/**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getFilterFlags <em>Filter Flags</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Filter Flags</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#getFilterFlags()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EAttribute getPropertyDecorator_FilterFlags();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isFieldReadOnly <em>Field Read Only</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Field Read Only</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isFieldReadOnly()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EAttribute getPropertyDecorator_FieldReadOnly();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getPropertyEditorClass <em>Property Editor Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Property Editor Class</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#getPropertyEditorClass()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EReference getPropertyDecorator_PropertyEditorClass();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getReadMethod <em>Read Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Read Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#getReadMethod()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EReference getPropertyDecorator_ReadMethod();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getWriteMethod <em>Write Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Write Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#getWriteMethod()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EReference getPropertyDecorator_WriteMethod();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getField <em>Field</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Field</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#getField()
-	 * @see #getPropertyDecorator()
-	 * @generated
-	 */
-	EReference getPropertyDecorator_Field();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator <em>Indexed Property Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Indexed Property Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator
-	 * @generated
-	 */
-	EClass getIndexedPropertyDecorator();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedReadMethod <em>Indexed Read Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Indexed Read Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedReadMethod()
-	 * @see #getIndexedPropertyDecorator()
-	 * @generated
-	 */
-	EReference getIndexedPropertyDecorator_IndexedReadMethod();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedWriteMethod <em>Indexed Write Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Indexed Write Method</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedWriteMethod()
-	 * @see #getIndexedPropertyDecorator()
-	 * @generated
-	 */
-	EReference getIndexedPropertyDecorator_IndexedWriteMethod();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator <em>Bean Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Bean Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator
-	 * @generated
-	 */
-	EClass getBeanDecorator();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperProperties <em>Merge Super Properties</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Merge Super Properties</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperProperties()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_MergeSuperProperties();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperMethods <em>Merge Super Methods</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Merge Super Methods</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperMethods()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_MergeSuperMethods();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperEvents <em>Merge Super Events</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Merge Super Events</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isMergeSuperEvents()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_MergeSuperEvents();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectProperties <em>Introspect Properties</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Introspect Properties</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectProperties()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_IntrospectProperties();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectMethods <em>Introspect Methods</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Introspect Methods</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectMethods()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_IntrospectMethods();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectEvents <em>Introspect Events</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Introspect Events</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isIntrospectEvents()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_IntrospectEvents();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getCustomizerClass <em>Customizer Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Customizer Class</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#getCustomizerClass()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EReference getBeanDecorator_CustomizerClass();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.MethodDecorator <em>Method Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Method Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.MethodDecorator
-	 * @generated
-	 */
-	EClass getMethodDecorator();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#isParmsExplicitEmpty <em>Parms Explicit Empty</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Parms Explicit Empty</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.MethodDecorator#isParmsExplicitEmpty()
-	 * @see #getMethodDecorator()
-	 * @generated
-	 */
-	EAttribute getMethodDecorator_ParmsExplicitEmpty();
-
-	/**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#getParameterDescriptors <em>Parameter Descriptors</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Parameter Descriptors</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.MethodDecorator#getParameterDescriptors()
-	 * @see #getMethodDecorator()
-	 * @generated
-	 */
-	EReference getMethodDecorator_ParameterDescriptors();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#getSerParmDesc <em>Ser Parm Desc</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Ser Parm Desc</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.MethodDecorator#getSerParmDesc()
-	 * @see #getMethodDecorator()
-	 * @generated
-	 */
-	EReference getMethodDecorator_SerParmDesc();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator <em>Parameter Decorator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Parameter Decorator</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.ParameterDecorator
-	 * @generated
-	 */
-	EClass getParameterDecorator();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Name</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.ParameterDecorator#getName()
-	 * @see #getParameterDecorator()
-	 * @generated
-	 */
-	EAttribute getParameterDecorator_Name();
-
-	/**
-	 * Returns the meta object for data type '{@link org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue <em>Feature Attribute Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for data type '<em>Feature Attribute Value</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue
-	 * @model instanceClass="org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue"
-	 * @generated
-	 */
-	EDataType getFeatureAttributeValue();
-
-	/**
-	 * Returns the factory that creates the instances of the model.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the factory that creates the instances of the model.
-	 * @generated
-	 */
-	BeaninfoFactory getBeaninfoFactory();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#isDoBeaninfo <em>Do Beaninfo</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Do Beaninfo</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#isDoBeaninfo()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_DoBeaninfo();
-
-	/**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedPropertyNames <em>Not Inherited Property Names</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Not Inherited Property Names</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedPropertyNames()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_NotInheritedPropertyNames();
-
-	/**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedMethodNames <em>Not Inherited Method Names</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Not Inherited Method Names</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedMethodNames()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_NotInheritedMethodNames();
-
-	/**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedEventNames <em>Not Inherited Event Names</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Not Inherited Event Names</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanDecorator#getNotInheritedEventNames()
-	 * @see #getBeanDecorator()
-	 * @generated
-	 */
-	EAttribute getBeanDecorator_NotInheritedEventNames();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator#getParameter <em>Parameter</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Parameter</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.ParameterDecorator#getParameter()
-	 * @see #getParameterDecorator()
-	 * @generated
-	 */
-	EReference getParameterDecorator_Parameter();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.beaninfo.BeanEvent <em>Bean Event</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Bean Event</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.BeanEvent
-	 * @generated
-	 */
-	EClass getBeanEvent();
-
-	/**
-	 * Returns the meta object for class '{@link java.util.Map.Entry <em>Feature Attribute Map Entry</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Feature Attribute Map Entry</em>'.
-	 * @see java.util.Map.Entry
-	 * @model keyType="java.lang.String"
-	 *        valueType="org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue" valueDataType="org.eclipse.jem.internal.beaninfo.FeatureAttributeValue"
-	 * @generated
-	 */
-	EClass getFeatureAttributeMapEntry();
-
-	/**
-	 * Returns the meta object for the attribute '{@link java.util.Map.Entry <em>Key</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Key</em>'.
-	 * @see java.util.Map.Entry
-	 * @see #getFeatureAttributeMapEntry()
-	 * @generated
-	 */
-	EAttribute getFeatureAttributeMapEntry_Key();
-
-	/**
-	 * Returns the meta object for the attribute '{@link java.util.Map.Entry <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Value</em>'.
-	 * @see java.util.Map.Entry
-	 * @see #getFeatureAttributeMapEntry()
-	 * @generated
-	 */
-	EAttribute getFeatureAttributeMapEntry_Value();
-
-	/**
-	 * Returns the meta object for enum '{@link org.eclipse.jem.internal.beaninfo.ImplicitItem <em>Implicit Item</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for enum '<em>Implicit Item</em>'.
-	 * @see org.eclipse.jem.internal.beaninfo.ImplicitItem
-	 * @generated
-	 */
-	EEnum getImplicitItem();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/EventSetDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/EventSetDecorator.java
deleted file mode 100644
index 817bf47..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/EventSetDecorator.java
+++ /dev/null
@@ -1,326 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: EventSetDecorator.java,v $
- *  $Revision: 1.8 $  $Date: 2005/10/06 15:18:38 $ 
- */
-
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.Method;
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Event Set Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Equivalent to EventSetDecorator in java.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isInDefaultEventSet <em>In Default Event Set</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isUnicast <em>Unicast</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isListenerMethodsExplicitEmpty <em>Listener Methods Explicit Empty</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getAddListenerMethod <em>Add Listener Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerMethods <em>Listener Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerType <em>Listener Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getRemoveListenerMethod <em>Remove Listener Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getEventAdapterClass <em>Event Adapter Class</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getSerListMthd <em>Ser List Mthd</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator()
- * @model
- * @generated
- */
-
-
-public interface EventSetDecorator extends FeatureDecorator{
-	
-	/**
-	 * Returns the value of the '<em><b>In Default Event Set</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>In Default Event Set</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>In Default Event Set</em>' attribute.
-	 * @see #isSetInDefaultEventSet()
-	 * @see #unsetInDefaultEventSet()
-	 * @see #setInDefaultEventSet(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_InDefaultEventSet()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isInDefaultEventSet();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isInDefaultEventSet <em>In Default Event Set</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>In Default Event Set</em>' attribute.
-	 * @see #isSetInDefaultEventSet()
-	 * @see #unsetInDefaultEventSet()
-	 * @see #isInDefaultEventSet()
-	 * @generated
-	 */
-	void setInDefaultEventSet(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isInDefaultEventSet <em>In Default Event Set</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetInDefaultEventSet()
-	 * @see #isInDefaultEventSet()
-	 * @see #setInDefaultEventSet(boolean)
-	 * @generated
-	 */
-	void unsetInDefaultEventSet();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isInDefaultEventSet <em>In Default Event Set</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>In Default Event Set</em>' attribute is set.
-	 * @see #unsetInDefaultEventSet()
-	 * @see #isInDefaultEventSet()
-	 * @see #setInDefaultEventSet(boolean)
-	 * @generated
-	 */
-	boolean isSetInDefaultEventSet();
-
-	/**
-	 * Returns the value of the '<em><b>Unicast</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Unicast</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Unicast</em>' attribute.
-	 * @see #isSetUnicast()
-	 * @see #unsetUnicast()
-	 * @see #setUnicast(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_Unicast()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isUnicast();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isUnicast <em>Unicast</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Unicast</em>' attribute.
-	 * @see #isSetUnicast()
-	 * @see #unsetUnicast()
-	 * @see #isUnicast()
-	 * @generated
-	 */
-	void setUnicast(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isUnicast <em>Unicast</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetUnicast()
-	 * @see #isUnicast()
-	 * @see #setUnicast(boolean)
-	 * @generated
-	 */
-	void unsetUnicast();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isUnicast <em>Unicast</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Unicast</em>' attribute is set.
-	 * @see #unsetUnicast()
-	 * @see #isUnicast()
-	 * @see #setUnicast(boolean)
-	 * @generated
-	 */
-	boolean isSetUnicast();
-
-	/**
-	 * Returns the value of the '<em><b>Listener Methods Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Set true if the listenerMethods feature is explicitly set as empty and is not to have listener methods merged in from BeanInfo or reflection.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Listener Methods Explicit Empty</em>' attribute.
-	 * @see #setListenerMethodsExplicitEmpty(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_ListenerMethodsExplicitEmpty()
-	 * @model
-	 * @generated
-	 */
-	boolean isListenerMethodsExplicitEmpty();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#isListenerMethodsExplicitEmpty <em>Listener Methods Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Listener Methods Explicit Empty</em>' attribute.
-	 * @see #isListenerMethodsExplicitEmpty()
-	 * @generated
-	 */
-	void setListenerMethodsExplicitEmpty(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Add Listener Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Add Listener Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Add Listener Method</em>' reference.
-	 * @see #setAddListenerMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_AddListenerMethod()
-	 * @model required="true"
-	 * @generated
-	 */
-	Method getAddListenerMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getAddListenerMethod <em>Add Listener Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Add Listener Method</em>' reference.
-	 * @see #getAddListenerMethod()
-	 * @generated
-	 */
-	void setAddListenerMethod(Method value);
-
-	/**
-	 * Returns the value of the '<em><b>Listener Methods</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.beaninfo.MethodProxy}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Listener Methods</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * listener methods. If it is desired that the list be explicitly empty and not have BeanInfo set it, then set listenerMethodsExplicitEmpty to true.
-	 * <p>
-	 * ListenerMethods will be decorated with MethodDecorators.
-	 * <p>
-	 * Note: This is a derived setting, which means it will not notify out changes to it. To here changes to it, listen on "serListMthd" notifications instead.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Listener Methods</em>' reference list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_ListenerMethods()
-	 * @model type="org.eclipse.jem.internal.beaninfo.MethodProxy" required="true" transient="true" volatile="true" derived="true"
-	 * @generated
-	 */
-	EList getListenerMethods();
-
-	/**
-	 * Returns the value of the '<em><b>Listener Type</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Listener Type</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Listener Type</em>' reference.
-	 * @see #setListenerType(JavaClass)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_ListenerType()
-	 * @model required="true"
-	 * @generated
-	 */
-	JavaClass getListenerType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getListenerType <em>Listener Type</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Listener Type</em>' reference.
-	 * @see #getListenerType()
-	 * @generated
-	 */
-	void setListenerType(JavaClass value);
-
-	/**
-	 * Returns the value of the '<em><b>Remove Listener Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Remove Listener Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Remove Listener Method</em>' reference.
-	 * @see #setRemoveListenerMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_RemoveListenerMethod()
-	 * @model required="true"
-	 * @generated
-	 */
-	Method getRemoveListenerMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getRemoveListenerMethod <em>Remove Listener Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Remove Listener Method</em>' reference.
-	 * @see #getRemoveListenerMethod()
-	 * @generated
-	 */
-	void setRemoveListenerMethod(Method value);
-
-	/**
-	 * Returns the value of the '<em><b>Event Adapter Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * For some listener interfaces an adapter class is provided that implements default no-op methods, e.g. java.awt.event.FocusEvent which has java.awt.event.FocusAdapter. The Adapter class is provided in a key/value pair on the java.beans.EventSetDescriptor with a key defined in a static final constants EVENTADAPTERCLASS = "eventAdapterClass".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Event Adapter Class</em>' reference.
-	 * @see #setEventAdapterClass(JavaClass)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_EventAdapterClass()
-	 * @model
-	 * @generated
-	 */
-	JavaClass getEventAdapterClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.EventSetDecorator#getEventAdapterClass <em>Event Adapter Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Event Adapter Class</em>' reference.
-	 * @see #getEventAdapterClass()
-	 * @generated
-	 */
-	void setEventAdapterClass(JavaClass value);
-
-	/**
-	 * Returns the value of the '<em><b>Ser List Mthd</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.beaninfo.MethodProxy}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is a private feature. It is used internally only. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Ser List Mthd</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getEventSetDecorator_SerListMthd()
-	 * @model type="org.eclipse.jem.internal.beaninfo.MethodProxy" containment="true" required="true"
-	 * @generated
-	 */
-	EList getSerListMthd();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/FeatureDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/FeatureDecorator.java
deleted file mode 100644
index 9422ab0..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/FeatureDecorator.java
+++ /dev/null
@@ -1,491 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: FeatureDecorator.java,v $
- *  $Revision: 1.9 $  $Date: 2005/09/15 20:09:51 $ 
- */
-
-
-import org.eclipse.emf.common.util.EMap;
-import org.eclipse.emf.ecore.EAnnotation;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Feature Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Equivalent to FeatureDescriptor in java.
- * <p>
- * Note: If any attribute is explicitly set then the BeanInfo/Reflection will not be merged into the decorator. This provides a way of overriding the BeanInfos. Also for any many-valued attribute, if it is desired to have it explicitly empty and not have BeanInfo fill it in, there will be another attribute named of the form "attibutueExplicitEmpty" If this is true then the BeanInfo will not merge in and will leave it empty.
- * <p>
- * These comments about merging apply to all subclasses of this decorator too. 
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getShortDescription <em>Short Description</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getCategory <em>Category</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isExpert <em>Expert</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isHidden <em>Hidden</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isPreferred <em>Preferred</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isMergeIntrospection <em>Merge Introspection</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isAttributesExplicitEmpty <em>Attributes Explicit Empty</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitlySetBits <em>Implicitly Set Bits</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitDecoratorFlag <em>Implicit Decorator Flag</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getAttributes <em>Attributes</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator()
- * @model
- * @generated
- */
-
-
-public interface FeatureDecorator extends EAnnotation{
-		
-	/**
-	 * Returns the value of the '<em><b>Display Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Display Name</em>' attribute.
-	 * @see #isSetDisplayName()
-	 * @see #unsetDisplayName()
-	 * @see #setDisplayName(String)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_DisplayName()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	String getDisplayName();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getDisplayName <em>Display Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Display Name</em>' attribute.
-	 * @see #isSetDisplayName()
-	 * @see #unsetDisplayName()
-	 * @see #getDisplayName()
-	 * @generated
-	 */
-	void setDisplayName(String value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getDisplayName <em>Display Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetDisplayName()
-	 * @see #getDisplayName()
-	 * @see #setDisplayName(String)
-	 * @generated
-	 */
-	void unsetDisplayName();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getDisplayName <em>Display Name</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Display Name</em>' attribute is set.
-	 * @see #unsetDisplayName()
-	 * @see #getDisplayName()
-	 * @see #setDisplayName(String)
-	 * @generated
-	 */
-	boolean isSetDisplayName();
-
-	/**
-	 * Returns the value of the '<em><b>Short Description</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Short Description</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Short Description</em>' attribute.
-	 * @see #isSetShortDescription()
-	 * @see #unsetShortDescription()
-	 * @see #setShortDescription(String)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_ShortDescription()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	String getShortDescription();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getShortDescription <em>Short Description</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Short Description</em>' attribute.
-	 * @see #isSetShortDescription()
-	 * @see #unsetShortDescription()
-	 * @see #getShortDescription()
-	 * @generated
-	 */
-	void setShortDescription(String value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getShortDescription <em>Short Description</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetShortDescription()
-	 * @see #getShortDescription()
-	 * @see #setShortDescription(String)
-	 * @generated
-	 */
-	void unsetShortDescription();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getShortDescription <em>Short Description</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Short Description</em>' attribute is set.
-	 * @see #unsetShortDescription()
-	 * @see #getShortDescription()
-	 * @see #setShortDescription(String)
-	 * @generated
-	 */
-	boolean isSetShortDescription();
-
-	/**
-	 * Returns the value of the '<em><b>Category</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Category</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Category</em>' attribute.
-	 * @see #setCategory(String)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_Category()
-	 * @model
-	 * @generated
-	 */
-	String getCategory();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getCategory <em>Category</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Category</em>' attribute.
-	 * @see #getCategory()
-	 * @generated
-	 */
-	void setCategory(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Expert</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Expert</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Expert</em>' attribute.
-	 * @see #isSetExpert()
-	 * @see #unsetExpert()
-	 * @see #setExpert(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_Expert()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isExpert();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isExpert <em>Expert</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Expert</em>' attribute.
-	 * @see #isSetExpert()
-	 * @see #unsetExpert()
-	 * @see #isExpert()
-	 * @generated
-	 */
-	void setExpert(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isExpert <em>Expert</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetExpert()
-	 * @see #isExpert()
-	 * @see #setExpert(boolean)
-	 * @generated
-	 */
-	void unsetExpert();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isExpert <em>Expert</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Expert</em>' attribute is set.
-	 * @see #unsetExpert()
-	 * @see #isExpert()
-	 * @see #setExpert(boolean)
-	 * @generated
-	 */
-	boolean isSetExpert();
-
-	/**
-	 * Returns the value of the '<em><b>Hidden</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Hidden</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Hidden</em>' attribute.
-	 * @see #isSetHidden()
-	 * @see #unsetHidden()
-	 * @see #setHidden(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_Hidden()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isHidden();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isHidden <em>Hidden</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Hidden</em>' attribute.
-	 * @see #isSetHidden()
-	 * @see #unsetHidden()
-	 * @see #isHidden()
-	 * @generated
-	 */
-	void setHidden(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isHidden <em>Hidden</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetHidden()
-	 * @see #isHidden()
-	 * @see #setHidden(boolean)
-	 * @generated
-	 */
-	void unsetHidden();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isHidden <em>Hidden</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Hidden</em>' attribute is set.
-	 * @see #unsetHidden()
-	 * @see #isHidden()
-	 * @see #setHidden(boolean)
-	 * @generated
-	 */
-	boolean isSetHidden();
-
-	/**
-	 * Returns the value of the '<em><b>Preferred</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Preferred</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Preferred</em>' attribute.
-	 * @see #isSetPreferred()
-	 * @see #unsetPreferred()
-	 * @see #setPreferred(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_Preferred()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isPreferred();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isPreferred <em>Preferred</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Preferred</em>' attribute.
-	 * @see #isSetPreferred()
-	 * @see #unsetPreferred()
-	 * @see #isPreferred()
-	 * @generated
-	 */
-	void setPreferred(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isPreferred <em>Preferred</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetPreferred()
-	 * @see #isPreferred()
-	 * @see #setPreferred(boolean)
-	 * @generated
-	 */
-	void unsetPreferred();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isPreferred <em>Preferred</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Preferred</em>' attribute is set.
-	 * @see #unsetPreferred()
-	 * @see #isPreferred()
-	 * @see #setPreferred(boolean)
-	 * @generated
-	 */
-	boolean isSetPreferred();
-
-	/**
-	 * Returns the value of the '<em><b>Merge Introspection</b></em>' attribute.
-	 * The default value is <code>"true"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Merge Introspection</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Should the introspection results be merged into this decorator. If this is set to false, then the introspection results are ignored for this particular decorator. This is an internal feature simply to allow desired override capabilities. Customers would use it to prevent ANY introspection/reflection from occurring.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Merge Introspection</em>' attribute.
-	 * @see #setMergeIntrospection(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_MergeIntrospection()
-	 * @model default="true"
-	 * @generated
-	 */
-	boolean isMergeIntrospection();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isMergeIntrospection <em>Merge Introspection</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Merge Introspection</em>' attribute.
-	 * @see #isMergeIntrospection()
-	 * @generated
-	 */
-	void setMergeIntrospection(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Attributes Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The attributes are explicitly set as empty and not retrieved from the beaninfo/reflection. Customers should set this if they want the list of attributes to be empty and not merged with the BeanInfo results. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Attributes Explicit Empty</em>' attribute.
-	 * @see #setAttributesExplicitEmpty(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_AttributesExplicitEmpty()
-	 * @model
-	 * @generated
-	 */
-	boolean isAttributesExplicitEmpty();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#isAttributesExplicitEmpty <em>Attributes Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attributes Explicit Empty</em>' attribute.
-	 * @see #isAttributesExplicitEmpty()
-	 * @generated
-	 */
-	void setAttributesExplicitEmpty(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Implicitly Set Bits</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * A bitflag for which attributes have been set by BeanInfo/Reflection.
-	 * <p>
-	 * This is an internal attribute that is used by the BeanInfo maintanance. It is not meant to be used by customers.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Implicitly Set Bits</em>' attribute.
-	 * @see #setImplicitlySetBits(long)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_ImplicitlySetBits()
-	 * @model
-	 * @generated
-	 */
-	long getImplicitlySetBits();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitlySetBits <em>Implicitly Set Bits</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Implicitly Set Bits</em>' attribute.
-	 * @see #getImplicitlySetBits()
-	 * @generated
-	 */
-	void setImplicitlySetBits(long value);
-
-	/**
-	 * Returns the value of the '<em><b>Implicit Decorator Flag</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.jem.internal.beaninfo.ImplicitItem}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Is this decorator/feature implicit. This means created by Introspection/Reflection and not by customer.
-	 * <p>
-	 * This is an internal attribute that is used by the BeanInfo maintanance. It is not meant to be used by customers.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Implicit Decorator Flag</em>' attribute.
-	 * @see org.eclipse.jem.internal.beaninfo.ImplicitItem
-	 * @see #setImplicitDecoratorFlag(ImplicitItem)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_ImplicitDecoratorFlag()
-	 * @model
-	 * @generated
-	 */
-	ImplicitItem getImplicitDecoratorFlag();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.FeatureDecorator#getImplicitDecoratorFlag <em>Implicit Decorator Flag</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Implicit Decorator Flag</em>' attribute.
-	 * @see org.eclipse.jem.internal.beaninfo.ImplicitItem
-	 * @see #getImplicitDecoratorFlag()
-	 * @generated
-	 */
-	void setImplicitDecoratorFlag(ImplicitItem value);
-
-	/**
-	 * Returns the value of the '<em><b>Attributes</b></em>' map.
-	 * The key is of type {@link java.lang.String},
-	 * and the value is of type {@link org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue},
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attributes</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Feature attributes. Key/value pairs. If it is desired that the feature attributes is explicitly empty and not have BeanInfo/reflection set it, set attributesExplicitEmpty to true.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Attributes</em>' map.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getFeatureDecorator_Attributes()
-	 * @model mapType="org.eclipse.jem.internal.beaninfo.FeatureAttributeMapEntry" keyType="java.lang.String" valueType="org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue"
-	 * @generated
-	 */
-	EMap getAttributes();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	String getName();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/ImplicitItem.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/ImplicitItem.java
deleted file mode 100644
index c5e5b4b..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/ImplicitItem.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.emf.common.util.AbstractEnumerator;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Implicit Item</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * This enum is an internal enum. It is used by BeanInfo for cache maintenance.
- * <p>
- * This enum is not meant to be used by clients.
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getImplicitItem()
- * @model
- * @generated
- */
-public final class ImplicitItem extends AbstractEnumerator {
-	/**
-	 * The '<em><b>NOT IMPLICIT</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Means this decorator is not implicit. That is it was created by customer.
-	 * <!-- end-model-doc -->
-	 * @see #NOT_IMPLICIT_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int NOT_IMPLICIT = 0;
-
-	/**
-	 * The '<em><b>IMPLICIT DECORATOR</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This means that the decorator is implicit. That is it was not created by the customer.
-	 * <!-- end-model-doc -->
-	 * @see #IMPLICIT_DECORATOR_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int IMPLICIT_DECORATOR = 1;
-
-	/**
-	 * The '<em><b>IMPLICIT DECORATOR AND FEATURE</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This means the decorator and the feature where implicit. That is they were not created by the customer.
-	 * <!-- end-model-doc -->
-	 * @see #IMPLICIT_DECORATOR_AND_FEATURE_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int IMPLICIT_DECORATOR_AND_FEATURE = 2;
-
-	/**
-	 * The '<em><b>NOT IMPLICIT</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #NOT_IMPLICIT
-	 * @generated
-	 * @ordered
-	 */
-	public static final ImplicitItem NOT_IMPLICIT_LITERAL = new ImplicitItem(NOT_IMPLICIT, "NOT_IMPLICIT");
-
-	/**
-	 * The '<em><b>IMPLICIT DECORATOR</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #IMPLICIT_DECORATOR
-	 * @generated
-	 * @ordered
-	 */
-	public static final ImplicitItem IMPLICIT_DECORATOR_LITERAL = new ImplicitItem(IMPLICIT_DECORATOR, "IMPLICIT_DECORATOR");
-
-	/**
-	 * The '<em><b>IMPLICIT DECORATOR AND FEATURE</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #IMPLICIT_DECORATOR_AND_FEATURE
-	 * @generated
-	 * @ordered
-	 */
-	public static final ImplicitItem IMPLICIT_DECORATOR_AND_FEATURE_LITERAL = new ImplicitItem(IMPLICIT_DECORATOR_AND_FEATURE, "IMPLICIT_DECORATOR_AND_FEATURE");
-
-	/**
-	 * An array of all the '<em><b>Implicit Item</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static final ImplicitItem[] VALUES_ARRAY =
-		new ImplicitItem[] {
-			NOT_IMPLICIT_LITERAL,
-			IMPLICIT_DECORATOR_LITERAL,
-			IMPLICIT_DECORATOR_AND_FEATURE_LITERAL,
-		};
-
-	/**
-	 * A public read-only list of all the '<em><b>Implicit Item</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
-
-	/**
-	 * Returns the '<em><b>Implicit Item</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static ImplicitItem get(String name) {
-		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
-			ImplicitItem result = VALUES_ARRAY[i];
-			if (result.toString().equals(name)) {
-				return result;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the '<em><b>Implicit Item</b></em>' literal with the specified value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static ImplicitItem get(int value) {
-		switch (value) {
-			case NOT_IMPLICIT: return NOT_IMPLICIT_LITERAL;
-			case IMPLICIT_DECORATOR: return IMPLICIT_DECORATOR_LITERAL;
-			case IMPLICIT_DECORATOR_AND_FEATURE: return IMPLICIT_DECORATOR_AND_FEATURE_LITERAL;
-		}
-		return null;	
-	}
-
-	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private ImplicitItem(int value, String name) {
-		super(value, name);
-	}
-
-} //ImplicitItem
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/IndexedPropertyDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/IndexedPropertyDecorator.java
deleted file mode 100644
index 2ea23b7..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/IndexedPropertyDecorator.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: IndexedPropertyDecorator.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-
-import org.eclipse.jem.java.Method;
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Indexed Property Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Equivalent to IndexedPropertyDecorator
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedReadMethod <em>Indexed Read Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedWriteMethod <em>Indexed Write Method</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getIndexedPropertyDecorator()
- * @model
- * @generated
- */
-
-
-public interface IndexedPropertyDecorator extends PropertyDecorator{
-	/**
-	 * Returns the value of the '<em><b>Indexed Read Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Indexed Read Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Indexed Read Method</em>' reference.
-	 * @see #isSetIndexedReadMethod()
-	 * @see #unsetIndexedReadMethod()
-	 * @see #setIndexedReadMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getIndexedPropertyDecorator_IndexedReadMethod()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	Method getIndexedReadMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedReadMethod <em>Indexed Read Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Indexed Read Method</em>' reference.
-	 * @see #isSetIndexedReadMethod()
-	 * @see #unsetIndexedReadMethod()
-	 * @see #getIndexedReadMethod()
-	 * @generated
-	 */
-	void setIndexedReadMethod(Method value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedReadMethod <em>Indexed Read Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetIndexedReadMethod()
-	 * @see #getIndexedReadMethod()
-	 * @see #setIndexedReadMethod(Method)
-	 * @generated
-	 */
-	void unsetIndexedReadMethod();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedReadMethod <em>Indexed Read Method</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Indexed Read Method</em>' reference is set.
-	 * @see #unsetIndexedReadMethod()
-	 * @see #getIndexedReadMethod()
-	 * @see #setIndexedReadMethod(Method)
-	 * @generated
-	 */
-	boolean isSetIndexedReadMethod();
-
-	/**
-	 * Returns the value of the '<em><b>Indexed Write Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Indexed Write Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Indexed Write Method</em>' reference.
-	 * @see #isSetIndexedWriteMethod()
-	 * @see #unsetIndexedWriteMethod()
-	 * @see #setIndexedWriteMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getIndexedPropertyDecorator_IndexedWriteMethod()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	Method getIndexedWriteMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedWriteMethod <em>Indexed Write Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Indexed Write Method</em>' reference.
-	 * @see #isSetIndexedWriteMethod()
-	 * @see #unsetIndexedWriteMethod()
-	 * @see #getIndexedWriteMethod()
-	 * @generated
-	 */
-	void setIndexedWriteMethod(Method value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedWriteMethod <em>Indexed Write Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetIndexedWriteMethod()
-	 * @see #getIndexedWriteMethod()
-	 * @see #setIndexedWriteMethod(Method)
-	 * @generated
-	 */
-	void unsetIndexedWriteMethod();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator#getIndexedWriteMethod <em>Indexed Write Method</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Indexed Write Method</em>' reference is set.
-	 * @see #unsetIndexedWriteMethod()
-	 * @see #getIndexedWriteMethod()
-	 * @see #setIndexedWriteMethod(Method)
-	 * @generated
-	 */
-	boolean isSetIndexedWriteMethod();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/MethodDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/MethodDecorator.java
deleted file mode 100644
index a8147e6..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/MethodDecorator.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: MethodDecorator.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-
-import org.eclipse.emf.common.util.EList;
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Method Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Equivalent to MethodDecorator in java.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#isParmsExplicitEmpty <em>Parms Explicit Empty</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#getParameterDescriptors <em>Parameter Descriptors</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#getSerParmDesc <em>Ser Parm Desc</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getMethodDecorator()
- * @model
- * @generated
- */
-
-
-public interface MethodDecorator extends FeatureDecorator{
-	/**
-	 * Returns the value of the '<em><b>Parms Explicit Empty</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Set true if the parms feature is explicitly set as empty and is not to have parameters merged in from BeanInfo or reflection.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Parms Explicit Empty</em>' attribute.
-	 * @see #setParmsExplicitEmpty(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getMethodDecorator_ParmsExplicitEmpty()
-	 * @model
-	 * @generated
-	 */
-	boolean isParmsExplicitEmpty();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.MethodDecorator#isParmsExplicitEmpty <em>Parms Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Parms Explicit Empty</em>' attribute.
-	 * @see #isParmsExplicitEmpty()
-	 * @generated
-	 */
-	void setParmsExplicitEmpty(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Parameter Descriptors</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.beaninfo.ParameterDecorator}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Parameter Descriptors</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the parameter descriptors list.
-	 * <p>
-	 * Note: This is a derived setting, which means it will not notify out changes to it. To here changes to it, listen on "serParmDesc" notifications instead.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Parameter Descriptors</em>' reference list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getMethodDecorator_ParameterDescriptors()
-	 * @model type="org.eclipse.jem.internal.beaninfo.ParameterDecorator" transient="true" volatile="true" derived="true"
-	 * @generated
-	 */
-	EList getParameterDescriptors();
-
-	/**
-	 * Returns the value of the '<em><b>Ser Parm Desc</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.beaninfo.ParameterDecorator}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Ser Parm Desc</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is a private feature. It is used internally only. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Ser Parm Desc</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getMethodDecorator_SerParmDesc()
-	 * @model type="org.eclipse.jem.internal.beaninfo.ParameterDecorator" containment="true"
-	 * @generated
-	 */
-	EList getSerParmDesc();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/MethodProxy.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/MethodProxy.java
deleted file mode 100644
index 8743a2a..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/MethodProxy.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: MethodProxy.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-
-import org.eclipse.emf.ecore.EOperation;
-
-import org.eclipse.jem.java.Method;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Method Proxy</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This is just a wrapper of a java Method. It allows access to the method but doesn't duplicate the interface for it.
- * <p>
- * MethodProxies will be in the eBehaviors setting for any methods that are in the JavaClass methods setting so that they are not duplicated.
- * <p>
- * MethodProxies would also have MethodDecorators.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.MethodProxy#getMethod <em>Method</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getMethodProxy()
- * @model
- * @generated
- */
-
-
-public interface MethodProxy extends EOperation{
-	/**
-	 * Returns the value of the '<em><b>Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Method</em>' reference.
-	 * @see #setMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getMethodProxy_Method()
-	 * @model required="true"
-	 * @generated
-	 */
-	Method getMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.MethodProxy#getMethod <em>Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Method</em>' reference.
-	 * @see #getMethod()
-	 * @generated
-	 */
-	void setMethod(Method value);
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/ParameterDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/ParameterDecorator.java
deleted file mode 100644
index fd0e8a5..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/ParameterDecorator.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: ParameterDecorator.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-
-import org.eclipse.jem.java.JavaParameter;
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Parameter Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator#getParameter <em>Parameter</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getParameterDecorator()
- * @model
- * @generated
- */
-
-
-public interface ParameterDecorator extends FeatureDecorator{
-	/**
-	 * Returns the value of the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Name</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The name is explicit here because unlike the other feature decorators, the name does not come from the object being decorated.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Name</em>' attribute.
-	 * @see #setName(String)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getParameterDecorator_Name()
-	 * @model
-	 * @generated
-	 */
-	String getName();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator#getName <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Name</em>' attribute.
-	 * @see #getName()
-	 * @generated
-	 */
-	void setName(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Parameter</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Parameter</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The JavaParameter that this ParameterDecorator is decorating. Can't use eDecorates in this.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Parameter</em>' reference.
-	 * @see #setParameter(JavaParameter)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getParameterDecorator_Parameter()
-	 * @model transient="true"
-	 * @generated
-	 */
-	JavaParameter getParameter();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.ParameterDecorator#getParameter <em>Parameter</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Parameter</em>' reference.
-	 * @see #getParameter()
-	 * @generated
-	 */
-	void setParameter(JavaParameter value);
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/PropertyDecorator.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/PropertyDecorator.java
deleted file mode 100644
index c9fa846..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/PropertyDecorator.java
+++ /dev/null
@@ -1,513 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo;
-/*
- *  $RCSfile: PropertyDecorator.java,v $
- *  $Revision: 1.10 $  $Date: 2005/09/15 20:09:51 $ 
- */
-
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClassifier;
-
-import org.eclipse.jem.java.Field;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.Method;
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property Decorator</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Equivalent to PropertyDecorator in java.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isBound <em>Bound</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isConstrained <em>Constrained</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isDesignTime <em>Design Time</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isAlwaysIncompatible <em>Always Incompatible</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getFilterFlags <em>Filter Flags</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isFieldReadOnly <em>Field Read Only</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getPropertyEditorClass <em>Property Editor Class</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getReadMethod <em>Read Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getWriteMethod <em>Write Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getField <em>Field</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator()
- * @model
- * @generated
- */
-
-
-public interface PropertyDecorator extends FeatureDecorator{
-	/**
-	 * Returns the value of the '<em><b>Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Bound</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Bound</em>' attribute.
-	 * @see #isSetBound()
-	 * @see #unsetBound()
-	 * @see #setBound(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_Bound()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isBound();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isBound <em>Bound</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Bound</em>' attribute.
-	 * @see #isSetBound()
-	 * @see #unsetBound()
-	 * @see #isBound()
-	 * @generated
-	 */
-	void setBound(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isBound <em>Bound</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetBound()
-	 * @see #isBound()
-	 * @see #setBound(boolean)
-	 * @generated
-	 */
-	void unsetBound();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isBound <em>Bound</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Bound</em>' attribute is set.
-	 * @see #unsetBound()
-	 * @see #isBound()
-	 * @see #setBound(boolean)
-	 * @generated
-	 */
-	boolean isSetBound();
-
-	/**
-	 * Returns the value of the '<em><b>Constrained</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Constrained</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Constrained</em>' attribute.
-	 * @see #isSetConstrained()
-	 * @see #unsetConstrained()
-	 * @see #setConstrained(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_Constrained()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isConstrained();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isConstrained <em>Constrained</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Constrained</em>' attribute.
-	 * @see #isSetConstrained()
-	 * @see #unsetConstrained()
-	 * @see #isConstrained()
-	 * @generated
-	 */
-	void setConstrained(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isConstrained <em>Constrained</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetConstrained()
-	 * @see #isConstrained()
-	 * @see #setConstrained(boolean)
-	 * @generated
-	 */
-	void unsetConstrained();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isConstrained <em>Constrained</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Constrained</em>' attribute is set.
-	 * @see #unsetConstrained()
-	 * @see #isConstrained()
-	 * @see #setConstrained(boolean)
-	 * @generated
-	 */
-	boolean isSetConstrained();
-
-	/**
-	 * Returns the value of the '<em><b>Design Time</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Design Time</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * If not set, then normal default processing.
-	 * 
-	 * If set true, then this property is a design time property. This means it will show up in the property sheet, but it won't be able to be connected to at runtime. It may not even be a true bean property but instead the builder will know how to handle it.
-	 * 
-	 * If set false, then this property will not show up on the property sheet, but will be able to be connected to for runtime.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Design Time</em>' attribute.
-	 * @see #isSetDesignTime()
-	 * @see #unsetDesignTime()
-	 * @see #setDesignTime(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_DesignTime()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	boolean isDesignTime();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isDesignTime <em>Design Time</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Design Time</em>' attribute.
-	 * @see #isSetDesignTime()
-	 * @see #unsetDesignTime()
-	 * @see #isDesignTime()
-	 * @generated
-	 */
-	void setDesignTime(boolean value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isDesignTime <em>Design Time</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetDesignTime()
-	 * @see #isDesignTime()
-	 * @see #setDesignTime(boolean)
-	 * @generated
-	 */
-	void unsetDesignTime();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isDesignTime <em>Design Time</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Design Time</em>' attribute is set.
-	 * @see #unsetDesignTime()
-	 * @see #isDesignTime()
-	 * @see #setDesignTime(boolean)
-	 * @generated
-	 */
-	boolean isSetDesignTime();
-
-	/**
-	 * Returns the value of the '<em><b>Always Incompatible</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Always Incompatible</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * If set true, then when multiple objects are selected, this property is always incompatible with each other. So in this case the property will not show up on the property sheet if more than one object has been selected.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Always Incompatible</em>' attribute.
-	 * @see #setAlwaysIncompatible(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_AlwaysIncompatible()
-	 * @model
-	 * @generated
-	 */
-	boolean isAlwaysIncompatible();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isAlwaysIncompatible <em>Always Incompatible</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Always Incompatible</em>' attribute.
-	 * @see #isAlwaysIncompatible()
-	 * @generated
-	 */
-	void setAlwaysIncompatible(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Filter Flags</b></em>' attribute list.
-	 * The list contents are of type {@link java.lang.String}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Filter Flags</em>' attribute list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Filter Flags</em>' attribute list.
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_FilterFlags()
-	 * @model type="java.lang.String"
-	 * @generated
-	 */
-	EList getFilterFlags();
-
-	/**
-	 * Returns the value of the '<em><b>Field Read Only</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Is this field read-only (i.e. is a "final" field). This is only referenced if the field reference is set.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Field Read Only</em>' attribute.
-	 * @see #setFieldReadOnly(boolean)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_FieldReadOnly()
-	 * @model
-	 * @generated
-	 */
-	boolean isFieldReadOnly();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#isFieldReadOnly <em>Field Read Only</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Field Read Only</em>' attribute.
-	 * @see #isFieldReadOnly()
-	 * @generated
-	 */
-	void setFieldReadOnly(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Property Editor Class</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Editor Class</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Property Editor Class</em>' reference.
-	 * @see #setPropertyEditorClass(JavaClass)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_PropertyEditorClass()
-	 * @model
-	 * @generated
-	 */
-	JavaClass getPropertyEditorClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getPropertyEditorClass <em>Property Editor Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Editor Class</em>' reference.
-	 * @see #getPropertyEditorClass()
-	 * @generated
-	 */
-	void setPropertyEditorClass(JavaClass value);
-
-	/**
-	 * Returns the value of the '<em><b>Read Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Read Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Read Method</em>' reference.
-	 * @see #isSetReadMethod()
-	 * @see #unsetReadMethod()
-	 * @see #setReadMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_ReadMethod()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	Method getReadMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getReadMethod <em>Read Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Read Method</em>' reference.
-	 * @see #isSetReadMethod()
-	 * @see #unsetReadMethod()
-	 * @see #getReadMethod()
-	 * @generated
-	 */
-	void setReadMethod(Method value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getReadMethod <em>Read Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetReadMethod()
-	 * @see #getReadMethod()
-	 * @see #setReadMethod(Method)
-	 * @generated
-	 */
-	void unsetReadMethod();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getReadMethod <em>Read Method</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Read Method</em>' reference is set.
-	 * @see #unsetReadMethod()
-	 * @see #getReadMethod()
-	 * @see #setReadMethod(Method)
-	 * @generated
-	 */
-	boolean isSetReadMethod();
-
-	/**
-	 * Returns the value of the '<em><b>Write Method</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Write Method</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Write Method</em>' reference.
-	 * @see #isSetWriteMethod()
-	 * @see #unsetWriteMethod()
-	 * @see #setWriteMethod(Method)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_WriteMethod()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	Method getWriteMethod();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getWriteMethod <em>Write Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Write Method</em>' reference.
-	 * @see #isSetWriteMethod()
-	 * @see #unsetWriteMethod()
-	 * @see #getWriteMethod()
-	 * @generated
-	 */
-	void setWriteMethod(Method value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getWriteMethod <em>Write Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetWriteMethod()
-	 * @see #getWriteMethod()
-	 * @see #setWriteMethod(Method)
-	 * @generated
-	 */
-	void unsetWriteMethod();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getWriteMethod <em>Write Method</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Write Method</em>' reference is set.
-	 * @see #unsetWriteMethod()
-	 * @see #getWriteMethod()
-	 * @see #setWriteMethod(Method)
-	 * @generated
-	 */
-	boolean isSetWriteMethod();
-
-	/**
-	 * Returns the value of the '<em><b>Field</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * If this is set, then this property is a field and not a getter/setter property. This is an extension that the Visual Editor uses to the BeanInfo model.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Field</em>' reference.
-	 * @see #isSetField()
-	 * @see #unsetField()
-	 * @see #setField(Field)
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#getPropertyDecorator_Field()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	Field getField();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getField <em>Field</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Field</em>' reference.
-	 * @see #isSetField()
-	 * @see #unsetField()
-	 * @see #getField()
-	 * @generated
-	 */
-	void setField(Field value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getField <em>Field</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetField()
-	 * @see #getField()
-	 * @see #setField(Field)
-	 * @generated
-	 */
-	void unsetField();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.jem.internal.beaninfo.PropertyDecorator#getField <em>Field</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Field</em>' reference is set.
-	 * @see #unsetField()
-	 * @see #getField()
-	 * @see #setField(Field)
-	 * @generated
-	 */
-	boolean isSetField();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Get the property type.
-	 * <!-- end-model-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-	EClassifier getPropertyType();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * This property type is not persisted if this class is serialized into an XMI file. Nor is 
-	 * it a property that can be set from an XMI file. It is an operation. It is used by
-	 * clients which want a PropertyDecorator that is not part of a BeanInfo model.
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Set the property type.
-	 * <!-- end-model-doc -->
-	 * @model
-	 * @generated
-	 */
-	void setPropertyType(EClassifier propertyType);
-
-	/**
-	 * @return boolean for whether this property is writeable or not
-	 * It could have a write method or it could have a field (e.g. java.awt.Insets.top)
-	 */
-	boolean isWriteable();
-
-	/**
-	 * @return boolean for whether this property is readable or not
-	 * It could have a read method or it could have a field (e.g. java.awt.Insets.top)
-	 */
-	boolean isReadable();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeanInfoAdapterMessages.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeanInfoAdapterMessages.java
deleted file mode 100644
index 2b49711..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeanInfoAdapterMessages.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class BeanInfoAdapterMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.beaninfo.adapters.messages";//$NON-NLS-1$
-
-	private BeanInfoAdapterMessages() {
-		// Do not instantiate
-	}
-
-	public static String INTROSPECT_FAILED_EXC_;
-	public static String BeaninfoClassAdapter_ClassNotFound;
-	public static String BeaninfoNature_InvalidProject;
-	public static String UICreateRegistryJobHandler_StartBeaninfoRegistry;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, BeanInfoAdapterMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeanInfoDecoratorUtility.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeanInfoDecoratorUtility.java
deleted file mode 100644
index fb18ccf..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeanInfoDecoratorUtility.java
+++ /dev/null
@@ -1,1446 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeanInfoDecoratorUtility.java,v $
- *  $Revision: 1.4 $  $Date: 2005/05/11 22:41:17 $ 
- */
-package org.eclipse.jem.internal.beaninfo.adapters;
-
-import java.io.*;
-import java.util.*;
-
-import org.eclipse.emf.common.util.EMap;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.change.*;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.internal.beaninfo.*;
-import org.eclipse.jem.internal.beaninfo.common.*;
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin;
-import org.eclipse.jem.internal.beaninfo.core.Utilities;
-import org.eclipse.jem.internal.beaninfo.impl.*;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.java.*;
-
-/**
- * This is a utility class for handling the BeanInfo decorators with respect to the overrides (explicit settings) vs. introspected/reflected (implicit
- * settings) It handles the transmission of data from the VM for introspection.
- * 
- * @since 1.1.0
- */
-public class BeanInfoDecoratorUtility {
-
-	/**
-	 * Clear out the implicit settings for FeatureDecorator.
-	 * 
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void clear(FeatureDecorator decor) {
-		long implicitSettings = decor.getImplicitlySetBits();
-		// For each setting, see if it was implicitly set, and if it was, then unset it.
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT) != 0)
-			decor.unsetDisplayName();
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT) != 0)
-			decor.unsetShortDescription();
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getFeatureDecorator_Category());
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT) != 0)
-			decor.unsetExpert();
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT) != 0)
-			decor.unsetHidden();
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT) != 0)
-			decor.unsetPreferred();
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getFeatureDecorator_Attributes());
-		decor
-				.setImplicitlySetBits(implicitSettings
-						& ~(FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT | FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT
-								| FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT | FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT
-								| FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT | FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT | FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT));
-	}
-
-	/**
-	 * Clear out the implicit settings for BeanDecorator
-	 * 
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void clear(BeanDecorator decor) {
-		clear((FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		// For each setting, see if it was implicitly set, and if it was, then unset it.
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_CustomizerClass());
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT) != 0)
-			decor.unsetMergeSuperProperties();
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT) != 0)
-			decor.unsetMergeSuperMethods();
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT) != 0)
-			decor.unsetMergeSuperEvents();
-		if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames()))
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames()); // Just clear them. This is our attribute. It should
-																							   // not be set overrides.
-		if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames()))
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames()); // Just clear them. This is our attribute. It should
-																							   // not be set overrides.
-		if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames()))
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames()); // Just clear them. This is our attribute. It should not
-																							// be set overrides.
-
-		decor.setImplicitlySetBits(implicitSettings
-				& ~(BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT | BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT
-						| BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT | BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT));
-	}
-
-	/**
-	 * Clear out the implicit settings of the PropertyDecorator.
-	 * 
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void clear(PropertyDecorator decor) {
-		clear((FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		// For each setting, see if it was implicitly set, and if it was, then unset it.
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getPropertyDecorator_PropertyEditorClass());
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT) != 0)
-			decor.unsetReadMethod();
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT) != 0)
-			decor.unsetWriteMethod();
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_FIELD_IMPLICIT) != 0) {
-			decor.unsetField();		
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getPropertyDecorator_Field());
-		}
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT) != 0)
-			decor.unsetBound();
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT) != 0)
-			decor.unsetConstrained();
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT) != 0)
-			decor.unsetDesignTime();
-		decor.setImplicitlySetBits(implicitSettings
-				& ~(PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT | PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT
-						| PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT | PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT
-						| PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT | PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT));
-	}
-
-	/**
-	 * Clear out the implicit settings of the IndexedPropertyDecorator.
-	 * 
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void clear(IndexedPropertyDecorator decor) {
-		clear((PropertyDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		// For each setting, see if it was implicitly set, and if it was, then unset it.
-		if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT) != 0)
-			decor.unsetIndexedReadMethod();
-		if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT) != 0)
-			decor.unsetIndexedWriteMethod();
-		decor.setImplicitlySetBits(implicitSettings
-				& ~(IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT | IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT));
-	}
-
-	/**
-	 * Clear the method decorator of any implicit settings.
-	 * 
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void clear(MethodDecorator decor) {
-		clear((FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		// For each setting, see if it was implicitly set, and if it was, then unset it.
-		if ((implicitSettings & (MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT | MethodDecoratorImpl.METHOD_PARAMETERS_DEFAULT)) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getMethodDecorator_SerParmDesc());
-		decor.setImplicitlySetBits(implicitSettings
-				& ~(MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT | MethodDecoratorImpl.METHOD_PARAMETERS_DEFAULT));
-	}
-
-	/**
-	 * Clear the event set decorator of any implicit settings.
-	 * 
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void clear(EventSetDecorator decor) {
-		clear((FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		// For each setting, see if it was implicitly set, and if it was, then unset it.
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod());
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_EventAdapterClass());
-		if ((implicitSettings & (EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT | EventSetDecoratorImpl.EVENT_LISTENERMETHODS_DEFAULT)) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_SerListMthd());
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod());
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT) != 0)
-			decor.unsetInDefaultEventSet();
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT) != 0)
-			decor.unsetUnicast();
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT) != 0)
-			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType());
-
-		decor.setImplicitlySetBits(implicitSettings
-				& ~(EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT | EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT
-						| EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT | EventSetDecoratorImpl.EVENT_LISTENERMETHODS_DEFAULT
-						| EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT | EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT
-						| EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT | EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT));
-
-	}
-
-	public static void introspect(IBeanProxy modelBeaninfoProxy, IntrospectCallBack callback) {
-		ProxyIntrospectCallBack cb = new ProxyIntrospectCallBack(callback);
-		modelBeaninfoProxy.getProxyFactoryRegistry().getCallbackRegistry().registerCallback(modelBeaninfoProxy, cb);
-		try {
-			BeaninfoProxyConstants.getConstants(modelBeaninfoProxy.getProxyFactoryRegistry()).getSendBeanInfoProxy()
-					.invokeCatchThrowableExceptions(modelBeaninfoProxy);
-		} finally {
-			modelBeaninfoProxy.getProxyFactoryRegistry().getCallbackRegistry().deregisterCallback(modelBeaninfoProxy);
-		}
-
-	}
-
-	/**
-	 * This call back is for each requested type of record. It allows the callee to process this record.
-	 * 
-	 * @since 1.1.0
-	 */
-	public interface IntrospectCallBack {
-
-		/**
-		 * Process the BeanDecoratorRecord. The callee can decide what needs to be done with this record. It would return the BeandDecorator that needs
-		 * to have the record applied to. If it returns <code>null</code> then the record will be ignored.
-		 * <p>
-		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
-		 * have them on a separate thread.
-		 * 
-		 * @param record
-		 * @return BeanDecorator to be applied to, or <code>null</code> if record is to be ignored.
-		 * 
-		 * @since 1.1.0
-		 */
-		public BeanDecorator process(BeanRecord record);
-
-		/**
-		 * Process the PropertyRecord. The callee can decide what needs to be done with this record. It would return the PropertyDecorator that needs
-		 * to have the record applied to. If it returns <code>null</code> then the record will be ignored.
-		 * <p>
-		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
-		 * have them on a separate thread.
-		 * 
-		 * @param record
-		 * @return PropertyDecorator to be applied to, or <code>null</code> if record is to be ignored.
-		 * 
-		 * @since 1.1.0
-		 */
-		public PropertyDecorator process(PropertyRecord record);
-
-		/**
-		 * Process the IndexedPropertyRecord. The callee can decide what needs to be done with this record. It would return the
-		 * IndexedPropertyDecorator that needs to have the record applied to. If it returns <code>null</code> then the record will be ignored.
-		 * 
-		 * <p>
-		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
-		 * have them on a separate thread.
-		 * 
-		 * @param record
-		 * @return PropertyDecorator to be applied to, or <code>null</code> if record is to be ignored. There is a possibility that a straight
-		 *         PropertyDecorator can be returned instead (in the case that it was explictly set by overrides as a property but beaninfo thinks it
-		 *         is an index. This can be handled by it will only set the PropertyRecord part. It normally should be an IndexedPropertyDecorator
-		 *         returned.
-		 * 
-		 * @since 1.1.0
-		 */
-		public PropertyDecorator process(IndexedPropertyRecord record);
-
-		/**
-		 * Process the MethodRecord. The callee can decide what needs to be done with this record. It would return the MethodDecorator that needs to
-		 * have the record applied to. If it returns <code>null</code> then the record will be ignored.
-		 * 
-		 * <p>
-		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
-		 * have them on a separate thread.
-		 * 
-		 * @param record
-		 * @return MethodDecorator to be applied to, or <code>null</code> if record is to be ignored.
-		 * 
-		 * @since 1.1.0
-		 */
-
-		public MethodDecorator process(MethodRecord record);
-
-		/**
-		 * Process the EventRecord. The callee can decide what needs to be done with this record. It would return the EventSetDecorator that needs to
-		 * have the record applied to. If it returns <code>null</code> then the record will be ignored.
-		 * 
-		 * <p>
-		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
-		 * have them on a separate thread.
-		 * 
-		 * @param record
-		 * @return EventSetDecorator to be applied to, or <code>null</code> if record is to be ignored.
-		 * 
-		 * @since 1.1.0
-		 */
-
-		public EventSetDecorator process(EventSetRecord record);
-	}
-
-	private static class ProxyIntrospectCallBack implements ICallback {
-
-		private IntrospectCallBack introspectCallback;
-
-		public ProxyIntrospectCallBack(IntrospectCallBack introspectCallback) {
-			this.introspectCallback = introspectCallback;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, org.eclipse.jem.internal.proxy.core.IBeanProxy)
-		 */
-		public Object calledBack(int msgID, IBeanProxy parm) {
-			return null; // Not used.
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, java.lang.Object)
-		 */
-		public Object calledBack(int msgID, Object parm) {
-			return null; // Not used.
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, java.lang.Object[])
-		 */
-		public Object calledBack(int msgID, Object[] parms) {
-			return null; // Not used.
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, java.io.InputStream)
-		 */
-		public void calledBackStream(int msgID, InputStream is) {
-			ObjectInputStream ois;
-			try {
-				ois = new ObjectInputStream(is);
-				while (true) {
-					int cmdId = ois.readInt();
-					switch (cmdId) {
-						case IBeanInfoIntrospectionConstants.BEAN_DECORATOR_SENT:
-							try {
-								BeanRecord br = (BeanRecord) ois.readObject();
-								BeanDecorator bd = introspectCallback.process(br);
-								if (bd != null) {
-									clear(bd);
-									applyRecord(bd, br);
-								}
-							} catch (IOException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassCastException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassNotFoundException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							}
-							break;
-						case IBeanInfoIntrospectionConstants.PROPERTY_DECORATORS_SENT:
-							try {
-								int propCount = ois.readInt();
-								for (int i = 0; i < propCount; i++) {
-									PropertyRecord pr = (PropertyRecord) ois.readObject();
-									if (pr.getClass() == IndexedPropertyRecord.class) {
-										IndexedPropertyRecord ipr = (IndexedPropertyRecord) pr;
-										PropertyDecorator ip = introspectCallback.process(ipr);
-										if (ip != null) {
-											// It actually could be either a property decorator or an indexed property decorator. This could happen
-											// because the overrides file has explicitly declared a PropertyDecorator, so we can't change it to an
-											// Indexed.
-											// So in that case we can only fill the property part.
-											if (ip.eClass().getClassifierID() == BeaninfoPackage.INDEXED_PROPERTY_DECORATOR)
-												applyRecord((IndexedPropertyDecorator) ip, ipr);
-											else
-												applyRecord(ip, pr); // It was forced to be a property and not indexed.
-										}
-									} else {
-										PropertyDecorator p = introspectCallback.process(pr);
-										if (p != null) {
-											// It actually could be either a property decorator or an indexed property decorator. This could happen
-											// because the overrides file has explicitly declared an IndexedPropertyDecorator, so we can't change it
-											// to an
-											// Property.
-											// So in that case we can only fill the property part.
-											applyRecord(p, pr);
-										}
-									}
-								}
-							} catch (IOException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassNotFoundException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassCastException e) {
-								// In case we got bad data sent in.
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} finally {
-							}
-							break;
-
-						case IBeanInfoIntrospectionConstants.METHOD_DECORATORS_SENT:
-							try {
-								int opCount = ois.readInt();
-								for (int i = 0; i < opCount; i++) {
-									MethodRecord mr = (MethodRecord) ois.readObject();
-									MethodDecorator m = introspectCallback.process(mr);
-									if (m != null)
-										applyRecord(m, mr);
-								}
-							} catch (IOException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassNotFoundException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassCastException e) {
-								// In case we got bad data sent in.
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							}
-							break;
-
-						case IBeanInfoIntrospectionConstants.EVENT_DECORATORS_SENT:
-							try {
-								int opCount = ois.readInt();
-								for (int i = 0; i < opCount; i++) {
-									EventSetRecord evr = (EventSetRecord) ois.readObject();
-									EventSetDecorator e = introspectCallback.process(evr);
-									if (e != null)
-										applyRecord(e, evr);
-								}
-							} catch (IOException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassNotFoundException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							} catch (ClassCastException e) {
-								// In case we got bad data sent in.
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							}
-							break;
-
-						case IBeanInfoIntrospectionConstants.DONE:
-							return;	// Good. This is a good stop.
-							
-						default:
-							return;	// This is invalid. Should of gotton something.
-					}
-				}
-			} catch (IOException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e);
-			}
-		}
-	}
-
-	/**
-	 * Apply the feature record to the feature decorator. This is protected because this is an abstract and should never be called by itself.
-	 * <p>
-	 * 
-	 * @param decor
-	 * @param record
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void applyRecord(FeatureDecorator decor, FeatureRecord record) {
-		// Subclasses will clear their decor, which will automatically clear the FeatureDecor part for us.
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.displayName != null && !decor.isSetDisplayName()) {
-			decor.setDisplayName(record.displayName);
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT;
-		}
-		if (record.shortDescription != null && !decor.isSetShortDescription()) {
-			decor.setShortDescription(record.shortDescription);
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT;
-		}
-		if (record.category != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getFeatureDecorator_Category())) {
-			decor.setCategory(record.category);
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT;
-		}
-		if (!decor.isSetExpert()) {
-			if (decor.isExpert() != record.expert)
-				decor.setExpert(record.expert); // Don't want to explicitly set it if it is equal to default (this will put less out to the cache file
-												// and so will parse and apply faster).
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT;
-		}
-		if (!decor.isSetHidden()) {
-			if (decor.isHidden() != record.hidden)
-				decor.setHidden(record.hidden);
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT;
-		}
-		if (!decor.isSetPreferred()) {
-			if (decor.isPreferred() != record.preferred)
-				decor.setPreferred(record.preferred);
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT;
-		}
-		if (record.attributeNames != null && !decor.isAttributesExplicitEmpty()
-				&& !decor.eIsSet(BeaninfoPackage.eINSTANCE.getFeatureDecorator_Attributes())) {
-			// This is a list, so we need to read an fill in.
-			EMap attrs = decor.getAttributes();
-			for (int i = 0; i < record.attributeNames.length; i++) {
-				FeatureAttributeMapEntryImpl entry = (FeatureAttributeMapEntryImpl) ((BeaninfoFactoryImpl) BeaninfoFactory.eINSTANCE)
-						.createFeatureAttributeMapEntry();
-				entry.setTypedKey(record.attributeNames[i]);
-				entry.setTypedValue(record.attributeValues[i]);
-				attrs.add(entry);
-			}
-			implicitSettings |= FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT;
-		}
-
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Apply the bean record to the bean decorator.
-	 * 
-	 * @param decor
-	 * @param record
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void applyRecord(BeanDecorator decor, BeanRecord record) {
-		applyRecord((FeatureDecorator) decor, record);
-
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.customizerClassName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_CustomizerClass())) {
-			decor.setCustomizerClass(createJavaClassProxy(record.customizerClassName));
-			implicitSettings |= BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT;
-		}
-		if (!decor.isSetMergeSuperProperties()) {
-			if (decor.isMergeSuperProperties() != record.mergeInheritedProperties)
-				decor.setMergeSuperProperties(record.mergeInheritedProperties);
-			implicitSettings |= BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT;
-		}
-		if (!decor.isSetMergeSuperMethods()) {
-			if (decor.isMergeSuperMethods() != record.mergeInheritedOperations)
-				decor.setMergeSuperMethods(record.mergeInheritedOperations);
-			implicitSettings |= BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT;
-		}
-		if (!decor.isSetMergeSuperEvents()) {
-			if (decor.isMergeSuperEvents() != record.mergeInheritedEvents)
-				decor.setMergeSuperEvents(record.mergeInheritedEvents);
-			implicitSettings |= BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT;
-		}
-		if (record.notInheritedPropertyNames != null) {
-			// This is always applied. This isn't a client override so we can just slam it.
-			decor.getNotInheritedPropertyNames().addAll(Arrays.asList(record.notInheritedPropertyNames));
-		}
-		if (record.notInheritedOperationNames != null) {
-			// This is always applied. This isn't a client override so we can just slam it.
-			decor.getNotInheritedMethodNames().addAll(Arrays.asList(record.notInheritedOperationNames));
-		}
-		if (record.notInheritedEventNames != null) {
-			// This is always applied. This isn't a client override so we can just slam it.
-			decor.getNotInheritedEventNames().addAll(Arrays.asList(record.notInheritedEventNames));
-		}
-
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Apply the PropertyRecord to the PropertyDecorator.
-	 * 
-	 * @param decor
-	 * @param record
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void applyRecord(PropertyDecorator decor, PropertyRecord record) {
-		applyRecord((FeatureDecorator) decor, record);
-
-		applyOnly(decor, record);
-	}
-
-	/*
-	 * Apply only to property decorator part. Allows IndexedProperty to apply just the Property part and not do duplicate work
-	 */
-	private static void applyOnly(PropertyDecorator decor, PropertyRecord record) {
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.propertyEditorClassName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getPropertyDecorator_PropertyEditorClass())) {
-			decor.setPropertyEditorClass(createJavaClassProxy(record.propertyEditorClassName));
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT;
-		}
-		if (record.readMethod != null && !decor.isSetReadMethod()) {
-			decor.setReadMethod(createJavaMethodProxy(record.readMethod));
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT;
-		}
-		if (record.writeMethod != null && !decor.isSetWriteMethod()) {
-			decor.setWriteMethod(createJavaMethodProxy(record.writeMethod));
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT;
-		}
-		if (record.field != null && !decor.isSetField()) {
-			decor.setField(createJavaFieldProxy(record.field));
-			if (decor.isFieldReadOnly() != record.field.readOnly)
-				decor.setFieldReadOnly(record.field.readOnly);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_FIELD_IMPLICIT;
-		}		
-		if (!decor.isSetBound()) {
-			if (decor.isBound() != record.bound)
-				decor.setBound(record.bound);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT;
-		}
-		if (!decor.isSetConstrained()) {
-			if (decor.isConstrained() != record.constrained)
-				decor.setConstrained(record.constrained);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT;
-		}
-		if (record.designTime != null && !decor.isSetDesignTime()) {
-			// Design time is slightly different than the other booleans because
-			// explicitly set to true/false is important versus not explicitly set at all (which is false).
-			decor.setDesignTime(record.designTime.booleanValue());
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT;
-		}
-
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-
-	}
-
-	public static void applyRecord(IndexedPropertyDecorator decor, IndexedPropertyRecord record) {
-		applyRecord((FeatureDecorator) decor, record);
-		applyOnly(decor, record);
-
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.indexedReadMethod != null && !decor.isSetIndexedReadMethod()) {
-			decor.setIndexedReadMethod(createJavaMethodProxy(record.indexedReadMethod));
-			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT;
-		}
-		if (record.indexedWriteMethod != null && !decor.isSetIndexedWriteMethod()) {
-			decor.setIndexedWriteMethod(createJavaMethodProxy(record.indexedWriteMethod));
-			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT;
-		}
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Apply the method record to the method decorator.
-	 * 
-	 * @param decor
-	 * @param record
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void applyRecord(MethodDecorator decor, MethodRecord record) {
-		applyRecord((FeatureDecorator) decor, record);
-
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.parameters != null && !decor.isParmsExplicitEmpty()
-				&& !decor.eIsSet(BeaninfoPackage.eINSTANCE.getMethodDecorator_ParameterDescriptors())) {
-			// This is a list, so we need to read an fill in.
-			List parms = decor.getSerParmDesc(); // So as not to have it implicitly fill it in, which it would if we called getParameterDescriptors.
-			for (int i = 0; i < record.parameters.length; i++) {
-				ParameterDecorator parm = BeaninfoFactory.eINSTANCE.createParameterDecorator();
-				applyRecord(parm, record.parameters[i]);
-				parms.add(parm);
-			}
-			implicitSettings |= MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT;
-			implicitSettings &= ~MethodDecoratorImpl.METHOD_PARAMETERS_DEFAULT; // Should of already been cleared, but be safe.
-		}
-
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	public static void applyRecord(ParameterDecorator decor, ParameterRecord record) {
-		applyRecord((FeatureDecorator) decor, record);
-
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.name != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getParameterDecorator_Name())) {
-			decor.setName(record.name);
-			implicitSettings |= ParameterDecoratorImpl.PARAMETER_NAME_IMPLICIT;
-		}
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Apply the event set record to the event set decorator.
-	 * 
-	 * @param decor
-	 * @param record
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void applyRecord(EventSetDecorator decor, EventSetRecord record) {
-		applyRecord((FeatureDecorator) decor, record);
-
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (record.addListenerMethod != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod())) {
-			decor.setAddListenerMethod(createJavaMethodProxy(record.addListenerMethod));
-			implicitSettings |= EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT;
-		}
-		if (record.eventAdapterClassName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_EventAdapterClass())) {
-			decor.setEventAdapterClass(createJavaClassProxy(record.eventAdapterClassName));
-			implicitSettings |= EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT;
-		}
-		if (record.listenerMethodDescriptors != null && !decor.isListenerMethodsExplicitEmpty()
-				&& !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerMethods())) {
-			List methods = decor.getSerListMthd(); // So as not to have it implicitly fill it in, which it would if we called getListenerMethods.
-			for (int i = 0; i < record.listenerMethodDescriptors.length; i++) {
-				BeaninfoFactory bfact = BeaninfoFactory.eINSTANCE;
-				MethodRecord mr = record.listenerMethodDescriptors[i];
-				Method method = createJavaMethodProxy(mr.methodForDescriptor);
-				// We need a method proxy, and a method decorator.
-				MethodProxy mproxy = bfact.createMethodProxy();
-				mproxy.setMethod(method);
-				mproxy.setName(mr.name);
-				MethodDecorator md = bfact.createMethodDecorator();
-				applyRecord(md, mr);
-				mproxy.getEAnnotations().add(md);
-				methods.add(mproxy);
-			}
-			implicitSettings |= EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT;
-			implicitSettings &= ~EventSetDecoratorImpl.EVENT_LISTENERMETHODS_DEFAULT; // Should of already been cleared, but be safe.
-		}
-		if (record.listenerTypeName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType())) {
-			decor.setListenerType(createJavaClassProxy(record.listenerTypeName));
-			implicitSettings |= EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT;
-		}
-		if (record.removeListenerMethod != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod())) {
-			decor.setRemoveListenerMethod(createJavaMethodProxy(record.removeListenerMethod));
-			implicitSettings |= EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT;
-		}
-		if (!decor.isSetInDefaultEventSet()) {
-			if (record.inDefaultEventSet != decor.isInDefaultEventSet())
-				decor.setInDefaultEventSet(record.inDefaultEventSet);
-			implicitSettings |= EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT;
-		}
-		if (!decor.isSetUnicast()) {
-			if (record.unicast != decor.isUnicast())
-				decor.setUnicast(record.unicast);
-			implicitSettings |= EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT;
-		}
-
-		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Create a java class proxy for the given name. By being a proxy we don't need to actually have the resource set. Nor do we need to fluff one up
-	 * until someone actually asks for it.
-	 * <p>
-	 * The jniName must refer to a JavaClass or errors could occur later on.
-	 * 
-	 * @param jniName
-	 *            classname in JNI format.
-	 * @return JavaClass proxy or <code>null</code> if not a java class (it may be a type).
-	 * 
-	 * @since 1.1.0
-	 */
-	public static JavaClass createJavaClassProxy(String jniName) {
-		JavaHelpers jh = createJavaTypeProxy(jniName);
-		return jh instanceof JavaClass ? (JavaClass) jh : null;
-	}
-
-	/**
-	 * Create a JavaHelpers proxy for the given name. By being a proxy we don't need to actually have the resource set. Nor do we need to fluff one up
-	 * until someone actually asks for it.
-	 * 
-	 * @param jniName
-	 *            typename in JNI format.
-	 * @return JavaHelper proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static JavaHelpers createJavaTypeProxy(String jniName) {
-		String formalName = MapJNITypes.getFormalTypeName(jniName);
-
-		URI uri = Utilities.getJavaClassURI(formalName);
-		JavaHelpers jh = null;
-		if (MapJNITypes.isFormalTypePrimitive(formalName))
-			jh = JavaRefFactory.eINSTANCE.createJavaDataType();
-		else
-			jh = JavaRefFactory.eINSTANCE.createJavaClass();
-		((InternalEObject) jh).eSetProxyURI(uri);
-		return jh;
-	}
-
-	public static Method createJavaMethodProxy(ReflectMethodRecord method) {
-		String[] parmTypes = method.parameterTypeNames != null ? new String[method.parameterTypeNames.length] : null;
-		if (parmTypes != null)
-			for (int i = 0; i < method.parameterTypeNames.length; i++) {
-				parmTypes[i] = MapJNITypes.getFormalTypeName(method.parameterTypeNames[i]);
-			}
-		URI uri = Utilities.getMethodURI(MapJNITypes.getFormalTypeName(method.className), method.methodName, parmTypes);
-		Method methodEMF = JavaRefFactory.eINSTANCE.createMethod();
-		((InternalEObject) methodEMF).eSetProxyURI(uri);
-		return methodEMF;
-	}
-	
-	public static Field createJavaFieldProxy(ReflectFieldRecord field) {
-		URI uri = Utilities.getFieldURI(MapJNITypes.getFormalTypeName(field.className), field.fieldName);
-		Field fieldEMF = JavaRefFactory.eINSTANCE.createField();
-		((InternalEObject) fieldEMF).eSetProxyURI(uri);
-		return fieldEMF;
-	}	
-
-	/**
-	 * Set the properties on the PropertyDecorator. These come from reflection. Since this is a private interface between BeaninfoClassAdapter and
-	 * this class, not all possible settings need to be mentioned. Only the ones that can be set by reflection. It is assumed that clear has already
-	 * been done so that there are no old implicit settings. It will check if properties are set already before setting so that don't wipe out
-	 * explicit settings.
-	 * 
-	 * @param prop
-	 * @param bound
-	 * @param constrained
-	 * @param getter
-	 * @param setter
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void setProperties(PropertyDecorator prop, boolean bound, boolean constrained, Method getter, Method setter) {
-		long implicitSettings = prop.getImplicitlySetBits();
-		if (getter != null && !prop.isSetReadMethod()) {
-			prop.setReadMethod(getter);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT;
-		}
-		if (setter != null && !prop.isSetWriteMethod()) {
-			prop.setWriteMethod(setter);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT;
-		}
-		if (!prop.isSetBound()) {
-			if (prop.isBound() != bound)
-				prop.setBound(bound);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT;
-		}
-		if (!prop.isSetConstrained()) {
-			if (prop.isConstrained() != constrained)
-				prop.setConstrained(constrained);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT;
-		}
-		prop.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Set the properties on the IndexedPropertyDecorator. These come from reflection. It is only the indexed portion. The base property portion
-	 * should have already been set. Since this is a private interface between BeaninfoClassAdapter and this class, not all possible settings need to
-	 * be mentioned. Only the ones that can be set by reflection. It is assumed that clear has already been done so that there are no old implicit
-	 * settings. It will check if properties are set already before setting so that don't wipe out explicit settings.
-	 * 
-	 * @param prop
-	 * @param indexedGetter
-	 * @param indexedSetter
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void setProperties(IndexedPropertyDecorator prop, Method indexedGetter, Method indexedSetter) {
-		long implicitSettings = prop.getImplicitlySetBits();
-		if (indexedGetter != null && !prop.isSetIndexedReadMethod()) {
-			prop.setIndexedReadMethod(indexedGetter);
-			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT;
-		}
-		if (indexedSetter != null && !prop.isSetIndexedWriteMethod()) {
-			prop.setIndexedWriteMethod(indexedSetter);
-			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT;
-		}
-		prop.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Set the properties on the EventSetDecorator. These come from reflection. Since this is a private interface between BeaninfoClassAdapter and
-	 * this class, not all possible settings need to be mentioned. Only the ones that can be set by reflection. It is assumed that clear has already
-	 * been done so that there are no old implicit settings. It will check if properties are set already before setting so that don't wipe out
-	 * explicit settings.
-	 * 
-	 * @param event
-	 * @param bound
-	 * @param constrained
-	 * @param getter
-	 * @param setter
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void setProperties(EventSetDecorator event, Method addListenerMethod, Method removeListenerMethod, boolean unicast,
-			JavaClass listenerType) {
-		long implicitSettings = event.getImplicitlySetBits();
-		if (addListenerMethod != null && !event.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod())) {
-			event.setAddListenerMethod(addListenerMethod);
-			implicitSettings |= EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT;
-		}
-		if (removeListenerMethod != null && !event.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod())) {
-			event.setRemoveListenerMethod(removeListenerMethod);
-			implicitSettings |= EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT;
-		}
-		if (!event.isSetUnicast()) {
-			if (event.isUnicast() != unicast)
-				event.setUnicast(unicast);
-			implicitSettings |= PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT;
-		}
-		if (listenerType != null && !event.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType())) {
-			event.setListenerType(listenerType);
-			implicitSettings |= EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT;
-		}
-
-		event.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
-	}
-
-	/**
-	 * Build the appropriate change record for the bean decorator. Either it is an add of a new bean decorator or it is the setting of the implicit
-	 * settings on an non-implicit bean decorator.
-	 * @param cd
-	 * @param bd
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void buildChange(ChangeDescription cd, BeanDecorator bd) {
-		// Only do anything if merge introspection. If no merge introspection, then there is no change needed.
-		if (bd.isMergeIntrospection()) {
-			if (bd.getImplicitDecoratorFlag() != ImplicitItem.NOT_IMPLICIT_LITERAL) {
-				// It is implicit, so do an add to end, new value.
-				doAddToEnd(cd, getFeatureChangeList(cd, bd.getEModelElement()), EcorePackage.eINSTANCE.getEModelElement_EAnnotations(), bd, true);
-			} else {
-				// Just do sets on implicit changed ones
-				buildNonImplicitChange(cd, getFeatureChangeList(cd, bd), bd);
-			}
-		}
-
-	}
-
-	/**
-	 * Build the appropriate change record for the property decorator. Either it is an add of a new property decorator or it is the setting of the implicit
-	 * settings on an non-implicit property decorator. The same is true of the feature that it decorates. It may be new or it may be an existing one.
-	 * @param cd
-	 * @param pd
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void buildChange(ChangeDescription cd, PropertyDecorator pd) {
-		// Only do changes if merge introspection. If not merging, then there are no changes.
-		if (pd.isMergeIntrospection()) {
-			boolean indexed = pd.eClass().getClassifierID() == BeaninfoPackage.INDEXED_PROPERTY_DECORATOR;
-			EStructuralFeature feature = (EStructuralFeature) pd.getEModelElement();
-			switch (pd.getImplicitDecoratorFlag().getValue()) {
-				case ImplicitItem.IMPLICIT_DECORATOR:
-					// The decorator is implicit, so clone it, and apply to feature, and then do the standard property applies to the feature.
-					List fcs = getFeatureChangeList(cd, feature);
-					doAddToEnd(cd, fcs, pd.eContainingFeature(), pd, true);
-					buildNonImplicitChange(cd, fcs, feature, indexed);
-					break;
-				case ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE:
-					// The decorator AND feature are implicit. Just clone them and add to the class.
-					doAddToEnd(cd, getFeatureChangeList(cd, feature.eContainer()), feature.eContainingFeature(), feature, true);
-					break;
-				case ImplicitItem.NOT_IMPLICIT:
-					// Neither the feature nor the decorator are implicit. So need to do applies against them.
-					buildNonImplicitChange(cd, getFeatureChangeList(cd, pd), pd, indexed);
-					buildNonImplicitChange(cd, getFeatureChangeList(cd, feature), feature, indexed);
-					break;
-			}
-		}
-	}
-	
-	/**
-	 * Build the appropriate change record for the event set decorator. Either it is an add of a new event set decorator or it is the setting of the implicit
-	 * settings on an non-implicit event set decorator. The same is true of the feature that it decorates. It may be new or it may be an existing one.
-	 * @param cd
-	 * @param ed
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void buildChange(ChangeDescription cd, EventSetDecorator ed) {
-		// Only build changes if merge introspection. If not merge then there are no changes.
-		if (ed.isMergeIntrospection()) {
-			JavaEvent event = (JavaEvent) ed.getEModelElement();
-			switch (ed.getImplicitDecoratorFlag().getValue()) {
-				case ImplicitItem.IMPLICIT_DECORATOR:
-					// The decorator is implicit, so clone it, and apply to feature, and then do the standard property applies to the feature.
-					List fcs = getFeatureChangeList(cd, event);
-					doAddToEnd(cd, fcs, ed.eContainingFeature(), ed, true);
-					buildNonImplicitChange(cd, fcs, event);
-					break;
-				case ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE:
-					// The decorator AND feature are implicit. Just clone them and add to the class.
-					doAddToEnd(cd, getFeatureChangeList(cd, event.eContainer()), event.eContainingFeature(), event, true);
-					break;
-				case ImplicitItem.NOT_IMPLICIT:
-					// Neither the feature nor the decorator are implicit. So need to do applies against them.
-					buildNonImplicitChange(cd, getFeatureChangeList(cd, ed), ed);
-					buildNonImplicitChange(cd, getFeatureChangeList(cd, event), event);
-					break;
-			}
-		}
-	}
-
-	/**
-	 * Build the appropriate change record for the method decorator. Either it is an add of a new method decorator or it is the setting of the implicit
-	 * settings on an non-implicit method decorator. The same is true of the operation that it decorates. It may be new or it may be an existing one.
-	 * @param cd
-	 * @param md
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void buildChange(ChangeDescription cd, MethodDecorator md) {
-		// Only do any builds if merge introspection. If not merge introspection then nothing should be changed.
-		if (md.isMergeIntrospection()) {
-			EOperation oper = (EOperation) md.getEModelElement();
-			switch (md.getImplicitDecoratorFlag().getValue()) {
-				case ImplicitItem.IMPLICIT_DECORATOR:
-					// The decorator is implicit, so clone it, and apply to feature, and then do the standard property applies to the feature.
-					List fcs = getFeatureChangeList(cd, oper);
-					doAddToEnd(cd, fcs, md.eContainingFeature(), md, true);
-					buildNonImplicitChange(cd, fcs, oper);
-					break;
-				case ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE:
-					// The decorator AND feature are implicit. Just clone them and add to the class.
-					doAddToEnd(cd, getFeatureChangeList(cd, oper.eContainer()), oper.eContainingFeature(), oper, true);
-					break;
-				case ImplicitItem.NOT_IMPLICIT:
-					// Neither the feature nor the decorator are implicit. So need to do applies against them.
-					buildNonImplicitChange(cd, getFeatureChangeList(cd, md), md);
-					buildNonImplicitChange(cd, getFeatureChangeList(cd, oper), oper);
-					break;
-			}
-		}
-	}
-	
-	private final static Integer ZERO = new Integer(0);
-	private final static Integer ONE = new Integer(1);
-	private final static Integer MINUS_ONE = new Integer(-1);
-	
-	/**
-	 * Build the non-implicit changes into the feature. This creates changes for the implicit settings
-	 * that always occur for a property decorator.
-	 *  
-	 * @param cd
-	 * @param fcs FeatureChanges list for the feature.
-	 * @param feature
-	 * @param indexed <code>true</code> if this is for an indexed feature.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, EStructuralFeature feature, boolean indexed) {
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getENamedElement_Name(), feature.getName(), false);
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getEStructuralFeature_Transient(), Boolean.FALSE, false);
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getEStructuralFeature_Volatile(), Boolean.FALSE, false);
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getEStructuralFeature_Changeable(), Boolean.valueOf(feature.isChangeable()), false);
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_EType(), feature.getEType(), false);
-		if (!indexed) {
-			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_LowerBound(), ZERO, false);
-			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_UpperBound(), ONE, false);
-		} else {
-			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_LowerBound(), ZERO, false);
-			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_UpperBound(), MINUS_ONE, false);
-			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_Unique(), Boolean.TRUE, false);
-		}
-	}
-
-	/**
-	 * Build the non-implicit changes into the event. This creates changes for the implicit settings
-	 * that always occur for an event set decorator.
-	 *  
-	 * @param cd
-	 * @param fcs FeatureChanges list for the feature.
-	 * @param event
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, JavaEvent event) {
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getENamedElement_Name(), event.getName(), false);
-	}
-
-	/**
-	 * Build the non-implicit changes into the operation. This creates changes for the implicit settings
-	 * that always occur for an method decorator.
-	 *  
-	 * @param cd
-	 * @param fcs FeatureChanges list for the feature.
-	 * @param oper
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, EOperation oper) {
-		doSet(cd, fcs, EcorePackage.eINSTANCE.getENamedElement_Name(), oper.getName(), false);
-		try {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getMethodProxy_Method(), ((MethodProxy) oper).getMethod(), false);	// This is a method that is not in this resource, so no clone.
-		} catch (ClassCastException e) {
-			// It will be a MethodProxy 99.9% of the time, so save by not doing instanceof.
-		}
-	}
-
-	/**
-	 * Build up the changes for a non-implicit feature decorator. This means create changes for implicit set features.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            the FeatureChanges list for the given decorator.
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, FeatureDecorator decor) {
-		long implicitSettings = decor.getImplicitlySetBits();
-		if (implicitSettings != 0)
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_ImplicitlySetBits(), new Long(implicitSettings), false);
-		
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_DisplayName(), decor.getDisplayName(), false);
-		}
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_ShortDescription(), decor.getShortDescription(), false);
-		}
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Category(), decor.getCategory(), false);
-		}
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT) != 0 && decor.isSetExpert()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Expert(), Boolean.valueOf(decor.isExpert()), false);
-		}
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT) != 0 && decor.isSetHidden()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Hidden(), Boolean.valueOf(decor.isHidden()), false);
-		}
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT) != 0 && decor.isSetPreferred()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Preferred(), Boolean.valueOf(decor.isPreferred()), false);
-		}
-		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT) != 0) {
-			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Attributes(), decor.getAttributes(), true);
-		}
-	}
-
-	/**
-	 * Build up the changes for a non-implicit bean decorator. This means create changes for implicit set features.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            the FeatureChanges list for the given decorator.
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, BeanDecorator decor) {
-		buildNonImplicitChange(cd, fcs, (FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_CustomizerClass(), decor.getCustomizerClass(), false); // Customizer class is
-																															 // not in this resource,
-																															 // so we don't clone it.
-		}
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT) != 0 && decor.isSetMergeSuperProperties()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_MergeSuperProperties(), Boolean.valueOf(decor.isMergeSuperProperties()), false);
-		}
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT) != 0 && decor.isSetMergeSuperMethods()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_MergeSuperMethods(), Boolean.valueOf(decor.isMergeSuperMethods()), false);
-		}
-		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT) != 0 && decor.isSetMergeSuperEvents()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_MergeSuperEvents(), Boolean.valueOf(decor.isMergeSuperEvents()), false);
-		}
-		if (!decor.getNotInheritedPropertyNames().isEmpty()) {
-			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames(), decor.getNotInheritedPropertyNames(), false);
-		}
-		if (!decor.getNotInheritedMethodNames().isEmpty()) {
-			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames(), decor.getNotInheritedMethodNames(), false);
-		}
-		if (!decor.getNotInheritedEventNames().isEmpty()) {
-			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames(), decor.getNotInheritedEventNames(), false);
-		}
-	}
-
-	/**
-	 * Build up the changes for a non-implicit property decorator. This means create changes for implicit set features.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            the FeatureChanges list for the given decorator.
-	 * @param decor
-	 * @param indexed <code>true</code> if this is an indexed property decorator.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, PropertyDecorator decor, boolean indexed) {
-		buildNonImplicitChange(cd, fcs, decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_PropertyEditorClass(), decor.getPropertyEditorClass(), false); // Property Editor class is
-																															 // not in this resource,
-																															 // so we don't clone it.
-		}
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_ReadMethod(), decor.getReadMethod(), false); 
-		}
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_WriteMethod(), decor.getWriteMethod(), false); 
-		}
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_FIELD_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_Field(), decor.getField(), false); 
-			if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getPropertyDecorator_FieldReadOnly()))
-				doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_FieldReadOnly(), Boolean.valueOf(decor.isFieldReadOnly()), false);
-		}		
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT) != 0 && decor.isSetBound()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_Bound(), Boolean.valueOf(decor.isBound()), false);
-		}
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT) != 0 && decor.isSetConstrained()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_Constrained(), Boolean.valueOf(decor.isConstrained()), false);
-		}
-		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_DesignTime(), Boolean.valueOf(decor.isDesignTime()), false);
-		}
-		
-		if (indexed) {
-			IndexedPropertyDecorator ipd = (IndexedPropertyDecorator) decor;
-			if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT) != 0) {
-				doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getIndexedPropertyDecorator_IndexedReadMethod(), ipd.getIndexedReadMethod(), false); 
-			}
-			if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT) != 0) {
-				doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getIndexedPropertyDecorator_IndexedWriteMethod(), ipd.getIndexedWriteMethod(), false); 
-			}
-		}
-	}
-	
-	/**
-	 * Build up the changes for a non-implicit event set decorator. This means create changes for implicit set features.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            the FeatureChanges list for the given decorator.
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, EventSetDecorator decor) {
-		buildNonImplicitChange(cd, fcs, (FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod(), decor.getAddListenerMethod(), false); // listener method is
-																															 // not in this resource,
-																															 // so we don't clone it.
-		}
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_EventAdapterClass(), decor.getEventAdapterClass(), false);
-		}
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT) != 0) {
-			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_SerListMthd(), decor.getSerListMthd(), true);	// These need to be cloned because they are contained here.
-		}
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType(), decor.getListenerType(), false);
-		}
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT) != 0) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod(), decor.getRemoveListenerMethod(), false);
-		}
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT) != 0 && decor.isSetInDefaultEventSet()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_InDefaultEventSet(), Boolean.valueOf(decor.isInDefaultEventSet()), false);
-		}
-		if ((implicitSettings & EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT) != 0 && decor.isSetUnicast()) {
-			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_Unicast(), Boolean.valueOf(decor.isUnicast()), false);
-		}
-	}
-
-	/**
-	 * Build up the changes for a non-implicit method decorator. This means create changes for implicit set features.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            the FeatureChanges list for the given decorator.
-	 * @param decor
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, MethodDecorator decor) {
-		buildNonImplicitChange(cd, fcs, (FeatureDecorator) decor);
-		long implicitSettings = decor.getImplicitlySetBits();
-		if ((implicitSettings & MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT) != 0) {
-			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getMethodDecorator_SerParmDesc(), decor.getSerParmDesc(), true); 
-		}
-	}
-
-
-	/**
-	 * Get the feature change list for an object. Create it one if necessary.
-	 * 
-	 * @param cd
-	 * @param object
-	 * @return feature change list.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static List getFeatureChangeList(ChangeDescription cd, EObject object) {
-		List fcs = (List) cd.getObjectChanges().get(object); // Get the feature changes if any.
-		if (fcs == null) {
-			Map.Entry entry = ChangeFactory.eINSTANCE.createEObjectToChangesMapEntry(object);
-			cd.getObjectChanges().add(entry);
-			fcs = (List) entry.getValue();
-		}
-		return fcs;
-	}
-
-	/**
-	 * Return the FeatureChange record for a feature wrt/object. Create one if necessary. If it creates it, it will mark it as "set". All of our
-	 * changes here are set kind of changes, not unset kind.
-	 * 
-	 * @param fcs
-	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
-	 * @param feature
-	 * @return feature change
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static FeatureChange getFeatureChange(List fcs, EStructuralFeature feature) {
-		if (!fcs.isEmpty()) {
-			for (int i = 0; i < fcs.size(); i++) {
-				FeatureChange fc = (FeatureChange) fcs.get(i);
-				if (fc.getFeature() == feature)
-					return fc;
-			}
-		}
-
-		// Either new object changes or no feature change found. Create one.
-		FeatureChange fc = ChangeFactory.eINSTANCE.createFeatureChange(feature, null, true);
-		fcs.add(fc);
-		return fc;
-	}
-
-	/**
-	 * Create a change for add to end of the given feature (must be isMany()). If newObject is true, then this means this is not a pointer to an
-	 * existing object and so it must be cloned. It is assumed that there will be no further changes to this object because those will not be known
-	 * about.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
-	 * @param feature
-	 *            the feature being added to.
-	 * @param addedValue
-	 *            the value being added.
-	 * @param newValue
-	 *            <code>true</code> if new object in the resource, a clone will be made. <code>false</code> if an existing object. Must be an
-	 *            EObject for cloning. Best if not true for non-eobjects.
-	 * @return the addedValue or the clone if it was cloned.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static Object doAddToEnd(ChangeDescription cd, List fcs, EStructuralFeature feature, Object addedValue, boolean newValue) {
-		FeatureChange fc = getFeatureChange(fcs, feature);
-		if (newValue) {
-			try {
-				addedValue = EcoreUtil.copy((EObject) addedValue);
-				cd.getObjectsToAttach().add(addedValue);
-			} catch (ClassCastException e) {
-				// Normally should not occur, but if it does, it means we can't clone, so don't clone.
-			}
-		}
-		List lcs = fc.getListChanges();
-		// Find the one with add and -1, i.e. add to end. There should only be one.
-		ListChange lc = null;
-		for (int i = 0; i < lcs.size(); i++) {
-			ListChange lca = (ListChange) lcs.get(i);
-			if (lca.getKind() == ChangeKind.ADD_LITERAL && lca.getIndex() == -1) {
-				lc = lca;
-				break;
-			}
-		}
-		if (lc == null) {
-			lc = ChangeFactory.eINSTANCE.createListChange();
-			lcs.add(lc);
-		}
-
-		lc.getValues().add(addedValue);
-		return addedValue;
-	}
-
-	/**
-	 * Create a change for add all to end of the given feature (must be isMany()). If newValue is true, then this means this is not a pointer to
-	 * existing objects and so it must be cloned. It is assumed that there will be no further changes to this object because those will not be known
-	 * about.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
-	 * @param feature
-	 *            the feature being added to.
-	 * @param addedValues
-	 *            the values being added.
-	 * @param newValue
-	 *            <code>true</code> if new objects in the resource, clones will be made. <code>false</code> if an existing object. Must be EObject
-	 *            for cloning. Best if not true for non-eobjects.
-	 * @return the addedValues or the clones if it was cloned.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static Object doAddAllToEnd(ChangeDescription cd, List fcs, EStructuralFeature feature, Collection addedValues, boolean newValue) {
-		FeatureChange fc = getFeatureChange(fcs, feature);
-		if (newValue) {
-			try {
-				addedValues = EcoreUtil.copyAll(addedValues);
-				cd.getObjectsToAttach().addAll(addedValues);
-			} catch (ClassCastException e) {
-				// Normally should not occur, but if it does, it means we can't clone, so don't clone.
-			}
-		}
-		List lcs = fc.getListChanges();
-		// Find the one with add and -1, i.e. add to end. There should only be one.
-		ListChange lc = null;
-		for (int i = 0; i < lcs.size(); i++) {
-			ListChange lca = (ListChange) lcs.get(i);
-			if (lca.getKind() == ChangeKind.ADD_LITERAL && lca.getIndex() == -1) {
-				lc = lca;
-				break;
-			}
-		}
-		if (lc == null) {
-			lc = ChangeFactory.eINSTANCE.createListChange();
-			lcs.add(lc);
-		}
-
-		lc.getValues().addAll(addedValues);
-		return addedValues;
-	}
-
-	/**
-	 * Create a change for set a given feature (must be !isMany()). If newValue is true, then this means this is not a pointer to an existing object
-	 * and so it must be cloned. It is assumed that there will be no further changes to this object because those will not be known about.
-	 * <p>
-	 * Any further sets to this feature will result in the previous setting being lost.
-	 * 
-	 * @param cd
-	 * @param fcs
-	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
-	 * @param feature
-	 *            the feature being set to.
-	 * @param setValue
-	 *            the value being set.
-	 * @param newValue
-	 *            <code>true</code> if new object in the resource, a clone will be made. <code>false</code> if an existing object. Must be an
-	 *            EObject for cloning. Best if not true for non-eobjects.
-	 * @return the setValue or the clone if it was cloned.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static Object doSet(ChangeDescription cd, List fcs, EStructuralFeature feature, Object setValue, boolean newValue) {
-
-		FeatureChange fc = getFeatureChange(fcs, feature);
-		if (newValue) {
-			try {
-				setValue = EcoreUtil.copy((EObject) setValue);
-				cd.getObjectsToAttach().add(setValue);
-			} catch (ClassCastException e) {
-				// Normally should not occur, but if it does, it means we can't clone, so don't clone.
-			}
-		}
-
-		if (setValue instanceof EObject)
-			fc.setReferenceValue((EObject) setValue);
-		else
-			fc.setDataValue(EcoreUtil.convertToString((EDataType) feature.getEType(), setValue));
-		return setValue;
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoAdapterFactory.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoAdapterFactory.java
deleted file mode 100644
index 1774b97..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoAdapterFactory.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: BeaninfoAdapterFactory.java,v $
- *  $Revision: 1.9 $  $Date: 2005/09/13 20:30:47 $ 
- */
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.WeakReference;
-import java.util.*;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.emf.common.notify.Adapter;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-
-import org.eclipse.jem.internal.beaninfo.core.*;
-import org.eclipse.jem.internal.java.beaninfo.IIntrospectionAdapter;
-import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
-import org.eclipse.jem.java.ArrayType;
-import org.eclipse.jem.util.emf.workbench.ProjectResourceSet;
-/**
- * BeaninfoAdapterFactory - the factory for 
- * beaninfo introspection to populate the Java Model.
- * Creation date: (11/1/2000 11:52:55 AM)
- * @author: Administrator
- */
-public class BeaninfoAdapterFactory extends AdapterFactoryImpl {
-	protected IBeaninfoSupplier fInfoSupplier;
-
-	// Maintain a mapping of the source objects to the adaptors which have
-	// introspected from them.  This allows a close operation to force those
-	// adapters to clear out the data. It also allows for marking an adapter as stale
-	// so that next time it introspects it will re-get the data.
-	// 
-	// This is a WeakReference so that we don't hold onto adapters that were
-	// explicitly removed in other ways.
-	private Map fIntrospected = new HashMap();	// NOTE: This is to be accessed only under sync(this)!
-	private ReferenceQueue fRefQ = new ReferenceQueue();
-	private static class WeakValue extends WeakReference {
-		private Object key;
-		public WeakValue(Object aKey, Object value, ReferenceQueue que) {
-			super(value, que);
-			key = aKey;
-		}
-
-		public Object getKey() {
-			return key;
-		}
-	};
-
-	public BeaninfoAdapterFactory(IBeaninfoSupplier supplier) {
-		fInfoSupplier = supplier;
-	}
-	
-	public Adapter createAdapter(Notifier target, Object type) {
-		if (type == IIntrospectionAdapter.ADAPTER_KEY) {
-			return !(target instanceof ArrayType) ? new BeaninfoClassAdapter(this) : null;	// Array types don't have beaninfo adapters.
-		} else
-			return new BeaninfoSuperAdapter();
-	}
-	
-	/**
-	 * @see org.eclipse.emf.common.notify.AdapterFactory#isFactoryForType(Object)
-	 */
-	public boolean isFactoryForType(Object type) {
-		return IIntrospectionAdapter.ADAPTER_KEY == type || BeaninfoSuperAdapter.ADAPTER_KEY == type;
-	}	
-
-	public ProxyFactoryRegistry getRegistry() {
-		return fInfoSupplier.getRegistry();
-	}
-	
-	public boolean isRegistryCreated() {
-		return fInfoSupplier.isRegistryCreated();
-	}
-
-	public ProxyFactoryRegistry recycleRegistry() {
-		markAllStale(); // At this point in time we need to mark them all stale because we are recycling. MarkAllStale also closes the registry.
-		return getRegistry();
-	}
-	
-	public IProject getProject() {
-		return fInfoSupplier.getProject();
-	}
-	
-	public ProjectResourceSet getNewResourceSet() {
-		return fInfoSupplier.getNewResourceSet();
-	}
-	
-	public ResourceSet getProjectResourceSet() {
-		return fInfoSupplier.getProjectResourceSet();
-	}
-
-	/**
-	 * Close ALL adapters. Also remove the adapters so that they
-	 * are not being held onto. This means we are closing the project or removing the nature.
-	 */
-	public void closeAll(boolean clearResults) {
-		processQueue();
-		synchronized (this) {
-			// We are going to be removing all of them, so just set introspected to an empty one
-			// and use the real one. This way we won't get concurrent modifications as we remove
-			// it from the notifier removeAdapter.
-			Map intr = fIntrospected;
-			fIntrospected = Collections.EMPTY_MAP;	// Since we are closing we can keep the unmodifiable one here.
-			Iterator i = intr.values().iterator();
-			while (i.hasNext()) {
-				BeaninfoClassAdapter a = (BeaninfoClassAdapter) ((WeakValue) i.next()).get();
-				if (a != null) {
-					if (clearResults)
-						a.clearIntrospection();
-					Notifier notifier = a.getTarget();
-					if (notifier != null)
-						notifier.eAdapters().remove(a);
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Mark all stale, but leave the overrides alone. The overrides aren't stale.
-	 * 
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public void markAllStale() {
-		markAllStale(false);
-	}
-
-	/**
-	 * Mark ALL adapters as stale. This occurs because we've recycled the registry.
-	 * 
-	 * @param clearOverrides clear the overrides too. This is full-fledged stale. The overrides are stale too.
-	 */
-	public void markAllStale(boolean clearOverrides) {
-		ProxyFactoryRegistry fact = isRegistryCreated() ? getRegistry() : null;
-		processQueue();
-		synchronized (this) {
-			Iterator i = fIntrospected.values().iterator();
-			while (i.hasNext()) {
-				BeaninfoClassAdapter a = (BeaninfoClassAdapter) ((WeakValue) i.next()).get();
-				if (a != null)
-					a.markStaleFactory(fact, clearOverrides);
-			}
-			fInfoSupplier.closeRegistry();	// Get rid of the registry now since it is not needed. This way we won't accidentily hold onto it when not needed.
-		}
-	}
-	/**
-	 * Mark the introspection as stale for a source object. Also clear results if told to.
-	 * @param sourceName Fully qualified source name, use type for reflection, i.e. "a.b.c.Class1$InnerClass"
-	 * @param clearResults clear out the results. If false, they will be reused if possible on recycle.
-	 */
-	public void markStaleIntrospection(String sourceName, boolean clearResults) {
-		processQueue();
-		synchronized (this) {
-			WeakValue ref = (WeakValue) fIntrospected.get(sourceName);
-			if (ref != null) {
-				BeaninfoClassAdapter a = (BeaninfoClassAdapter) ref.get();
-				if (a != null) {
-					if (clearResults)
-						a.clearIntrospection();
-					a.markStaleFactory(isRegistryCreated() ? getRegistry() : null); // Mark it stale with the current registry.
-				}
-			}
-		}
-	}
-	
-	public void markStaleIntrospectionPlusInner(String sourceName, boolean clearResults) {
-		processQueue();
-		String sourceNameForInner = sourceName + '$';
-		synchronized (this) {
-			Iterator itr = fIntrospected.entrySet().iterator();
-			while (itr.hasNext()) {
-				Map.Entry entry = (Map.Entry) itr.next();
-				String entryName = (String) entry.getKey();
-				if (entryName.equals(sourceName) || entryName.startsWith(sourceNameForInner)) {
-					// It is the item or one of its inner classes.
-					WeakValue ref = (WeakValue) entry.getValue();
-					BeaninfoClassAdapter a = (BeaninfoClassAdapter) ref.get();					
-					if (a != null) {
-						if (clearResults)
-							a.clearIntrospection();
-						a.markStaleFactory(isRegistryCreated() ? getRegistry() : null); // Mark it stale with the current registry.
-					}
-				}
-			}
-		}
-	}	
-
-	/**
-	 * Register an adapter for introspection.
-	 * @param sourceName Fully qualified source name, use type for reflection, i.e. "a.b.c.Class1$InnerClass"
-	 * @param adapter The adapter to register
-	 */
-	public void registerIntrospection(String sourceName, BeaninfoClassAdapter adapter) {
-		// Create it as a weak reference so that it doesn't hold onto the adapter if it is ever removed
-		// and thrown away (or the MOF resource itself is thrown away).
-		processQueue();
-		synchronized (this) {
-			fIntrospected.put(sourceName, new WeakValue(sourceName, adapter, fRefQ));
-		}
-	}
-	
-	/**
-	 * Remove adapter. This happens in the case that adapter is being removed and
-	 * we want to remove it from our list. This is an internal API only for use by
-	 * the adapter itself.
-	 */
-	public synchronized void removeAdapter(BeaninfoClassAdapter a) {
-		fIntrospected.remove(a.getJavaClass().getQualifiedNameForReflection());
-	}
-
-	private synchronized void processQueue() {
-		WeakValue wv;
-		while ((wv = (WeakValue) fRefQ.poll()) != null) {
-			fIntrospected.remove(wv.getKey());
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoClassAdapter.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoClassAdapter.java
deleted file mode 100644
index ce2165b..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoClassAdapter.java
+++ /dev/null
@@ -1,2600 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: BeaninfoClassAdapter.java,v $
- *  $Revision: 1.47 $  $Date: 2005/10/11 21:27:17 $ 
- */
-
-import java.io.FileNotFoundException;
-import java.lang.ref.WeakReference;
-import java.text.MessageFormat;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.emf.common.notify.Adapter;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.impl.AdapterImpl;
-import org.eclipse.emf.common.util.*;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.change.*;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.ESuperAdapter;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.*;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-
-import org.eclipse.jem.internal.beaninfo.*;
-import org.eclipse.jem.internal.beaninfo.common.*;
-import org.eclipse.jem.internal.beaninfo.core.*;
-import org.eclipse.jem.internal.beaninfo.core.BeanInfoCacheController.ClassEntry;
-import org.eclipse.jem.internal.java.beaninfo.IIntrospectionAdapter;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.internal.impl.JavaClassImpl;
-import org.eclipse.jem.util.TimerTests;
-import org.eclipse.jem.util.logger.proxy.Logger;
-
-import com.ibm.etools.emf.event.EventFactory;
-import com.ibm.etools.emf.event.EventUtil;
-
-/**
- * Beaninfo adapter for doing introspection on a Java Model class.
- * <p>
- * The first time a introspect request is made, it will use the ClassEntry from the cache controller to determine if it should load from the
- * cache or do a complete introspection. After that it will always do a complete introspection when it is marked as needing introspection.
- * This is because the cache is useless to us then. At that point in time we already know that we or one of our superclasses or one of 
- * outer classes has changed, thereby requiring us to reintrospect, the cache is invalid at that point. Also once we did an introspection we
- * don't want to do a load from cache but instead do a merge because someone may of been holding onto the features and we don't want to
- * throw them away unnecessarily.
- * <p> 
- * TODO Need to re-look into this to see if we can do a merge with the cache file because if it was an external jar and it has now gone
- * valid, why waste time reintrospecting. But this needs to be carefully thought about. 
- * <p> 
- * The resource change listener
- * will automatically mark any subclasses (both the BeaninfoClassAdapter and the ClassEntry) as being stale for us. That way we don't need
- * to waste time checking the ce and superclasses everytime. We will keep the ClassEntry around simply to make the marking of it as stale easier for the
- * resource listener. Finding the ce everytime would be expensive.
- * <p> 
- * This is the process for determining if introspection required:
- * <ol>
- * <li>If needsIntrospection flag is false, then do nothing. Doesn't need introspection.
- * <li>If class is undefined, then just set up for an undefined class and return. (In this case the CE should be thrown away, it should of been deleted).
- * <li>If never introspected (not RETRIEVED_FULL_DOCUMENT), get the CE, get the modification stamp and call isStaleStamp. This determines if this
- * stamp or any super class stamp is stale wrt to current stamp. If it is not stale, then load from cache because the cache is good. 
- * <li>If no cache or cache is stale or has introspected once, then introspect and replace cache.
- * </ol>
- * 
- */
-
-public class BeaninfoClassAdapter extends AdapterImpl implements IIntrospectionAdapter {
-	
-	public static final String REFLECT_PROPERTIES = "Reflect properties";	// Reflect properties in IDE //$NON-NLS-1$
-	public static final String APPLY_EXTENSIONS = "Apply Overrides";	// Apply override files //$NON-NLS-1$
-	public static final String REMOTE_INTROSPECT = "Remote Introspect";	// Introspect on remote //$NON-NLS-1$
-	public static final String INTROSPECT = "Introspect";	// Straight introspection, whether load from cache or introspect. //$NON-NLS-1$
-	public static final String LOAD_FROM_CACHE = "Load from Cache"; //$NON-NLS-1$
-	
-	
-	public static BeaninfoClassAdapter getBeaninfoClassAdapter(EObject jc) {
-		return (BeaninfoClassAdapter) EcoreUtil.getExistingAdapter(jc, IIntrospectionAdapter.ADAPTER_KEY);
-	}
-	
-	/**
-	 * Clear out the introspection because introspection is being closed or removed from the project.
-	 * Don't want anything hanging around that we had done.
-	 */
-	public void clearIntrospection() {
-		// Clear out the beandecorator if implicitly created.
-		Iterator beanItr = getJavaClass().getEAnnotationsInternal().iterator();
-		while (beanItr.hasNext()) {
-			EAnnotation dec = (EAnnotation) beanItr.next();
-			if (dec instanceof BeanDecorator) {
-				BeanDecorator decor = (BeanDecorator) dec;
-				if (decor.getImplicitDecoratorFlag() == ImplicitItem.IMPLICIT_DECORATOR_LITERAL) {
-					beanItr.remove();
-					((InternalEObject) decor).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-				} else {
-					BeanInfoDecoratorUtility.clear((BeanDecorator) dec);
-				}
-				break;
-			}
-		}
-		// Clear out the features that we implicitly created.
-		Iterator propItr = getJavaClass().getEStructuralFeaturesInternal().iterator();
-		while (propItr.hasNext()) {
-			EStructuralFeature prop = (EStructuralFeature) propItr.next();
-			Iterator pdItr = prop.getEAnnotations().iterator();
-			while (pdItr.hasNext()) {
-				EAnnotation dec = (EAnnotation) pdItr.next();
-				if (dec instanceof PropertyDecorator) {
-					PropertyDecorator pd = (PropertyDecorator) dec;
-					if (pd.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL)
-						BeanInfoDecoratorUtility.clear(pd);
-					else {
-						pdItr.remove(); // Remove it from the property.
-						((InternalEObject) pd).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-					}
-					if (pd.getImplicitDecoratorFlag() == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-						propItr.remove(); // Remove the feature itself
-						((InternalEObject) prop).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-					}
-					break;
-				}
-			}
-		}
-		
-		// Clear out the operations that we implicitly created.
-		Iterator operItr = getJavaClass().getEOperationsInternal().iterator();
-		while (operItr.hasNext()) {
-			EOperation oper = (EOperation) operItr.next();
-			Iterator mdItr = oper.getEAnnotations().iterator();
-			while (mdItr.hasNext()) {
-				EAnnotation dec = (EAnnotation) mdItr.next();
-				if (dec instanceof MethodDecorator) {
-					MethodDecorator md = (MethodDecorator) dec;
-					if (md.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL)
-						BeanInfoDecoratorUtility.clear(md);
-					else {
-						mdItr.remove(); // Remove it from the operation.
-						((InternalEObject) md).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-					}
-					if (md.getImplicitDecoratorFlag() == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-						operItr.remove(); // Remove the oepration itself
-						((InternalEObject) oper).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-					}
-					break;
-				}
-			}
-			
-			// Clear out the events that we implicitly created.
-			Iterator evtItr = getJavaClass().getEventsGen().iterator();
-			while (evtItr.hasNext()) {
-				JavaEvent evt = (JavaEvent) evtItr.next();
-				Iterator edItr = evt.getEAnnotations().iterator();
-				while (edItr.hasNext()) {
-					EAnnotation dec = (EAnnotation) edItr.next();
-					if (dec instanceof EventSetDecorator) {
-						EventSetDecorator ed = (EventSetDecorator) dec;
-						if (ed.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL)
-							BeanInfoDecoratorUtility.clear(ed);
-						else {
-							edItr.remove(); // Remove it from the event.
-							((InternalEObject) ed).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-						}
-						if (ed.getImplicitDecoratorFlag() == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-							evtItr.remove(); // Remove the event itself
-							((InternalEObject) evt).eSetProxyURI(BAD_URI); // Mark it as bad proxy so we know it is no longer any use.
-						}
-						break;
-					}
-				}
-			}				
-		}
-
-		synchronized(this) {
-			needsIntrospection = true;
-		}
-	}
-	
-	private void clearAll() {
-		clearIntrospection();	// First get rid of the ones we did so that they are marked as proxies.
-		
-		// Clear out the annotations.
-		getJavaClass().getEAnnotationsInternal().clear();
-		// Clear out the attributes.
-		getJavaClass().getEStructuralFeaturesInternal().clear();	
-		// Clear out the operations.
-		getJavaClass().getEOperationsInternal().clear();
-		// Clear out the events.
-		getJavaClass().getEventsGen().clear();
-		
-		retrievedExtensionDocument = NEVER_RETRIEVED_EXTENSION_DOCUMENT;	// Since we cleared everything, go back to no doc applied.
-	}
-	
-
-	/**
-	 * @version 	1.0
-	 * @author
-	 */
-
-	// A URI that will never resolve. Used to mark an object as no longer valid.
-	protected static final URI BAD_URI = URI.createURI("baduri"); //$NON-NLS-1$
-
-	protected boolean needsIntrospection = true;
-	
-	protected BeanInfoCacheController.ClassEntry classEntry;
-	
-	protected boolean isIntrospecting;
-
-	protected boolean isDoingAllProperties;
-
-	protected boolean isDoingAllOperations;
-
-	protected boolean isDoingAllEvents;
-
-	protected final static int
-		NEVER_RETRIEVED_EXTENSION_DOCUMENT = 0,
-		RETRIEVED_ROOT_ONLY = 1,
-		RETRIEVED_FULL_DOCUMENT = 2,
-		CLEAR_EXTENSIONS = 3;
-	protected int retrievedExtensionDocument = NEVER_RETRIEVED_EXTENSION_DOCUMENT;
-
-	protected BeaninfoAdapterFactory adapterFactory;
-
-	private WeakReference staleFactory; // When reference not null, then this factory is a stale factory and 
-	// a new one is needed when the factory returned == this one.
-	// It is a WeakRef so that if the factory goes away on its own
-	// that we don't hold onto it.
-
-	// A temporary hashset of the local properties. Used when creating a new
-	// property to use the old one. It is cleared out at the end of attribute introspection.
-	// It is only built once during attribute introspection so that we have the snapshot
-	// of before the introspection (i.e. the ones that were specifically added by users
-	// and not through introspection). The ones that we are adding do not need to be checked
-	// against each other because there will not be conflicts.
-	//
-	// Also at the end, we will go through the properties and see if it exists in the fPropertiesMap and
-	// it is not the value Boolean.FALSE in the map, and the entry is implicitly created. This means this
-	// was an implicit entry from the previous introspection and was not re-created in this introspection.
-	private HashMap propertiesMap;
-	private List featuresRealList; // Temp pointer to the real list we are building. It is the true list in java class.
-	
-	// A temporary hashmap of the local operations. Used when creating a new
-	// operation to reuse the old one. It is cleared out at the end of operation introspection.
-	// It is only built once during operation introspection so that we have the snapshot
-	// of before the introspection.
-	private HashMap operationsMap;
-	private EList operationsRealList; // Temp pointer to the real list we are building. It is the true list in java class.
-	// A set of operations as we create them so that we which ones we added/kept and which are no longer in use and can be removed.	
-	// If they aren't in this set at the end, then we know it should be removed if it is one we had created in the past.
-	private HashSet newoperations; 
-
-	// A temporary hashset of the local events. Used when creating a new
-	// event to use the old one. It is cleared out at the end of event introspection.
-	// It is only built once during event introspection so that we have the snapshot
-	// of before the introspection (i.e. the ones that were specifically added by users
-	// and not through introspection). The ones that we are adding do not need to be checked
-	// against each other because there will not be conflicts.
-	//
-	// Also at the end, we will go through the events and see if it exists in the fEventsMap and
-	// it is not the value Boolean.FALSE in the map, and the entry is implicitly created. This means this
-	// was an implicit entry from the previous introspection and was not re-created in this introspection.
-	private HashMap eventsMap;
-	private EList eventsRealList; // Temp pointer to the real list we are building. It is the true list in java class.
-
-	private Boolean defaultBound;
-	// Whether this class is default bound or not (i.e. does this class implement add/remove property change listener. If null, then not yet queried.
-
-	public BeaninfoClassAdapter(BeaninfoAdapterFactory factory) {
-		super();
-		adapterFactory = factory;
-	}
-
-	/*
-	 * Answer whether this java class is still connected to a live resource. It happens during unloading
-	 * that we are no longer connected to a resource (because the javapackage has already been processed and
-	 * unloaded) or the resource is in the process of being unloaded, but the unloading process will still 
-	 * call accessors on this java class, which will come over here. In those cases we should treat as
-	 * introspection completed without doing anything.
-	 */
-	protected boolean isResourceConnected() {
-		Resource res = getJavaClass().eResource();
-		return res != null && res.isLoaded();
-	}
-
-	protected final ProxyFactoryRegistry getRegistry() {
-		ProxyFactoryRegistry factory = adapterFactory.getRegistry();
-		if (staleFactory != null && factory == staleFactory.get()) {
-			// We need to recycle the factory. The returned factory is the same factory when it went stale.
-			factory = adapterFactory.recycleRegistry();
-		}
-		staleFactory = null; // Whether we recycled or not, it is no longer stale.
-		return factory;
-	}
-
-	/**
-	 * Return whether this adapter has been marked as stale. Needed
-	 * by the users so that they can recycle if necessary.
-	 */
-	public boolean isStale() {
-		return staleFactory != null;
-	}
-
-	protected BeaninfoAdapterFactory getAdapterFactory() {
-		return adapterFactory;
-	}
-
-	public boolean isAdapterForType(Object key) {
-		return IIntrospectionAdapter.ADAPTER_KEY.equals(key);
-	}
-
-	/**
-	 * This map is keyed by name. It is a snapshot of the properties at the
-	 * time the introspection/reflection of properties was started. It is used
-	 * for quick lookup.
-	 *
-	 * Once a property is used, the entry is replaced with a Boolean.FALSE. This
-	 * is so we know which have already been used and at the end, which need
-	 * to be deleted since they weren't used (i.e. the ones that aren't FALSE).
-	 */
-	protected HashMap getPropertiesMap() {
-		if (propertiesMap == null) {
-			List localFeatures = getJavaClass().getEStructuralFeaturesInternal();
-			propertiesMap = new HashMap(localFeatures.size());
-			Iterator itr = localFeatures.iterator();
-			while (itr.hasNext()) {
-				EStructuralFeature feature = (EStructuralFeature) itr.next();
-				propertiesMap.put(feature.getName(), feature);
-			}
-		}
-		return propertiesMap;
-	}
-
-	/**
-	 * Get it once so that we don't need to keep getting it over and over.
-	 */
-	protected List getFeaturesList() {
-		if (featuresRealList == null)
-			featuresRealList = getJavaClass().getEStructuralFeaturesInternal();
-		return featuresRealList;
-	}
-
-	/**
-	 * The map is keyed by longName. If a Method is passed in, then the
-	 * id of the method is used (this is in reflection), if an IBeanProxy
-	 * is passed in, then an id is created and looked up (this is in introspection).
-	 * The map is used for a quick lookup of behaviors at the time introspection
-	 * of behaviors started.
-	 */
-	protected HashMap getOperationsMap() {
-		if (operationsMap == null) {
-			List locals = getJavaClass().getEOperationsInternal();
-			int l = locals.size();
-			operationsMap = new HashMap(l);
-			for (int i = 0; i < l; i++) {
-				EOperation op = (EOperation) locals.get(i);
-				operationsMap.put(formLongName(op), op);
-			}
-		}
-		return operationsMap;
-	}
-
-	/**
-	 * Get it once so that we don't need to keep getting it over and over.
-	 */
-	protected EList getOperationsList() {
-		if (operationsRealList == null)
-			operationsRealList = getJavaClass().getEOperationsInternal();
-		return operationsRealList;
-	}
-
-	/**
-	 * The map is keyed by name.
-	 * The map is used for a quick lookup of events at the time introspection
-	 * of events started.
-	 *
-	 * Once an event is used, the entry is replaced with a Boolean.FALSE. This
-	 * is so we know which have already been used and at the end, which need
-	 * to be deleted since they weren't used (i.e. the ones that aren't FALSE).
-	 */
-	protected HashMap getEventsMap() {
-		if (eventsMap == null) {
-			List locals = getJavaClass().getEventsGen();
-			eventsMap = new HashMap(locals.size());
-			Iterator itr = locals.iterator();
-			while (itr.hasNext()) {
-				JavaEvent event = (JavaEvent) itr.next();
-				eventsMap.put(event.getName(), event);
-			}
-		}
-		return eventsMap;
-	}
-
-	/**
-	 * Get it once so that we don't need to keep getting it over and over.
-	 */
-	protected EList getEventsList() {
-		if (eventsRealList == null)
-			eventsRealList = getJavaClass().getEventsGen();
-		return eventsRealList;
-	}
-
-	public void introspectIfNecessary() {
-		introspectIfNecessary(false);
-	}
-	
-	protected void introspectIfNecessary(boolean doOperations) {
-		boolean doIntrospection = false;
-		synchronized (this) {
-			doIntrospection = needsIntrospection && !isIntrospecting; 
-			if (doIntrospection)
-				isIntrospecting = true;
-		}
-		if (doIntrospection) {
-			boolean didIntrospection = false;
-			try {				
-				introspect(doOperations);
-				didIntrospection = true;
-			} catch (Throwable e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(
-					new Status(
-						IStatus.WARNING,
-						BeaninfoPlugin.getPlugin().getBundle().getSymbolicName(),
-						0,
-						MessageFormat.format(
-							BeanInfoAdapterMessages.INTROSPECT_FAILED_EXC_, 
-							new Object[] { getJavaClass().getJavaName(), ""}), //$NON-NLS-1$
-						e));
-			} finally {
-				synchronized (this) {
-					isIntrospecting = false;
-					needsIntrospection = !didIntrospection;
-				}
-			}
-		}
-	}
-
-	/**
-	 * Get the class entry. 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public BeanInfoCacheController.ClassEntry getClassEntry() {
-		return classEntry;
-	}
-	
-	private boolean canUseCache() {
-		// We check our level, we assume not stale unless CE says stale.
-		synchronized (this) {
-			// We may already have a class entry due to a subclass doing a check, so if we do, we'll use it. Else we'll get the latest one.
-			if (classEntry == null)
-				classEntry = BeanInfoCacheController.INSTANCE.getClassEntry(getJavaClass());
-			if (classEntry != null) {
-				// We have a cache to check.
-				long modStamp = classEntry.getModificationStamp();
-				// A sanity check, if this was an old, but now deleted one we want to throw it away and get it again. It may now be valid.
-				if (modStamp == BeanInfoCacheController.ClassEntry.DELETED_MODIFICATION_STAMP) {
-					classEntry = BeanInfoCacheController.INSTANCE.getClassEntry(getJavaClass());
-					if (classEntry != null)
-						modStamp = classEntry.getModificationStamp();
-				}
-				if (modStamp == IResource.NULL_STAMP || modStamp == BeanInfoCacheController.ClassEntry.DELETED_MODIFICATION_STAMP)
-					return false;	// We are stale.
-			} else
-				return false;	// We don't have a cache entry to check against, which means are deleted, or never cached.
-		}
-		
-		// Now try the supers to see if we are out of date to them.
-		// Note: Only if this is an interface could there be more than one eSuperType.
-		List supers = getJavaClass().getESuperTypes();
-		if (!supers.isEmpty()) {
-			BeaninfoClassAdapter bca = getBeaninfoClassAdapter((EObject) supers.get(0));
-			ClassEntry superCE = bca.getClassEntry();
-			// If super is defined and out of date don't use cache. If super is undefined and super modification stamp is not super_undefined,
-			// then that means it was defined at time of cache and now not defined, so don't use cache.
-			if (superCE != null) {
-				if (superCE.getModificationStamp() != classEntry.getSuperModificationStamp())
-					return false; // Out-of-date wrt/super.
-			} else if (classEntry.getSuperModificationStamp() != ClassEntry.SUPER_UNDEFINED_MODIFICATION_STAMP)
-				return false;	// was previously defined, and now undefined, so out of date.
-			String[] iNames = classEntry.getInterfaceNames();
-			if (iNames != null) {
-				if (iNames.length != supers.size() - 1)
-					return false; // We have a different number of supers, so stale.
-				// Now the interfaces may not be in the same order, but there shouldn't be too many, so we'll use O(n2) lookup. We'll try starting at
-				// the same index just in case. That way if they are the same order it will be linear instead. Most likely will be same order.
-				long[] iStamp = classEntry.getInterfaceModificationStamps();
-				for (int i = 1; i <= iNames.length; i++) {
-					JavaClass javaClass = (JavaClass) supers.get(i);
-					String intName = (javaClass).getQualifiedNameForReflection();
-					// Find it in the names list.
-					int stop = i-1;
-					int indx = stop;	// Start at the stop, when we hit it again we will be done.
-					boolean found = false;
-					do {
-						if (iNames[indx].equals(intName)) {
-							found = true;
-							break;
-						}
-					} while ((++indx)%iNames.length != stop);
-					if (!found)
-						return false;	// Couldn't find it, so we are stale.]
-					
-					superCE = getBeaninfoClassAdapter(javaClass).getClassEntry();
-					if (superCE != null) {
-						if (superCE.getModificationStamp() != iStamp[indx])
-							return false; // Out-of-date wrt/interface.
-					} else if (iStamp[indx] != ClassEntry.SUPER_UNDEFINED_MODIFICATION_STAMP)
-						return false;	// was previously defined, and now undefined, so out of date.
-				}
-			}
-		}
-		return true;	// If we got here everything is ok.
-	}
-
-	private boolean canUseOverrideCache() {
-		// We check our config stamp.
-		// TODO in future can we listen for config changes and mark classes stale if the config changes?
-		synchronized (this) {
-			// We may already have a class entry due to a subclass doing a check, so if we do, we'll use it. Else we'll get the latest one.
-			if (classEntry == null)
-				classEntry = BeanInfoCacheController.INSTANCE.getClassEntry(getJavaClass());
-			if (classEntry != null) {
-				// We have a cache to check.
-				// A sanity check, if this was an old, but now deleted one we want to throw it away and get it again. It may now be valid.
-				if (classEntry.isDeleted()) {
-					classEntry = BeanInfoCacheController.INSTANCE.getClassEntry(getJavaClass());
-					if (classEntry != null)
-						if (classEntry.isDeleted())
-							return false;	// We have been deleted. Probably shouldn't of gotton here in this case.
-				}
-			} else
-				return false;	// We don't have a cache entry to check against, which means are deleted, or never cached.
-			return classEntry.getConfigurationModificationStamp() == Platform.getPlatformAdmin().getState(false).getTimeStamp();
-		}
-		
-	}
-
-	/**
-	 * Check if the cache for this entry is stale compared to the modification stamp, or if the modification stamp itself is stale, meaning
-	 * subclass was stale already.
-	 * 
-	 * @param requestStamp the timestamp to compare against. 
-	 * @return <code>true</code> if we can use the incoming cache stamp.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected boolean canUseCache(long requestStamp) {
-		long modStamp;
-		// Now get the current mod stamp for this class so we can compare it.
-		synchronized (this) {
-			// We may already have a class entry due to a subclass doing a check, so if we do, we'll use it. Else we'll get the latest one.
-			if (classEntry == null)
-				classEntry = BeanInfoCacheController.INSTANCE.getClassEntry(getJavaClass());
-			if (classEntry != null) {
-				// We have a cache to check.
-				modStamp = classEntry.getModificationStamp();
-				// A sanity check, if this was an old, but now deleted one we want to throw it away and get it again. It may now be valid.
-				if (modStamp == BeanInfoCacheController.ClassEntry.DELETED_MODIFICATION_STAMP) {
-					classEntry = BeanInfoCacheController.INSTANCE.getClassEntry(getJavaClass());
-					if (classEntry != null)
-						modStamp = classEntry.getModificationStamp();
-				}
-				if (modStamp == IResource.NULL_STAMP && modStamp == BeanInfoCacheController.ClassEntry.DELETED_MODIFICATION_STAMP)
-					return false;	// Since we are stale, child asking question must also be stale and can't use the cache.
-			} else
-				return false;	// We don't have a cache entry to check against, so child must be stale too.
-		}
-		// If the requested stamp is not the same as ours, then it is out of date (it couldn't be newer but it could be older).
-		return requestStamp == modStamp;
-	}
-		
-	/*
-	 * This should only be called through introspectIfNecessary so that flags are set correctly.
-	 */
-	private void introspect(boolean doOperations) {
-		IBeanProxy beaninfo = null;
-		try {
-			if (isResourceConnected()) {
-				// See if are valid kind of class.
-				if (getJavaClass().getKind() == TypeKind.UNDEFINED_LITERAL) {
-					// Not valid, don't let any further introspection occur.
-					// Mark that we've done all introspections so as not to waste time until we get notified that it has been added
-					// back in.
-					synchronized(this) {
-						if (classEntry != null) {
-							classEntry.markDeleted();	// mark it deleted in case still sitting in cache (maybe because it was in an external jar, we can't know if deleted when jar changed).
-							classEntry = null;	// Get rid of it since now deleted.
-						}
-						needsIntrospection = false;
-					}
-					
-					if (retrievedExtensionDocument == RETRIEVED_FULL_DOCUMENT || retrievedExtensionDocument == CLEAR_EXTENSIONS) {
-						// We've been defined at one point. Need to clear everything and step back
-						// to never retrieved so that we now get the root added in. If we had been
-						// previously defined, then we didn't have root. We will have to lose
-						// all other updates too. But they can come back when we're defined.
-						// Or we've been asked to clear all.
-						clearAll();
-						retrievedExtensionDocument = NEVER_RETRIEVED_EXTENSION_DOCUMENT;
-					}
-					if (retrievedExtensionDocument == NEVER_RETRIEVED_EXTENSION_DOCUMENT)
-						applyExtensionDocument(true);	// Add in Root stuff so that it will work correctly even though undefined.
-				} else {
-					// TODO For now cause recycle of vm if any super type is stale so that if registry is stale for the super type it will be
-					// recreated. This is needed because reflection requires superProperties, etc. and recreating the registry
-					// currently re-marks everyone as stale, including this subclass. This would mean that
-					// re-introspection would need to be done, even though we just did it. The stale registry business needs to be re-addressed so that it is
-					// a lot smarter. 
-					List supers = getJavaClass().getEAllSuperTypes();
-					for (int i = 0; i < supers.size(); i++) {
-						BeaninfoClassAdapter bca = (BeaninfoClassAdapter) EcoreUtil.getExistingAdapter((EObject) supers.get(i),
-								IIntrospectionAdapter.ADAPTER_KEY);
-						if (bca != null && bca.isStale())
-							bca.getRegistry();
-					}
-					// Now we need to force introspection, if needed, of all parents because we need them to be up-to-date for the
-					// class entry.
-					// TODO see if we can come up with a better way that we KNOW the CE is correct, even if any supers are stale.
-					supers = getJavaClass().getESuperTypes();
-					for (int i = 0; i < supers.size(); i++) {
-						BeaninfoClassAdapter bca = (BeaninfoClassAdapter) EcoreUtil.getRegisteredAdapter((EObject) supers.get(i),
-								IIntrospectionAdapter.ADAPTER_KEY);
-						bca.introspectIfNecessary();
-					}
-
-					TimerTests.basicTest.startCumulativeStep(INTROSPECT);
-					if (retrievedExtensionDocument == RETRIEVED_ROOT_ONLY || retrievedExtensionDocument == CLEAR_EXTENSIONS) {
-						// We need to clear out EVERYTHING because we are coming from an undefined to a defined.
-						// Nothing previous is now valid. (Particularly the root stuff).
-						// Or we had a Clean requested and need to clear the extensions too.
-						clearAll();
-					}
-					boolean firstTime = false;
-					if (retrievedExtensionDocument != RETRIEVED_FULL_DOCUMENT) {
-						firstTime = true;	// If we need to apply the extension doc, then this is the first time.
-						applyExtensionDocument(false); // Apply the extension doc before we do anything.
-					}
-
-					// Now check to see if we can use the cache.
-					boolean doIntrospection = true;
-					if (firstTime) {
-						// Check if we can use the cache. Use Max value so that first level test (ourself) will always pass and go on to the supers.
-						if (canUseCache()) {
-							TimerTests.basicTest.startCumulativeStep(LOAD_FROM_CACHE);
-							// We can use the cache.
-							Resource cres = BeanInfoCacheController.INSTANCE.getCache(getJavaClass(), classEntry, true);
-							if (cres != null) {
-								try {
-									// Got a cache to use, now apply it.
-									for (Iterator cds = cres.getContents().iterator(); cds.hasNext();) {
-										ChangeDescription cacheCD = (ChangeDescription) cds.next();
-										cacheCD.apply();
-									}
-									// We need to walk through and create the appropriate ID's for events/actions/properties because by
-									// default from the change descriptions these don't get reflected back. And if some one doesn't
-									// use an ID to get them, they won't have an id set.
-									doIDs();
-									doIntrospection = false;
-								} catch (RuntimeException e) {
-									BeaninfoPlugin.getPlugin().getLogger().log(
-										MessageFormat.format(
-												BeanInfoAdapterMessages.INTROSPECT_FAILED_EXC_, 
-												new Object[] { getJavaClass().getJavaName(), ""}), //$NON-NLS-1$
-										Level.WARNING);
-									BeaninfoPlugin.getPlugin().getLogger().log(e);
-								} finally {
-									// Remove the cres since it is now invalid. The applies cause them to be invalid.
-									cres.getResourceSet().getResources().remove(cres);
-									if (doIntrospection) {
-										// Apply had failed. We don't know how far it went. We need to wipe out and reget EVERYTHING.
-										clearAll();
-										applyExtensionDocument(false); // Re-apply the extension doc before we do anything else.
-									}
-								}
-							}
-							TimerTests.basicTest.stopCumulativeStep(LOAD_FROM_CACHE);
-						}
-					}
-					
-					if (doIntrospection) {
-						// Finally we can get to handling ourselves.
-						TimerTests.basicTest.startCumulativeStep(REMOTE_INTROSPECT);
-						BeanDecorator decor = Utilities.getBeanDecorator(getJavaClass());
-						if (decor == null) {
-							decor = BeaninfoFactory.eINSTANCE.createBeanDecorator();
-							decor.setImplicitDecoratorFlag(ImplicitItem.IMPLICIT_DECORATOR_LITERAL);
-							getJavaClass().getEAnnotations().add(decor);
-						} else
-							BeanInfoDecoratorUtility.clear(decor);	// Clear out previous results.
-						
-						boolean doReflection = true;
-						if (doOperations)
-							newoperations = new HashSet(50);
-						if (decor.isDoBeaninfo()) {
-							int doFlags = 0;
-							if (decor == null || decor.isMergeIntrospection())
-								doFlags |= IBeanInfoIntrospectionConstants.DO_BEAN_DECOR;
-							if (decor == null || decor.isIntrospectEvents())
-								doFlags |= IBeanInfoIntrospectionConstants.DO_EVENTS;
-							if (decor == null || decor.isIntrospectProperties())
-								doFlags |= IBeanInfoIntrospectionConstants.DO_PROPERTIES;
-							if (doOperations && (decor == null || decor.isIntrospectMethods()))
-								doFlags |= IBeanInfoIntrospectionConstants.DO_METHODS;
-							
-							if (doFlags != 0) {
-								// There was something remote to do.
-								IBeanTypeProxy targetType = null;
-								ProxyFactoryRegistry registry = getRegistry();
-								if (registry != null && registry.isValid())
-									targetType = registry.getBeanTypeProxyFactory().getBeanTypeProxy(getJavaClass().getQualifiedNameForReflection());
-								if (targetType != null) {
-									if (targetType.getInitializationError() == null) {
-										// If an exception is thrown, treat this as no proxy, however log it because we
-										// shouldn't have exceptions during introspection, but if we do it should be logged
-										// so it can be corrected.
-										try {
-											beaninfo = getProxyConstants().getIntrospectProxy().invoke(null,
-													new IBeanProxy[] { targetType, getRegistry().getBeanProxyFactory().createBeanProxyWith(false), getRegistry().getBeanProxyFactory().createBeanProxyWith(doFlags)});
-										} catch (ThrowableProxy e) {
-											BeaninfoPlugin.getPlugin().getLogger().log(
-													new Status(IStatus.WARNING, BeaninfoPlugin.getPlugin().getBundle().getSymbolicName(), 0,
-															MessageFormat.format(BeanInfoAdapterMessages.INTROSPECT_FAILED_EXC_, new Object[] { //$NON-NLS-1$
-																	getJavaClass().getJavaName(), ""}), //$NON-NLS-1$
-																	e));
-										}
-									} else {
-										// The class itself couldn't be initialized. Just log it, but treat as no proxy.
-										BeaninfoPlugin.getPlugin().getLogger()
-										.log(
-												new Status(IStatus.WARNING, BeaninfoPlugin.getPlugin().getBundle().getSymbolicName(), 0,
-														MessageFormat.format(BeanInfoAdapterMessages.INTROSPECT_FAILED_EXC_, new Object[] { //$NON-NLS-1$
-																getJavaClass().getJavaName(), targetType.getInitializationError()}), null));
-									}
-								} else {
-									// The class itself could not be found. Just log it, but treat as no proxy.
-									BeaninfoPlugin.getPlugin().getLogger().log(
-											new Status(IStatus.INFO, BeaninfoPlugin.getPlugin().getBundle().getSymbolicName(), 0, MessageFormat.format(
-													BeanInfoAdapterMessages.INTROSPECT_FAILED_EXC_, new Object[] { 
-															getJavaClass().getJavaName(),
-															BeanInfoAdapterMessages.BeaninfoClassAdapter_ClassNotFound}), 
-															null));
-								}
-								
-								if (beaninfo != null) {
-									doReflection = false;	// We have a beaninfo, so we are doing introspection.
-									final BeanDecorator bdecor = decor;
-									// We have a beaninfo to process.
-									BeanInfoDecoratorUtility.introspect(beaninfo, new BeanInfoDecoratorUtility.IntrospectCallBack() {
-
-										/*; (non-Javadoc)
-										 * @see org.eclipse.jem.internal.beaninfo.adapters.BeanInfoDecoratorUtility.IntrospectCallBack#process(org.eclipse.jem.internal.beaninfo.common.BeanRecord)
-										 */
-										public BeanDecorator process(BeanRecord record) {
-											return bdecor;
-										}
-
-										/* (non-Javadoc)
-										 * @see org.eclipse.jem.internal.beaninfo.adapters.BeanInfoDecoratorUtility.IntrospectCallBack#process(org.eclipse.jem.internal.beaninfo.common.PropertyRecord)
-										 */
-										public PropertyDecorator process(PropertyRecord record) {
-											return calculateProperty(record, false);
-										}
-
-										/* (non-Javadoc)
-										 * @see org.eclipse.jem.internal.beaninfo.adapters.BeanInfoDecoratorUtility.IntrospectCallBack#process(org.eclipse.jem.internal.beaninfo.common.IndexedPropertyRecord)
-										 */
-										public PropertyDecorator process(IndexedPropertyRecord record) {
-											return calculateProperty(record, true);
-										}
-
-										/* (non-Javadoc)
-										 * @see org.eclipse.jem.internal.beaninfo.adapters.BeanInfoDecoratorUtility.IntrospectCallBack#process(org.eclipse.jem.internal.beaninfo.common.MethodRecord)
-										 */
-										public MethodDecorator process(MethodRecord record) {
-											return calculateOperation(record);
-										}
-
-										/* (non-Javadoc)
-										 * @see org.eclipse.jem.internal.beaninfo.adapters.BeanInfoDecoratorUtility.IntrospectCallBack#process(org.eclipse.jem.internal.beaninfo.common.EventSetRecord)
-										 */
-										public EventSetDecorator process(EventSetRecord record) {
-											return calculateEvent(record);
-										}
-									});
-								} 
-							}
-						}
-						
-						if (doReflection) {
-							// Need to do reflection stuff.
-							if (decor.isIntrospectProperties())
-								reflectProperties();
-							if (doOperations && decor.isIntrospectMethods())
-								reflectOperations();
-							if (decor.isIntrospectEvents())
-								reflectEvents();
-						}
-						ChangeDescription cd = ChangeFactory.eINSTANCE.createChangeDescription();						
-						BeanInfoDecoratorUtility.buildChange(cd, decor);
-						finalizeProperties(cd);
-						if (doOperations)
-							finalizeOperations(cd);
-						finalizeEvents(cd);
-
-						classEntry = BeanInfoCacheController.INSTANCE.newCache(getJavaClass(), cd, doOperations ? BeanInfoCacheController.REFLECTION_OPERATIONS_CACHE : BeanInfoCacheController.REFLECTION_CACHE);
-						TimerTests.basicTest.stopCumulativeStep(REMOTE_INTROSPECT); 
-					}
-					TimerTests.basicTest.stopCumulativeStep(INTROSPECT);
-				}
-				getAdapterFactory().registerIntrospection(getJavaClass().getQualifiedNameForReflection(), this);
-			}
-		} finally {
-			if (beaninfo != null) {
-				beaninfo.getProxyFactoryRegistry().releaseProxy(beaninfo); // Dispose of the beaninfo since we now have everything.
-			}
-			eventsMap = null; // Clear out the temp lists.
-			eventsRealList = null;
-			operationsMap = null; // Clear out the temp lists.
-			operationsRealList = null;
-			newoperations = null;
-			propertiesMap = null; // Get rid of accumulated map.
-			featuresRealList = null; // Release the real list.
-		}
-	}
-
-	private void doIDs() {
-		// Do properties.
-		if (getJavaClass().eIsSet(EcorePackage.eINSTANCE.getEClass_EStructuralFeatures())) {
-			List features = getFeaturesList();
-			int len = features.size();
-			for (int i = 0; i < len; i++) {
-				EStructuralFeature f = (EStructuralFeature) features.get(i);
-				PropertyDecorator pd = Utilities.getPropertyDecorator(f);
-				if (pd == null || !pd.isMergeIntrospection())
-					continue; // Not a property for us to give an ID to.
-				setPropertyID(f.getName(), f);
-			}
-		}
-		
-		// Do events.
-		if (getJavaClass().eIsSet(JavaRefPackage.eINSTANCE.getJavaClass_Events())) {
-			List events = getEventsList();
-			int len = events.size();
-			for (int i = 0; i < len; i++) {
-				BeanEvent e = (BeanEvent) events.get(i);
-				EventSetDecorator ed = Utilities.getEventSetDecorator(e);
-				if (ed == null || !ed.isMergeIntrospection())
-					continue; // Not an event for us to give an ID to.
-				setEventID(e.getName(), e);
-			}
-		}
-
-		// Do Operations.
-		if (getJavaClass().eIsSet(EcorePackage.eINSTANCE.getEClass_EOperations())) {
-			List ops = getOperationsList();
-			int len = ops.size();
-			for (int i = 0; i < len; i++) {
-				EOperation o = (EOperation) ops.get(i);
-				MethodDecorator md = Utilities.getMethodDecorator(o);
-				if (md == null || !md.isMergeIntrospection())
-					continue; // Not an event for us to give an ID to.
-				setMethodID(o.getName(), o);
-			}
-		}
-	}
-
-	private static final String ROOT_OVERRIDE = BeaninfoPlugin.ROOT+'.'+BeaninfoPlugin.OVERRIDE_EXTENSION;	 //$NON-NLS-1$
-	
-	protected void applyExtensionDocument(boolean rootOnly) {
-		try {
-			TimerTests.basicTest.startCumulativeStep(APPLY_EXTENSIONS);
-			boolean canUseCache = !rootOnly && canUseOverrideCache();
-			boolean alreadyRetrievedRoot = retrievedExtensionDocument == RETRIEVED_ROOT_ONLY;
-			retrievedExtensionDocument = rootOnly ? RETRIEVED_ROOT_ONLY : RETRIEVED_FULL_DOCUMENT;
-			JavaClass jc = getJavaClass();
-			Resource mergeIntoResource = jc.eResource();
-			ResourceSet rset = mergeIntoResource.getResourceSet();
-			String className = jc.getName();
-			if (canUseCache) {
-				// We can use the cache, see if we actually have one.
-				if (getClassEntry().overrideCacheExists()) {
-					// Get the cache and apply it before anything else.
-					Resource cacheRes = BeanInfoCacheController.INSTANCE.getCache(jc, getClassEntry(), false);
-					if (cacheRes != null) {
-						try {
-							new ExtensionDocApplies(null, rset, jc, null).run(cacheRes);
-						} catch (WrappedException e) {
-							BeaninfoPlugin.getPlugin().getLogger().log(
-									new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0,
-											"Error processing file\"" + cacheRes.getURI() + "\"", e.exception())); //$NON-NLS-1$ //$NON-NLS-2$						
-						} finally {
-							cacheRes.getResourceSet().getResources().remove(cacheRes); // We don't need it around once we do the merge. Normal merge would of gotton rid of it, but in case of error we do it here.
-						}
-					} else
-						canUseCache = false; // Need to rebuild the cache.
-				}
-			}
-			List overrideCache = null;
-			if (!alreadyRetrievedRoot && (rootOnly || jc.getSupertype() == null)) {
-				// It is a root class. Need to merge in root stuff.
-				if (!canUseCache) {
-					overrideCache = createOverrideCache(overrideCache, getAdapterFactory().getProject(), BeaninfoPlugin.ROOT, ROOT_OVERRIDE, rset, jc);
-				}
-				applyExtensionDocTo(rset, jc, ROOT_OVERRIDE, BeaninfoPlugin.ROOT, BeaninfoPlugin.ROOT);
-				if (rootOnly)
-					return;
-			}
-
-			String baseOverridefile = className + '.' + BeaninfoPlugin.OVERRIDE_EXTENSION; // getName() returns inner classes with "$" notation, which is good. //$NON-NLS-1$
-			String packageName = jc.getJavaPackage().getPackageName();
-			if (!canUseCache) {
-				overrideCache = createOverrideCache(overrideCache, getAdapterFactory().getProject(), packageName, baseOverridefile, rset, jc);
-			}
-			applyExtensionDocTo(rset, jc, baseOverridefile, packageName, className);
-			
-			if (!canUseCache) {
-				// We have an override cache to store. If the cache is null, this will flag that there is no override cache for the current configuration. That way we won't bother trying again until config changes.
-				BeanInfoCacheController.INSTANCE.newCache(jc, overrideCache, BeanInfoCacheController.OVERRIDES_CACHE);
-			}
-			
-		} finally {
-			TimerTests.basicTest.stopCumulativeStep(APPLY_EXTENSIONS);	
-		}
-	}
-	
-	/*
-	 * Build up the fixed overrides into the cache, and apply as we gather them.
-	 * Return the cache or null if the cache is empty at the end.
-	 */
-	private List createOverrideCache(List cache, IProject project, String packageName, String overrideFile, ResourceSet rset, JavaClass mergeIntoJavaClass) {
-		// Now get the overrides paths
-		String[] paths = BeaninfoPlugin.getPlugin().getOverridePaths(project, packageName);
-		if (paths.length == 0)
-			return cache;
-		
-		// Now apply the overrides.
-		if (cache == null)
-			cache = new ArrayList();
-		BeaninfoPlugin.IOverrideRunnable runnable = new ExtensionDocApplies(overrideFile, rset, mergeIntoJavaClass, cache);
-		for (int i = 0; i < paths.length; i++) {
-			runnable.run(paths[i]);
-		}
-		return !cache.isEmpty() ? cache : null;
-	}
-	
-	private static final URI ROOT_URI = URI.createGenericURI(BeaninfoPlugin.ROOT_SCHEMA, BeaninfoPlugin.ROOT_OPAQUE, null);
-	private static final String ROOT_FRAGMENT = "//@root";
-	private static final Pattern FRAGMENT_SPLITTER = Pattern.compile("/");
-	
-	private class ExtensionDocApplies implements BeaninfoPlugin.IOverrideRunnable {
-		
-		private final String overrideFile;
-		private final ResourceSet rset;
-		private final JavaClass mergeIntoJavaClass;
-		private final List overridesCache;
-
-		public ExtensionDocApplies(String overrideFile, ResourceSet rset, JavaClass mergeIntoJavaClass, List overridesCache) {
-			this.overrideFile = overrideFile;
-			this.rset = rset;
-			this.mergeIntoJavaClass = mergeIntoJavaClass;
-			this.overridesCache = overridesCache;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin.IOverrideRunnable#run(java.lang.String)
-		 */
-		public void run(String overridePath) {
-			Resource overrideRes = null;
-			URI uri = URI.createURI(overridePath+overrideFile);
-			try {
-				overrideRes = rset.getResource(uri, true);
-				run(overrideRes);
-			} catch (WrappedException e) {
-				// FileNotFoundException is ok
-				if (!(e.exception() instanceof FileNotFoundException)) {
-					if (e.exception() instanceof CoreException
-						&& ((CoreException) e.exception()).getStatus().getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
-						// This is ok. Means uri_mapping not set so couldn't find in Workspace, also ok.
-					} else {
-						BeaninfoPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0, "Error loading file\"" + uri + "\"", e.exception())); //$NON-NLS-1$ //$NON-NLS-2$						
-					}
-				}
-				// In case it happened after creating resource but during load. Need to get rid of it in the finally.	
-				overrideRes = rset.getResource(uri, false);				
-			} catch (Exception e) {
-				// Couldn't load it for some reason.
-				BeaninfoPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0, "Error loading file\"" + uri + "\"", e)); //$NON-NLS-1$ //$NON-NLS-2$
-				overrideRes = rset.getResource(uri, false); // In case it happened after creating resource but during load so that we can get rid of it.
-			} finally {
-				if (overrideRes != null)
-					rset.getResources().remove(overrideRes); // We don't need it around once we do the merge. Normal merge would of gotton rid of it, but in case of error we do it here.
-			}
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin.IOverrideRunnable#run(org.eclipse.emf.ecore.resource.Resource)
-		 */
-		public void run(Resource overrideRes) {
-			try {
-				EList contents = overrideRes.getContents();
-				if (overridesCache != null) {
-					// TODO Until https://bugs.eclipse.org/bugs/show_bug.cgi?id=109169 is fixed, we need our own Copier.
-					EcoreUtil.Copier copier = new EcoreUtil.Copier() {
-
-						private static final long serialVersionUID = 1L;
-
-						protected void copyReference(EReference eReference, EObject eObject, EObject copyEObject) {
-							if (eObject.eIsSet(eReference)) {
-								if (eReference.isMany()) {
-									List source = (List) eObject.eGet(eReference);
-									InternalEList target = (InternalEList) copyEObject.eGet(getTarget(eReference));
-									if (source.isEmpty()) {
-										target.clear();
-									} else {
-										boolean isBidirectional = eReference.getEOpposite() != null;
-										int index = 0;
-										for (Iterator k = ((EcoreEList) source).basicIterator(); k.hasNext();) {
-											Object referencedEObject = k.next();
-											Object copyReferencedEObject = get(referencedEObject);
-											if (copyReferencedEObject == null) {
-												if (!isBidirectional) {
-													target.addUnique(index, referencedEObject);
-													++index;
-												}
-											} else {
-												if (isBidirectional) {
-													int position = target.indexOf(copyReferencedEObject);
-													if (position == -1) {
-														target.addUnique(index, copyReferencedEObject);
-													} else if (index != position) {
-														target.move(index, copyReferencedEObject);
-													}
-												} else {
-													target.addUnique(index, copyReferencedEObject);
-												}
-												++index;
-											}
-										}
-									}
-								} else {
-									Object referencedEObject = eObject.eGet(eReference, false);
-									if (referencedEObject == null) {
-										copyEObject.eSet(getTarget(eReference), null);
-									} else {
-										Object copyReferencedEObject = get(referencedEObject);
-										if (copyReferencedEObject == null) {
-											if (eReference.getEOpposite() == null) {
-												copyEObject.eSet(getTarget(eReference), referencedEObject);
-											}
-										} else {
-											copyEObject.eSet(getTarget(eReference), copyReferencedEObject);
-										}
-									}
-								}
-							}
-						}
-					};
-					
-					// We fixup the CD first so that when serialized it will be to the correct object already. Simplifies apply later.
-					Iterator itr = contents.iterator();
-					while (itr.hasNext()) {
-						Object o = itr.next();
-						if (o instanceof ChangeDescription) {
-							fixupCD((ChangeDescription) o);
-						}
-					}
-
-				    Collection result = copier.copyAll(contents);
-				    copier.copyReferences();
-					overridesCache.addAll(result);	// Make a copy for the override cache to be used next time needed.
-				}
-				
-				if (!contents.isEmpty()) {
-					// TODO It could be either the old event model or the new ChangeDescription. When we remove Event Model we need to remove
-					// the test. This could be the override cache too, so we must apply the contents in the order they are in the resource.
-					try {
-						List events = new ArrayList(1);
-						events.add(null);	// EventUtil needs a list, but we will be calling one by one. So just reuse this list.
-						Iterator itr = contents.iterator();
-						while (itr.hasNext()) {
-							Object o = itr.next();
-							if (o instanceof ChangeDescription) {
-								ChangeDescription cd = (ChangeDescription) o;
-								fixupCD(cd);
-								cd.apply();
-							} else {
-								// It is the old format.
-								events.set(0, o);
-								EventUtil util = EventFactory.eINSTANCE.createEventUtil(mergeIntoJavaClass, rset);
-								util.doForwardEvents(events);
-							}
-						}
-					} finally {
-						uninstallRootResource();
-					}						
-				}
-			} catch (WrappedException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0, "Error processing file\"" + overrideRes.getURI() + "\"", e.exception())); //$NON-NLS-1$ //$NON-NLS-2$						
-			}
-		}
-		
-		/*
-		 * fix it up so that references to "X:ROOT#//@root" are replaced with reference to the javaclass.
-		 */
-		private void fixupCD(ChangeDescription cd) {
-			EStructuralFeature keyFeature = ChangePackage.eINSTANCE.getEObjectToChangesMapEntry_Key();
-			Iterator changes = cd.getObjectChanges().iterator();
-			while (changes.hasNext()) {
-				EObject entry = (EObject) changes.next();
-				EObject key = (EObject) entry.eGet(keyFeature, false);
-				if (key != null && key.eIsProxy()) {
-					// See if it is our special.
-					URI uri = ((InternalEObject) key).eProxyURI();
-					String rootFrag = uri.fragment();
-					if (BeaninfoPlugin.ROOT_SCHEMA.equals(uri.scheme()) && BeaninfoPlugin.ROOT_OPAQUE.equals(uri.opaquePart()) && (rootFrag != null && rootFrag.startsWith(ROOT_FRAGMENT))) {
-						// It is one of ours. Get the fragment, remove the leading //root and append to the end of the
-						// uri from the java class itself.
-						if (rootFrag.length() <= ROOT_FRAGMENT.length())
-							entry.eSet(keyFeature, mergeIntoJavaClass);	// No sub-path, so just the java class.
-						else {
-							// There is a sub-path below the java class that is needed. Need to walk down the path.
-							String[] path = FRAGMENT_SPLITTER.split(rootFrag.substring(ROOT_FRAGMENT.length()+1));
-							InternalEObject newKey = (InternalEObject) mergeIntoJavaClass;
-							for (int i = 0; newKey != null && i < path.length; i++) {
-								newKey = (InternalEObject) newKey.eObjectForURIFragmentSegment(path[i]);
-							}
-							if (newKey != null)
-								entry.eSet(keyFeature, newKey);
-						}
-					}
-				}
-			}
-		}
-		
-		/*
-		 * Uninstall the fake root resource. This must be called after installRootResource has been called. So must use try/finally. 
-		 * 
-		 * 
-		 * @since 1.2.0
-		 */
-		private void uninstallRootResource() {
-			Resource root = rset.getResource(ROOT_URI, false);
-			if (root != null)
-				rset.getResources().remove(root);
-		}
-	}
-	protected void applyExtensionDocTo(ResourceSet rset, JavaClass mergeIntoJavaClass, String overrideFile, String packageName, String className) {
-		BeaninfoPlugin.getPlugin().applyOverrides(getAdapterFactory().getProject(), packageName, className, mergeIntoJavaClass, rset, 
-			new ExtensionDocApplies(overrideFile, rset, mergeIntoJavaClass, null));
-	}
-
-	/**
-	 * Return the target as a JavaClass 
-	 */
-	protected JavaClassImpl getJavaClass() {
-		return (JavaClassImpl) getTarget();
-	}
-
-	/**
-	 * Answer the beaninfo constants record
-	 */
-	protected BeaninfoProxyConstants getProxyConstants() {
-		return BeaninfoProxyConstants.getConstants(getRegistry());
-	}
-
-	/**
-	 * @see org.eclipse.jem.java.beaninfo.IIntrospectionAdapter#getEStructuralFeatures()
-	 */
-	public EList getEStructuralFeatures() {
-		introspectIfNecessary();
-		return getJavaClass().getEStructuralFeaturesInternal();
-	}
-	
-	/**
-	 * @see org.eclipse.jem.java.beaninfo.IIntrospectionAdapter#getAllProperties()
-	 */
-	public EList getAllProperties() {
-		return allProperties();
-	}	
-	
-	/**
-	 * @see org.eclipse.jem.java.beaninfo.IIntrospectionAdapter#getEOperations()
-	 */
-	public EList getEOperations() {
-		if (getClassEntry() != null && getClassEntry().isOperationsStored())
-			introspectIfNecessary();	// Already stored, just do if necessary.
-		else {
-			synchronized (this) {
-				needsIntrospection = true;	// Force reintrospection because we either aren't storing operations, or have never loaded.
-			}
-			introspectIfNecessary(true);	// But force the operations now.
-		}
-		return getJavaClass().getEOperationsInternal();
-	}
-	
-	/**
-	 * @see org.eclipse.jem.java.beaninfo.IIntrospectionAdapter#getEAllOperations()
-	 */
-	public BasicEList getEAllOperations() {
-		return allOperations();
-	}
-	
-	/**
-	 * @see org.eclipse.jem.java.beaninfo.IIntrospectionAdapter#getEvents()
-	 */
-	public EList getEvents() {
-		introspectIfNecessary();
-		return getJavaClass().getEventsGen();
-	}
-	
-	/**
-	 * @see org.eclipse.jem.java.beaninfo.IIntrospectionAdapter#getAllEvents()
-	 */
-	public EList getAllEvents() {
-		return allEvents();
-	}					
-
-	private void finalizeProperties(ChangeDescription cd) {
-		// Now go through the list and remove those that should be removed, and set the etype for those that don't have it set.
-		Map oldLocals = getPropertiesMap();
-		Iterator itr = getFeaturesList().iterator();
-		while (itr.hasNext()) {
-			EStructuralFeature a = (EStructuralFeature) itr.next();
-			PropertyDecorator p = Utilities.getPropertyDecorator(a);
-			Object aOld = oldLocals.get(a.getName());
-			if (aOld != null && aOld != Boolean.FALSE) {
-				// A candidate for removal. It was in the old list and it was not processed.
-				if (p != null) {
-					ImplicitItem implicit = p.getImplicitDecoratorFlag();
-					if (implicit != ImplicitItem.NOT_IMPLICIT_LITERAL) {
-						p.setEModelElement(null); // Remove from the feature;
-						((InternalEObject) p).eSetProxyURI(BAD_URI);
-						// Mark it as bad proxy so we know it is no longer any use.
-						p = null;
-						if (implicit == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-							itr.remove(); // Remove it, this was implicitly created and not processed this time.
-							((InternalEObject) a).eSetProxyURI(BAD_URI);	// Mark it as bad proxy so we know it is no longer any use.
-							continue;
-						}
-						// Need to go on because we need to check the eType to make sure it is set. At this point we have no decorator but we still have a feature.
-					}
-				}
-			}
-			
-			// [79083] Also check for eType not set, and if it is, set it to EObject type. That way it will be valid, but not valid as 
-			// a bean setting.
-			if (a.getEType() == null) {
-				// Set it to EObject type. If it becomes valid later (through the class being changed), then the introspect/reflect
-				// will set it to the correct type.
-				a.setEType(EcorePackage.eINSTANCE.getEObject());
-				Logger logger = BeaninfoPlugin.getPlugin().getLogger();
-				if (logger.isLoggingLevel(Level.WARNING))
-					logger.logWarning("Feature \""+getJavaClass().getQualifiedName()+"->"+a.getName()+"\" did not have a type set. Typically due to override file creating feature but property not found on introspection/reflection."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-			}
-			
-			if (p != null && cd != null) {
-				// Now create the appropriate cache entry for this property.
-				BeanInfoDecoratorUtility.buildChange(cd, p);
-			}
-		}
-	}
-
-	/**
-	 * merge all  the Properties (i.e. supertypes) (properties)
-	 */
-	protected EList allProperties() {
-		
-		EList jcAllProperties = getJavaClass().getAllPropertiesGen();
-		BeaninfoSuperAdapter superAdapter =
-			(BeaninfoSuperAdapter) EcoreUtil.getRegisteredAdapter(getJavaClass(), BeaninfoSuperAdapter.class);
-		if (jcAllProperties != null) {
-			// See if new one required.
-			if (superAdapter == null || !superAdapter.isAllPropertiesCollectionModified())
-				return jcAllProperties;
-			// Can't get superadapter, so must not be attached to a resource, so return current list. Or no change required.       		
-		}
-		
-		UniqueEList.FastCompare allProperties = new UniqueEList.FastCompare() {
-			/**
-			 * Comment for <code>serialVersionUID</code>
-			 * 
-			 * @since 1.1.0
-			 */
-			private static final long serialVersionUID = 1L;
-
-			protected Object[] newData(int capacity) {
-				return new EStructuralFeature[capacity];
-			}
-		};
-		boolean doAllProperties = false;
-		synchronized(this) {
-			// If we are introspecting, don't do all properties because it is an invalid list. Just return empty without reseting the all modified flag.
-			doAllProperties = !isDoingAllProperties && !isIntrospecting && isResourceConnected();
-			if (doAllProperties)
-				isDoingAllProperties = true;
-		}
-		if (doAllProperties) {
-			try {
-				EList localProperties = getJavaClass().getProperties();
-				// Kludge: BeanInfo spec doesn't address Interfaces, but some people want to use them.
-				// Interfaces can have multiple extends, while the Introspector ignores these for reflection,
-				// the truth is most people want these. So we will add them in. But since there could be more than one it
-				// gets confusing. We need to look for dups from the super types and still keep order.
-				//
-				// Supertypes will never be more than one entry for classes, it is possible to be 0, 1, 2 or more for interfaces.
-				List superTypes = getJavaClass().getESuperTypes();
-				if (!superTypes.isEmpty()) {
-					// Now we need to merge in the supers.
-					BeanDecorator bd = Utilities.getBeanDecorator(getJavaClass());
-					// If there is only one supertype, we can add to the actual events, else we will use the linked hashset so that
-					// we don't add possible duplicates (e.g. IA extends IB,IC and IB extends IC. In this case there would be dups
-					// because IB would contribute IC's too).
-					Collection workingAllProperties = superTypes.size() == 1 ? (Collection) allProperties : new LinkedHashSet(); 
-					// We will now merge as directed.
-					boolean mergeAll = bd == null || bd.isMergeSuperProperties();
-					if (!mergeAll) {
-						// we don't to want to merge super properties, but we still need super non-properties or explict ones.
-						int lenST = superTypes.size();
-						for (int i=0; i<lenST; i++) {
-							List supers = ((JavaClass) superTypes.get(i)).getAllProperties();
-							int len = supers.size();
-							for (int i1 = 0; i1 < len; i1++) {
-								EStructuralFeature p = (EStructuralFeature) supers.get(i1);
-								PropertyDecorator pd = Utilities.getPropertyDecorator(p);
-								if ( pd == null || (pd.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL && !pd.isMergeIntrospection()))
-									workingAllProperties.add(p);
-							}
-						}
-					} else {
-						// We want to merge all.					
-						// BeanInfo could of given us the not merge list. If the list is empty, then we accept all.
-						if (bd != null && bd.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames())) {
-							// We were given a list of names.
-							// Get the names into a set to create a quick lookup.
-							HashSet superSet = new HashSet(bd.getNotInheritedPropertyNames());
-							
-							// Now walk and add in non-bean properties (and bean properties that were explicitly added and not mergeable (i.e. didn't come thru beaninfo)) 
-							// and add those not specifically called out by BeanInfo in the not inherited list.
-							int lenST = superTypes.size();
-							for (int i=0; i<lenST; i++) {
-								List supers = ((JavaClass) superTypes.get(i)).getAllProperties();
-								int len = supers.size();
-								for (int i1 = 0; i1 < len; i1++) {
-									EStructuralFeature p = (EStructuralFeature) supers.get(i1);
-									PropertyDecorator pd = Utilities.getPropertyDecorator(p);
-									if (pd == null || (pd.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL && !pd.isMergeIntrospection()) || !superSet.contains(pd.getName()))
-										workingAllProperties.add(p);
-								}
-							}
-						} else {
-							// BeanInfo (or reflection always does this) called out that all super properties are good
-							int lenST = superTypes.size();
-							for (int i=0; i<lenST; i++) {
-								workingAllProperties.addAll(((JavaClass) superTypes.get(i)).getAllProperties());
-							}
-						}
-					}
-					if (workingAllProperties != allProperties)
-						allProperties.addAll(workingAllProperties);	// Now copy over the ordered super properties.
-				}
-				allProperties.addAll(localProperties);				
-				superAdapter.setAllPropertiesCollectionModified(false); // Now built, so reset to not changed.
-			} finally {
-				synchronized(this) {
-					isDoingAllProperties = false;
-				}
-			}
-		}
-
-		if (!allProperties.isEmpty()) {
-			allProperties.shrink();
-			return new EcoreEList.UnmodifiableEList.FastCompare(
-				getJavaClass(),
-				null,
-				allProperties.size(),
-				allProperties.data());
-		} else
-			return ECollections.EMPTY_ELIST;
-	}
-
-	/*
-	 * Fill in the property using the prop record. If this one that should have merging done, then
-	 * return the PropertyDecorator so that it can have the PropertyRecord merged into it. Else
-	 * return null if no merging.
-	 */
-	protected PropertyDecorator calculateProperty(PropertyRecord pr, boolean indexed) {
-		// If this is an indexed property, then a few fields will not be set in here, but
-		// will instead be set by the calculateIndexedProperty, which will be called.
-		JavaHelpers type = pr.propertyTypeName != null ? Utilities.getJavaType(MapJNITypes.getFormalTypeName(pr.propertyTypeName), getJavaClass().eResource().getResourceSet()) : null;
-
-		if (indexed) {
-			// If no array write method found, then see if there is an indexed write method. If there is, then it is changable.
-			if (type == null) {
-				// If no array type from above, create one from the indexed type proxy. Add '[]' to turn it into an array.
-				type = Utilities.getJavaType(MapJNITypes.getFormalTypeName(((IndexedPropertyRecord) pr).indexedPropertyTypeName)+"[]", getJavaClass().eResource().getResourceSet()); //$NON-NLS-1$
-			}
-		}
-
-		if (type != null)
-			return createProperty(pr.name, indexed, type); // A valid property descriptor.
-		else
-			return null;
-	}
-
-	/**
-	 * Fill in the property and its decorator using the passed in information.
-	 */
-	protected PropertyDecorator createProperty(String name, boolean indexed, EClassifier type) {
-		// First find if there is already a property of this name, and if there is, is the PropertyDecorator
-		// marked to not allow merging in of introspection results.		
-		HashMap existingLocals = getPropertiesMap();
-		EStructuralFeature prop = null;
-		PropertyDecorator pd = null;
-		Object p = existingLocals.get(name);
-		if (Boolean.FALSE == p)
-			return null; // We've already processed this name, can't process it again.
-		if (p != null) {
-			// We've found one of the same name. Whether we modify it or use it as is, we put in a
-			// special dummy in its place. That marks that we've already processed it and accepted it.
-			existingLocals.put(name, Boolean.FALSE);
-
-			// If the decorator for this entry says not to merge then return.
-			// If there is no PropertyDecorator, then we will merge. If they
-			// didn't want to merge then should of created of property decorator and said no merge.
-			pd = Utilities.getPropertyDecorator((EStructuralFeature) p);
-			if (pd != null && !pd.isMergeIntrospection())
-				return null;
-			prop = (EStructuralFeature) p;
-		}
-
-		// Need to test if this is an implicit decorator and it is not of the 
-		// same type (i.e. is indexed now but wasn't or visa-versa, then we need
-		// to get rid of the decorator and recreate it. If it is not implicit, then
-		// we have to use it as is because the user specified, so it won't become
-		// an indexed if the user did not created it as an index, and visa-versa.
-		// Also if it is implicit, then we need to unset certain features that may of
-		// been set by a previous reflection which has now become introspected.
-		// When reflected we set the actual fields instead of the letting proxy determine them.
-		if (pd != null) {
-			if (pd.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL) {
-				// We can't change the type for explicit.
-				indexed = pd instanceof IndexedPropertyDecorator;
-			} else {
-				if ((indexed && !(pd instanceof IndexedPropertyDecorator)) || (!indexed && pd instanceof IndexedPropertyDecorator)) {
-					// It is implicit and of a different type, so just get rid of it and let it be recreated correctly.
-					prop.getEAnnotations().remove(pd);
-					pd = null;
-				}
-			}
-			if (pd != null)
-				if (indexed)
-					BeanInfoDecoratorUtility.clear((IndexedPropertyDecorator) pd);
-				else
-					BeanInfoDecoratorUtility.clear(pd);
-		}
-
-		ImplicitItem implicit = pd == null ? ImplicitItem.IMPLICIT_DECORATOR_LITERAL : pd.getImplicitDecoratorFlag();
-		if (prop == null) {
-			// We will create a new property.
-			// We can't have an implicit feature, but an explicit decorator.
-			getFeaturesList().add(prop = EcoreFactory.eINSTANCE.createEReference());
-			implicit = ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL;
-		}
-
-		setPropertyID(name, prop);
-		prop.setName(name);
-		prop.setTransient(false);
-		prop.setVolatile(false);
-
-		// Containment and Unsettable is tricky for EReferences. There is no way to know whether it has been explicitly set to false, or it defaulted to
-		// false because ECore has not made containment/unsettable an unsettable feature. So we need to instead use the algorithm of if we here 
-		// created the feature, then we will by default set it to containment/unsettable. If it was created through diff merge, then
-		// we will leave it alone. It is the responsibility of the merge file writer to set containment/unsettable correctly.
-		if (implicit == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-			prop.setUnsettable(true);
-		}
-		prop.setEType(type);
-		if (!indexed) {
-			prop.setLowerBound(0);
-			prop.setUpperBound(1);
-		} else {
-			prop.setLowerBound(0);
-			prop.setUpperBound(-1);
-			prop.setUnique(true);
-		}
-
-		// Now create/fill in the property descriptor for it.
-		// If there already is one then we
-		// will use it. This allows merging with beanfinfo.		
-		if (pd == null) {
-			pd =
-				(!indexed)
-					? BeaninfoFactory.eINSTANCE.createPropertyDecorator()
-					: BeaninfoFactory.eINSTANCE.createIndexedPropertyDecorator();
-			pd.setImplicitDecoratorFlag(implicit);
-			prop.getEAnnotations().add(pd);
-		}
-		return pd;
-	}
-
-	/**
-	 * @param name
-	 * @param prop
-	 * 
-	 * @since 1.1.0
-	 */
-	private void setPropertyID(String name, EStructuralFeature prop) {
-		// Now fill it in. Normal id for an attribute is "classname.attributename" but we can't use that
-		// for us because that format is used by Java Core for a field and there would be confusion.
-		// So we will use '/' instead.
-		((XMIResource) prop.eResource()).setID(prop, getJavaClass().getName() + BeaninfoJavaReflectionKeyExtension.FEATURE + name);
-	}
-
-	/*
-	 * Reflect the properties. This requires going through local methods and matching them up to
-	 * see if they are properties.
-	 */
-	private void reflectProperties() {
-		// If we are set to mergeSuperTypeProperties, then we need to get the super properties.
-		// This is so that duplicate any from super that we find here. When reflecting we don't
-		// allow discovered duplicates unless they are different types.
-		//
-		// Kludge: BeanInfo spec doesn't address Interfaces, but some people want to use them.
-		// Interfaces can have multiple extends, while the Introspector ignores these for reflection,
-		// the truth is most people want these. So we will add them in. But since there could be more than one it
-		// gets confusing. We need to look for dups from the super types.
-		//
-		// Supertypes will never be more than one entry for classes, it is possible to be 0, 1, 2 or more for interfaces.
-		TimerTests.basicTest.startCumulativeStep(REFLECT_PROPERTIES);		
-		Set supers = new HashSet(50);
-		BeanDecorator bd = Utilities.getBeanDecorator(getJavaClass());
-		if (bd == null || bd.isMergeSuperProperties()) {
-			List superTypes = getJavaClass().getESuperTypes();
-			if (!superTypes.isEmpty()) {
-				int lenST = superTypes.size();
-				for (int i=0; i<lenST; i++) {
-					List superAll = ((JavaClass) superTypes.get(i)).getAllProperties();
-					int len = superAll.size();
-					for (int i1=0; i1<len; i1++) {
-						EStructuralFeature sf = (EStructuralFeature) superAll.get(i1);
-						supers.add(sf.getName());
-					}
-				}
-			}
-		}
-
-		// If any of the classes in the hierarchy are bound, then all reflected properties are considered bound.
-		boolean isBound = isDefaultBound();
-		if (!isBound) {
-			List superTypes = getJavaClass().getEAllSuperTypes();
-			// Start from end because that will be first class above the this one.
-			for (int i=superTypes.size()-1; !isBound && i>=0; i--) {
-				JavaClass spr = (JavaClass) superTypes.get(i);
-				BeaninfoClassAdapter bi = (BeaninfoClassAdapter) EcoreUtil.getExistingAdapter(spr, IIntrospectionAdapter.ADAPTER_KEY);
-				// They should all be reflected, but be on safe side, check if null.
-				if (bi != null)
-					isBound = bi.isDefaultBound();
-			}
-		}
-
-		HashMap props = new HashMap();
-
-		Iterator itr = getJavaClass().getPublicMethods().iterator();
-		while (itr.hasNext()) {
-			Method mthd = (Method) itr.next();
-			if (mthd.isStatic() || mthd.isConstructor())
-				continue; // Statics/constructors don't participate as properties
-			if (mthd.getName().startsWith("get")) { //$NON-NLS-1$
-				String name = java.beans.Introspector.decapitalize(mthd.getName().substring(3));
-				if (name.length() == 0 || supers.contains(name))
-					continue;	// Had get(...) and not getXXX(...) so not a getter. Or this is the same name as a super, either way ignore it.
-				PropertyInfo propInfo = (PropertyInfo) props.get(name);
-				if (propInfo == null) {
-					propInfo = new PropertyInfo();
-					if (propInfo.setGetter(mthd, false))
-						props.put(name, propInfo);
-				} else
-					propInfo.setGetter(mthd, false);
-			} else if (mthd.getName().startsWith("is")) { //$NON-NLS-1$
-				String name = java.beans.Introspector.decapitalize(mthd.getName().substring(2));
-				if (name.length() == 0 || supers.contains(name))
-					continue;	// Had is(...) and not isXXX(...) so not a getter. Or this is the same name as a super, either way ignore it.
-				PropertyInfo propInfo = (PropertyInfo) props.get(name);
-				if (propInfo == null) {
-					propInfo = new PropertyInfo();
-					if (propInfo.setGetter(mthd, true))
-						props.put(name, propInfo);
-				} else
-					propInfo.setGetter(mthd, true);
-			} else if (mthd.getName().startsWith("set")) { //$NON-NLS-1$
-				String name = java.beans.Introspector.decapitalize(mthd.getName().substring(3));
-				if (name.length() == 0 || supers.contains(name))
-					continue;	// Had set(...) and not setXXX(...) so not a setter. Or this is the same name as a super, either way ignore it.				
-				PropertyInfo propInfo = (PropertyInfo) props.get(name);
-				if (propInfo == null) {
-					propInfo = new PropertyInfo();
-					if (propInfo.setSetter(mthd))
-						props.put(name, propInfo);
-				} else
-					propInfo.setSetter(mthd);
-			}
-		}
-
-		// Now go through the hash map and create the properties.
-		itr = props.entrySet().iterator();
-		while (itr.hasNext()) {
-			Map.Entry entry = (Map.Entry) itr.next();
-			((PropertyInfo) entry.getValue()).createProperty((String) entry.getKey(), isBound);
-		}
-		TimerTests.basicTest.stopCumulativeStep(REFLECT_PROPERTIES);		
-	}
-
-	private class PropertyInfo {
-		
-		public EClassifier type, indexedType;
-		public boolean constrained;
-		public Method getter, setter, indexedGetter, indexedSetter;
-
-		public boolean setGetter(Method get, boolean mustBeBoolean) {
-			List parms = get.getParameters();
-			if (parms.size() > 1)
-				return false; // Invalid - improper number of parms.
-			boolean indexed = parms.size() == 1;
-			if (indexed && !((JavaParameter) parms.get(0)).getEType().getName().equals("int")) //$NON-NLS-1$
-				return false; // Invalid - a parm that is not an int is invalid for indexed.
-			EClassifier retType = get.getReturnType();
-			if (retType == null || retType.getName().equals("void")) //$NON-NLS-1$
-				return false; // Invalid - must have a return type
-			if (mustBeBoolean && !retType.getName().equals("boolean")) //$NON-NLS-1$
-				return false; // Invalid - it must be a boolean.
-			if (indexed) {
-				if (indexedType != null) {
-					if (indexedType != retType)
-						return false; // Invalid - type is different from previous info.
-				}
-				if (type != null && !(((JavaHelpers) type).isArray() && ((ArrayType) type).getComponentType() == retType))
-					return false; // Invalid - indexed type doesn't match component type of base type.
-			} else {
-				if (type != null) {
-					if (type != retType)
-						return false; // Invalid - type is different from previous info.
-				}
-				if (indexedType != null && !(((JavaHelpers) retType).isArray() && ((ArrayType) retType).getComponentType() == indexedType))
-					if (type == null) {
-						// We had a potential indexed and had not yet found the regular type. We've now found
-						// the regular type, and it is not indexed. So it takes priority and will wipe out
-						// the indexed type.
-						indexedGetter = null;
-						indexedSetter = null;
-						indexedType = null;
-					} else
-						return false; // Invalid - indexed type doesn't match component type of base type we already have
-			}
-
-			if (indexed) {
-				if (indexedGetter != null)
-					return false; // Already have an indexed getter.
-				indexedGetter = get;
-				indexedType = retType;
-			} else {
-				if (getter != null)
-					return false; // Already have a getter
-				getter = get;
-				type = retType;
-			}
-			return true;
-		}
-
-		public boolean setSetter(Method set) {
-			List parms = set.getParameters();
-			if (parms.size() > 2 || parms.size() < 1)
-				return false; // Invalid - improper number of parms.
-			boolean indexed = parms.size() == 2;
-			if (indexed && !((JavaParameter) parms.get(0)).getEType().getName().equals("int")) //$NON-NLS-1$
-				return false; // Invalid - a parm that is not an int is invalid for indexed.
-			EClassifier retType = set.getReturnType();
-			if (retType != null && !retType.getName().equals("void")) //$NON-NLS-1$
-				return false; // Invalid - must not have a return type
-			EClassifier propType = null;
-			if (indexed) {
-				propType = ((JavaParameter) parms.get(1)).getEType();
-				if (indexedType != null) {
-					if (indexedType != propType)
-						return false; // Invalid - type is different from previous info.
-				}
-				if (type != null && !(((JavaHelpers) type).isArray() && ((ArrayType) type).getComponentType() == propType))
-					return false; // Invalid - indexed type doesn't match component type of base type, or base type not an array
-			} else {
-				propType = ((JavaParameter) parms.get(0)).getEType();
-				if (type != null) {
-					if (type != propType)
-						return false; // Invalid - type is different from previous info.
-				}
-				if (indexedType != null
-					&& !(((JavaHelpers) propType).isArray() && ((ArrayType) propType).getComponentType() == indexedType))
-					if (type == null) {
-						// We had a potential indexed and had not yet found the regular type. We've now found
-						// the regular type, and it is not indexed of the correct type. So it takes priority and will wipe out
-						// the indexed type.
-						indexedGetter = null;
-						indexedSetter = null;
-						indexedType = null;
-					} else
-						return false; // Invalid - indexed type doesn't match component type of base type from this setter.
-			}
-
-			if (indexed) {
-				if (indexedSetter != null)
-					return false; // Already have an indexed getter.
-				indexedSetter = set;
-				indexedType = propType;
-			} else {
-				if (setter != null)
-					return false; // Already have a getter
-				setter = set;
-				type = propType;
-			}
-
-			if (set.getJavaExceptions().contains(Utilities.getJavaClass("java.beans.PropertyVetoException", getJavaClass().eResource().getResourceSet()))) //$NON-NLS-1$
-				constrained = true;
-			return true;
-		}
-
-		public void createProperty(String name, boolean isBound) {
-			boolean indexed = indexedType != null;
-			if (indexed && type == null)
-				return; // A potential indexed, but never found the getter/setter of the regular type.
-
-			PropertyDecorator prop =
-				BeaninfoClassAdapter.this.createProperty(
-					name,
-					indexed,
-					type);
-			if (prop == null)
-				return; // Reflection not wanted.
-
-			indexed = prop instanceof IndexedPropertyDecorator; // It could of been forced back to not indexed if explicitly set.
-
-			// At this point in time all implicit settings have been cleared. This is done back in createProperty() method above.
-			// So now apply reflected settings on the property decorator. 
-			BeanInfoDecoratorUtility.setProperties(prop, isBound, constrained, getter, setter);
-			if (indexed)
-				BeanInfoDecoratorUtility.setProperties((IndexedPropertyDecorator) prop, indexedGetter, indexedSetter);
-
-		}
-	};
-
-	/*
-	 * Should only be called from introspect so that flags are correct.
-	 */
-	private void finalizeOperations(ChangeDescription cd) {
-		// Now go through the list and remove those that should be removed.
-		Iterator itr = getOperationsList().iterator();
-		while (itr.hasNext()) {
-			EOperation a = (EOperation) itr.next();
-			MethodDecorator m = Utilities.getMethodDecorator(a);
-			if (!newoperations.contains(a)) {
-				// A candidate for removal. It is in the list but we didn't add it. Check to see if it one we had created in the past.
-				// If no methoddecorator, then keep it, not one ours.
-				if (m != null) {
-					ImplicitItem implicit = m.getImplicitDecoratorFlag();
-					if (implicit != ImplicitItem.NOT_IMPLICIT_LITERAL) {
-						m.setEModelElement(null); // Remove it because it was implicit.
-						 ((InternalEObject) m).eSetProxyURI(BAD_URI);
-						if (implicit == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-							itr.remove(); // The operation was implicit too.
-							 ((InternalEObject) a).eSetProxyURI(BAD_URI);
-						}
-						continue;	// At this point we no longer have a method decorator, so go to next.
-					}
-				}
-			}
-			
-			if (m != null && cd != null) {
-				// Now create the appropriate cache entry for this method.
-				BeanInfoDecoratorUtility.buildChange(cd, m);
-			}
-		}
-	}
-
-	/**
-	 * Fill in the behavior and its decorator using the mthdDesc.
-	 */
-	protected MethodDecorator calculateOperation(MethodRecord record) {
-		return createOperation(record.name, formLongName(record), null, record);
-	}
-
-	/**
-	 * Fill in the behavior and its decorator using the passed in information.
-	 */
-	protected MethodDecorator createOperation(String name, String longName, Method method, MethodRecord record) {
-		// First find if there is already a behavior of this name and method signature , and if there is, is the MethodDecorator
-		// marked to not allow merging in of introspection results.
-		HashMap existingLocals = getOperationsMap();
-		EOperation oper = null;
-		MethodDecorator md = null;
-		Object b = null;
-		if (name != null)
-			b = existingLocals.get(longName);
-		else
-			b = existingLocals.get(longName);
-			
-		if (b != null) {
-			// If the decorator for this entry says not to merge then return.
-			// If there is no decorator, then we will merge. If they didn't want to
-			// merge, then they should of created a decorator with no merge on it.
-			md = Utilities.getMethodDecorator((EOperation) b);
-			if (md != null && !md.isMergeIntrospection())
-				return null;
-			oper = (EOperation) b;
-		}
-
-		// Need to find the method and method id.
-		if (method == null) {
-			// No method sent, create a proxy to it from the record.
-			method = BeanInfoDecoratorUtility.createJavaMethodProxy(record.methodForDescriptor);
-		}
-
-		ImplicitItem implicit = md == null ? ImplicitItem.IMPLICIT_DECORATOR_LITERAL : ImplicitItem.NOT_IMPLICIT_LITERAL;
-		if (oper == null) {
-			// We will create a new MethodProxy.
-			oper = BeaninfoFactory.eINSTANCE.createMethodProxy();
-			getOperationsList().add(oper);
-			implicit = ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL; 
-		}		
-		if (name == null)
-			name = method.getName();		
-
-		// Now fill it in.
-		if (oper instanceof MethodProxy)
-			 ((MethodProxy) oper).setMethod(method);
-		setMethodID(name, oper);
-		oper.setName(name);
-		newoperations.add(oper);
-
-		// Now create/fill in the method decorator for it.
-		// If there already is one then we
-		// will use it. This allows merging with beaninfo.		
-		if (md == null) {
-			md = BeaninfoFactory.eINSTANCE.createMethodDecorator();
-			md.setImplicitDecoratorFlag(implicit);
-			oper.getEAnnotations().add(md);
-		} else
-			BeanInfoDecoratorUtility.clear(md);
-		return md;
-	}
-
-	/**
-	 * @param name
-	 * @param oper
-	 * 
-	 * @since 1.1.0
-	 */
-	private void setMethodID(String name, EOperation oper) {
-		((XMIResource) oper.eResource()).setID(oper, getJavaClass().getName() + BeaninfoJavaReflectionKeyExtension.BEHAVIOR + name);
-	}
-
-	private void reflectOperations() {
-		// If we are set to mergeSuperTypeBehaviors, then we need to get the super behaviors.
-		// This is so that duplicate any from super that we find here. When reflecting we don't
-		// allow discovered duplicates unless they are different signatures. So all super operations
-		// will be allowed and we will not override them.
-		//
-		// Kludge: BeanInfo spec doesn't address Interfaces, but some people want to use them.
-		// Interfaces can have multiple extends, while the Introspector ignores these for reflection,
-		// the truth is most people want these. So we will add them in. But since there could be more than one it
-		// gets confusing. We need to look for dups from the super types.
-		//
-		// Supertypes will never be more than one entry for classes, it is possible to be 0, 1, 2 or more for interfaces.
-		Set supers = new HashSet(50);
-		BeanDecorator bd = Utilities.getBeanDecorator(getJavaClass());
-		if (bd == null || bd.isMergeSuperMethods()) {
-			List superTypes = getJavaClass().getESuperTypes();
-			if (!superTypes.isEmpty()) {
-				int lenST = superTypes.size();
-				for (int i=0; i<lenST; i++) {
-					List superAll = ((JavaClass) superTypes.get(i)).getEAllOperations();
-					int len = superAll.size();
-					for (int i1=0; i1<len; i1++) {
-						EOperation op = (EOperation) superAll.get(i1);
-						supers.add(formLongName(op));
-					}
-				}
-			}
-		}
-
-		Iterator itr = getJavaClass().getPublicMethods().iterator();
-		while (itr.hasNext()) {
-			Method mthd = (Method) itr.next();
-			if (mthd.isStatic() || mthd.isConstructor())
-				continue; // Statics/constructors don't participate as behaviors	
-			String longName = formLongName(mthd);
-			// Add if super not already contain it.
-			if (!supers.contains(longName))
-				createOperation(null, longName, mthd, null);	// Don't pass a name, try to create it by name, only use ID if there is more than one of the same name.
-		}
-	}
-
-	/*
-	 * merge all  the Behaviors(i.e. supertypes)
-	 */
-	protected BasicEList allOperations() {
-		BasicEList jcAllOperations = (BasicEList) getJavaClass().primGetEAllOperations();
-		BeaninfoSuperAdapter superAdapter =
-			(BeaninfoSuperAdapter) EcoreUtil.getRegisteredAdapter(getJavaClass(), BeaninfoSuperAdapter.class);
-		if (jcAllOperations != null) {
-			// See if new one required.
-			if (superAdapter == null || !superAdapter.isAllOperationsCollectionModified())
-				return jcAllOperations;
-			// Can't get superadapter, so must not be attached to a resource, so return current list. Or no change required.       		
-		}
-
-		UniqueEList.FastCompare allOperations = new UniqueEList.FastCompare() {
-			/**
-			 * Comment for <code>serialVersionUID</code>
-			 * 
-			 * @since 1.1.0
-			 */
-			private static final long serialVersionUID = 1L;
-
-			protected Object[] newData(int capacity) {
-				return new EOperation[capacity];
-			}
-		};
-		boolean doAllOperations = false;
-		synchronized(this) {
-			// If we are introspecting, don't do all operatoins because it is an invalid list. Just return empty without reseting the all modified flag.
-			doAllOperations = !isDoingAllOperations && !isIntrospecting && isResourceConnected();
-			if (doAllOperations)
-				isDoingAllOperations = true;
-		}
-
-		if (doAllOperations) {
-			try {
-				EList localOperations = getJavaClass().getEOperations();
-				// Kludge: BeanInfo spec doesn't address Interfaces, but some people want to use them.
-				// Interfaces can have multiple extends, while the Introspector ignores these for reflection,
-				// the truth is most people want these. So we will add them in. But since there could be more than one it
-				// gets confusing. We need to look for dups from the super types and still keep order.
-				//
-				// Supertypes will never be more than one entry for classes, it is possible to be 0, 1, 2 or more for interfaces.
-				List superTypes = getJavaClass().getESuperTypes();
-				if (!superTypes.isEmpty()) {
-					// Now we need to merge in the supers.
-					BeanDecorator bd = Utilities.getBeanDecorator(getJavaClass());
-					// If there is only one supertype, we can add to the actual events, else we will use the linked hashset so that
-					// we don't add possible duplicates (e.g. IA extends IB,IC and IB extends IC. In this case there would be dups
-					// because IB would contribute IC's too).
-					Collection workingAllOperations = superTypes.size() == 1 ? (Collection) allOperations : new LinkedHashSet(); 
-					// We will now merge as directed.
-					boolean mergeAll = bd == null || bd.isMergeSuperMethods();
-					if (!mergeAll) {
-						// we don't to want to merge super operations, but we still need super non-operations.
-						int lenST = superTypes.size();
-						for (int i=0; i<lenST; i++) {
-							List supers = ((JavaClass) superTypes.get(i)).getEAllOperations();
-							int len = supers.size();
-							for (int i1 = 0; i1 < len; i1++) {
-								EOperation o = (EOperation) supers.get(i1);
-								MethodDecorator md = Utilities.getMethodDecorator(o);
-								if (md == null || (md.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL && !md.isMergeIntrospection()))
-									workingAllOperations.add(o);
-							}
-						}
-					} else {
-						// We want to merge all.
-						// BeanInfo could of given us the don't merge list. If the list is empty, then we accept all.
-						if (bd != null && bd.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames())) {
-							// We were given a list of names.
-							// Get the names into a set to create a quick lookup.
-							HashSet superSet = new HashSet(bd.getNotInheritedMethodNames());
-							
-							// Now walk and add in non-bean operations (and bean operations that were explicitly added and not mergeable (i.e. didn't come thru beaninfo)) 
-							// and add those not specifically called out by BeanInfo not merge list.
-							int lenST = superTypes.size();
-							for (int i=0; i<lenST; i++) {
-								List supers = ((JavaClass) superTypes.get(i)).getEAllOperations();
-								int len = supers.size();
-								for (int i1 = 0; i1 < len; i1++) {
-									EOperation o = (EOperation) supers.get(i1);
-									MethodDecorator md = Utilities.getMethodDecorator(o);
-									if (md == null || (md.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL && !md.isMergeIntrospection()))
-										workingAllOperations.add(o);
-									else {
-										String longName = formLongName(o);
-										if (longName == null || !superSet.contains(longName))
-											workingAllOperations.add(o);
-									}
-								}
-							}
-						} else {
-							int lenST = superTypes.size();
-							for (int i=0; i<lenST; i++) {
-								workingAllOperations.addAll(((JavaClass) superTypes.get(i)).getEAllOperations());
-							}
-						}
-					}
-					if (workingAllOperations != allOperations)
-						allOperations.addAll(workingAllOperations);	// Now copy over the ordered super operations.					
-				}
-				allOperations.addAll(localOperations);				
-				ESuperAdapter sa = getJavaClass().getESuperAdapter();
-				sa.setAllOperationsCollectionModified(false); // Now built, so reset to not changed.
-			} finally {
-				synchronized(this) {
-					isDoingAllProperties = false;
-				}
-			}
-		}
-
-		allOperations.shrink();
-		return new EcoreEList.UnmodifiableEList.FastCompare(
-			getJavaClass(),
-			EcorePackage.eINSTANCE.getEClass_EAllOperations(),
-			allOperations.size(),
-			allOperations.data());
-
-	}
-
-	/*
-	 * Should only be called from introspect so that flags are correct.
-	 */
-	private void finalizeEvents(ChangeDescription cd) {
-		// Now go through the list and remove those that should be removed.
-		Map oldLocals = getEventsMap();
-		Iterator itr = getEventsList().iterator();
-		while (itr.hasNext()) {
-			JavaEvent a = (JavaEvent) itr.next();
-			EventSetDecorator e = Utilities.getEventSetDecorator(a);
-			Object aOld = oldLocals.get(a.getName());
-			if (aOld != null && aOld != Boolean.FALSE) {
-				// A candidate for removal. It was in the old list and it was not processed.
-				if (e != null) {
-					ImplicitItem implicit = e.getImplicitDecoratorFlag();
-					if (implicit != ImplicitItem.NOT_IMPLICIT_LITERAL) {
-						e.setEModelElement(null); // Remove it because it was implicit.
-						((InternalEObject) e).eSetProxyURI(BAD_URI);
-						if (implicit == ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL) {
-							itr.remove(); // The feature was implicit too.
-							((InternalEObject) a).eSetProxyURI(BAD_URI);
-						}
-						continue;	// At this point we don't have a decorator any more, so don't bother going on.
-					}
-				}
-			}
-			
-			if (e != null && cd != null) {
-				// Now create the appropriate cache entry for this event.
-				BeanInfoDecoratorUtility.buildChange(cd, e);
-			}
-		}
-	}
-
-	/**
-	 * Fill in the event and its decorator using the eventDesc.
-	 */
-	protected EventSetDecorator calculateEvent(EventSetRecord record) {
-		return createEvent(record.name);
-	}
-
-	/**
-	 * Fill in the event and its decorator using the passed in information.
-	 */
-	protected EventSetDecorator createEvent(String name) {
-		// First find if there is already an event of this name, and if there is, is the EventSetDecorator
-		// marked to not allow merging in of introspection results.
-		HashMap existingLocals = getEventsMap();
-		JavaEvent event = null;
-		EventSetDecorator ed = null;
-		Object b = existingLocals.get(name);
-		if (Boolean.FALSE == b)
-			return null; // We've already processed this event, can't process it again.			
-		if (b != null) {
-			// We've found one of the same event. Whether we modify it or use it as is, we put in a
-			// special dummy in its place. That marks that we've already processed it and accepted it.
-			existingLocals.put(name, Boolean.FALSE);
-
-			// If the decorator for this entry says not to merge then return.
-			// If there is no decorator, then we will merge. If they didn't want to
-			// merge, then they should of created a decorator with no merge on it.
-			ed = Utilities.getEventSetDecorator((JavaEvent) b);
-			if (ed != null && !ed.isMergeIntrospection())
-				return null;
-			event = (JavaEvent) b;
-		}
-		
-		ImplicitItem implicit = ed == null ? ImplicitItem.IMPLICIT_DECORATOR_LITERAL : ImplicitItem.NOT_IMPLICIT_LITERAL;
-		if (event == null) {
-			// We will create a new Event.
-			event = BeaninfoFactory.eINSTANCE.createBeanEvent();
-			getEventsList().add(event);
-			implicit = ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL; // Can't have an implicit feature but explicit decorator.
-		}
-
-		setEventID(name, event);
-		event.setName(name);
-
-		// Now create in the event decorator for it.
-		// If there already is one then we
-		// will use it. This allows merging with beaninfo.		
-		if (ed == null) {
-			ed = BeaninfoFactory.eINSTANCE.createEventSetDecorator();
-			ed.setImplicitDecoratorFlag(implicit);
-			event.getEAnnotations().add(ed);
-		} else
-			BeanInfoDecoratorUtility.clear(ed);
-		return ed;
-	}
-
-	/**
-	 * @param name
-	 * @param event
-	 * 
-	 * @since 1.1.0
-	 */
-	private void setEventID(String name, JavaEvent event) {
-		// Now fill it in.
-		((XMIResource) event.eResource()).setID(event, getJavaClass().getName() + BeaninfoJavaReflectionKeyExtension.EVENT + name);
-	}
-
-	/**
-	 * Reflect the events. This requires going through local public methods and creating an 
-	 * event for the discovered events.
-	 */
-	protected void reflectEvents() {
-		// If we are set to mergeSuperTypeEvents, then we need to get the super events.
-		// This is so that duplicate any from super that we find here. When reflecting we don't
-		// allow discovered duplicates.
-		//
-		// Kludge: BeanInfo spec doesn't address Interfaces, but some people want to use them.
-		// Interfaces can have multiple extends, while the Introspector ignores these for reflection,
-		// the truth is most people want these. So we will add them in. But since there could be more than one it
-		// gets confusing. We need to look for dups from the super types.
-		//
-		// Supertypes will never be more than one entry for classes, it is possible to be 0, 1, 2 or more for interfaces.
-		Set supers = new HashSet(50);
-		BeanDecorator bd = Utilities.getBeanDecorator(getJavaClass());
-		if (bd == null || bd.isMergeSuperEvents()) {
-			List superTypes = getJavaClass().getESuperTypes();
-			if (!superTypes.isEmpty()) {
-				int lenST = superTypes.size();
-				for (int i=0; i<lenST; i++) {
-					List superAll = ((JavaClass) superTypes.get(i)).getAllEvents();
-					int len = superAll.size();
-					for (int i1=0; i1<len; i1++) {
-						JavaEvent se = (JavaEvent) superAll.get(i1);
-						supers.add(se.getName());
-					}
-				}
-			}
-		}
-
-		HashMap events = new HashMap();
-		eventListenerClass = (JavaClass) JavaRefFactory.eINSTANCE.reflectType("java.util.EventListener", getJavaClass()); // Initialize, needed for building eventinfos. //$NON-NLS-1$
-		tooManyExceptionClass = (JavaClass) JavaRefFactory.eINSTANCE.reflectType("java.util.TooManyListenersException", getJavaClass()); // Initialize, needed for building eventinfos. //$NON-NLS-1$
-		Iterator itr = getJavaClass().getPublicMethods().iterator();
-		while (itr.hasNext()) {
-			Method mthd = (Method) itr.next();
-			if (mthd.isStatic() || mthd.isConstructor())
-				continue; // Statics/constructors don't participate in events.
-			String key = validEventAdder(mthd);
-			if (key != null) {
-				EventInfo eventInfo = (EventInfo) events.get(key);
-				if (eventInfo == null) {
-					eventInfo = new EventInfo();
-					eventInfo.setAdder(mthd);
-					events.put(key, eventInfo);
-				} else
-					eventInfo.setAdder(mthd);
-			} else {
-				key = validEventRemove(mthd);
-				if (key != null) {
-					EventInfo eventInfo = (EventInfo) events.get(key);
-					if (eventInfo == null) {
-						eventInfo = new EventInfo();
-						eventInfo.setRemover(mthd);
-						events.put(key, eventInfo);
-					} else
-						eventInfo.setRemover(mthd);
-				}
-			}
-		}
-
-		eventListenerClass = null; // No longer need it.
-
-		// Now actually create the events.
-		HashSet eventNames = new HashSet(events.size()); // Set of found event names, to prevent duplicates
-		Iterator evtItr = events.entrySet().iterator();
-		while (evtItr.hasNext()) {
-			Map.Entry eventMap = (Map.Entry) evtItr.next();
-			EventInfo ei = (EventInfo) eventMap.getValue();
-			if (ei.isValidInfo()) {
-				String eventName = getEventName((String) eventMap.getKey());
-				if (eventNames.contains(eventName))
-					continue;	// Aleady created it. (Note: Introspector actually takes last one over previous dups, but the order is totally undefined, so choosing first is just as good or bad.
-
-				if (supers.contains(eventName))
-					continue; // Don't override a super event.
-
-				if (ei.createEvent(eventName))
-					eventNames.add(eventName); // It was validly created.
-			}
-		}
-
-		tooManyExceptionClass = null; // No longer need it.
-	}
-
-	/**
-	 * merge all the Events (i.e. supertypes)
-	 */
-	protected EList allEvents() {
-
-		EList jcAllEvents = getJavaClass().getAllEventsGen();
-		BeaninfoSuperAdapter superAdapter =
-			(BeaninfoSuperAdapter) EcoreUtil.getRegisteredAdapter(getJavaClass(), BeaninfoSuperAdapter.class);
-		if (jcAllEvents != null) {
-			// See if new one required.
-			if (superAdapter == null || !superAdapter.isAllEventsCollectionModified())
-				return jcAllEvents;
-			// Can't get superadapter, so must not be attached to a resource, so return current list. Or no change required.       		
-		}
-
-		UniqueEList.FastCompare allEvents = new UniqueEList.FastCompare() {
-			/**
-			 * Comment for <code>serialVersionUID</code>
-			 * 
-			 * @since 1.1.0
-			 */
-			private static final long serialVersionUID = 1L;
-
-			protected Object[] newData(int capacity) {
-				return new JavaEvent[capacity];
-			}
-		};
-		
-		boolean doAllEvents = false;
-		synchronized(this) {
-			// If we are introspecting, don't do all properties because it is an invalid list. Just return empty without reseting the all modified flag.
-			doAllEvents = !isDoingAllEvents && !isIntrospecting && isResourceConnected();
-			if (doAllEvents)
-				isDoingAllEvents = true;
-		}
-
-		if (doAllEvents) {
-			try {
-				EList localEvents = getJavaClass().getEvents();
-				// Kludge: BeanInfo spec doesn't address Interfaces, but some people want to use them.
-				// Interfaces can have multiple extends, while the Introspector ignores these for reflection,
-				// the truth is most people want these. So we will add them in. But since there could be more than one it
-				// gets confusing. We need to look for dups from the super types and still keep order.
-				//
-				// Supertypes will never be more than one entry for classes, it is possible to be 0, 1, 2 or more for interfaces.
-				List superTypes = getJavaClass().getESuperTypes();
-				if (!superTypes.isEmpty()) {
-					// Now we need to merge in the supers.
-					BeanDecorator bd = Utilities.getBeanDecorator(getJavaClass());
-					// If there is only one supertype, we can add to the actual events, else we will use the linked hashset so that
-					// we don't add possible duplicates (e.g. IA extends IB,IC and IB extends IC. In this case there would be dups
-					// because IB would contribute IC's too).
-					Collection workingAllEvents = superTypes.size() == 1 ? (Collection) allEvents : new LinkedHashSet(); 
-					// We will now merge as directed.
-					boolean mergeAll = bd == null || bd.isMergeSuperEvents();
-					if (!mergeAll) {
-						// we don't to want to merge super events, but we still need super non-events or explicit ones.
-						int lenST = superTypes.size();
-						for (int i=0; i<lenST; i++) {
-							List supers = ((JavaClass) superTypes.get(i)).getAllEvents();
-							int len = supers.size();
-							for (int i1 = 0; i1 < len; i1++) {
-								JavaEvent e = (JavaEvent) supers.get(i1);
-								EventSetDecorator ed = Utilities.getEventSetDecorator(e);
-								if (ed == null || (ed.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL && !ed.isMergeIntrospection()))
-									workingAllEvents.add(e);
-							}
-						}
-					} else {
-						// We want to merge all.					
-						// BeanInfo has given us the not merge list. If the list is empty, then we accept all.
-						if (bd != null && bd.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames())) {
-							// We were given a list of names.
-							// Get the names into a set to create a quick lookup.
-							HashSet superSet = new HashSet(bd.getNotInheritedEventNames());
-							
-							// Now walk and add in non-bean events (and bean events that were explicitly added and not mergeable (i.e. didn't come thru beaninfo)) 
-							// and add those not specifically called out by BeanInfo.
-							int lenST = superTypes.size();
-							for (int i=0; i<lenST; i++) {
-								List supers = ((JavaClass) superTypes.get(i)).getAllEvents();
-								int len = supers.size();
-								for (int i1 = 0; i1 < len; i1++) {
-									JavaEvent e = (JavaEvent) supers.get(i1);
-									EventSetDecorator ed = Utilities.getEventSetDecorator(e);
-									if (ed == null || (ed.getImplicitDecoratorFlag() == ImplicitItem.NOT_IMPLICIT_LITERAL && !ed.isMergeIntrospection()) || !superSet.contains(ed.getName()))
-										workingAllEvents.add(e);
-								}
-							}
-						} else {
-							// BeanInfo called out that all super events should be added, or no beaninfo.
-							int lenST = superTypes.size();
-							for (int i=0; i<lenST; i++) {
-								workingAllEvents.addAll(((JavaClass) superTypes.get(i)).getAllEvents());
-							}
-						}
-					}
-					if (workingAllEvents != allEvents)
-						allEvents.addAll(workingAllEvents);	// Now copy over the ordered super events.
-				}
-				allEvents.addAll(localEvents);				
-				superAdapter.setAllEventsCollectionModified(false); // Now built, so reset to not changed.
-			} finally {
-				synchronized (this) {
-					isDoingAllEvents = false;
-				}
-			}
-		}
-
-		if (allEvents.isEmpty())
-			return ECollections.EMPTY_ELIST;
-		else {
-			allEvents.shrink();
-			return new EcoreEList.UnmodifiableEList.FastCompare(
-				getJavaClass(),
-				JavaRefPackage.eINSTANCE.getJavaClass_AllEvents(),
-				allEvents.size(),
-				allEvents.data());
-		}
-
-	}
-
-	private JavaClass eventListenerClass, // Event Listener class. Needed for validation.
-	tooManyExceptionClass; // Too many listeners exception.
-
-	/*
-	 * Pass in the key, it will be used to form the name.
-	 */
-	protected String getEventName(String key) {
-		return key.substring(0, key.indexOf(':'));
-	}
-
-	/*	
-	 * Answers event key if valid, null if not valid.
-	 */
-	protected String validEventAdder(Method method) {
-		String name = method.getName();
-		if (!name.startsWith("add") || !name.endsWith("Listener")) //$NON-NLS-1$ //$NON-NLS-2$
-			return null; // Not valid format for an add listener name.
-
-		List parms = method.getParameters();
-		if (parms.size() != 1)
-			return null; // Invalid - improper number of parms.
-
-		EClassifier returnType = method.getReturnType();
-		if (returnType == null || !returnType.getName().equals("void")) //$NON-NLS-1$
-			return null; // Invalid - must be void return type.
-
-		EClassifier parmType = ((JavaParameter) parms.get(0)).getEType();
-		if (!BeaninfoClassAdapter.this.eventListenerClass.isAssignableFrom(parmType))
-			return null; // Parm must be inherit from EventListener
-
-		// This is a unique containing event name and listener type
-		// This is so we can have a unique key for two events with the same
-		// name but different listener type. (This matches Introspector so that we aren't
-		// coming up with different results.
-		return java.beans.Introspector.decapitalize(name.substring(3, name.length() - 8))
-			+ ':'
-			+ ((JavaHelpers) parmType).getQualifiedName();
-	}
-
-	/*
-	 * Answers event key if valid, null if not valid.
-	 */
-	protected String validEventRemove(Method method) {
-		String name = method.getName();
-		if (!name.startsWith("remove") || !name.endsWith("Listener")) //$NON-NLS-1$ //$NON-NLS-2$
-			return null; // Not valid format for a remove listener name.
-
-		List parms = method.getParameters();
-		if (parms.size() != 1)
-			return null; // Invalid - improper number of parms.
-
-		EClassifier returnType = method.getReturnType();
-		if (returnType == null || !returnType.getName().equals("void")) //$NON-NLS-1$
-			return null; // Invalid - must be void return type.
-
-		EClassifier parmType = ((JavaParameter) parms.get(0)).getEType();
-		if (!BeaninfoClassAdapter.this.eventListenerClass.isAssignableFrom(parmType))
-			return null; // Parm must be inherit from EventListener
-
-		// This is a unique containing event name and listener type
-		// This is so we can have a unique key for two events with the same
-		// name but different listener type. (This matches Introspector so that we aren't
-		// coming up with different results).
-		return java.beans.Introspector.decapitalize(name.substring(6, name.length() - 8))
-			+ ':'
-			+ ((JavaHelpers) parmType).getQualifiedName();
-	}
-
-	public boolean isDefaultBound() {
-		if (defaultBound == null) {
-			// Haven't yet decided on it.
-			Iterator methods = getJavaClass().getPublicMethods().iterator();
-			boolean foundAdd = false, foundRemove = false;
-			while (methods.hasNext() && (!foundAdd || !foundRemove)) {
-				Method method = (Method) methods.next();
-				if ("addPropertyChangeListener".equals(method.getName())) { //$NON-NLS-1$
-					List parms = method.getParameters();
-					if (parms.size() == 1) {
-						JavaParameter parm = (JavaParameter) parms.get(0);
-						if ("java.beans.PropertyChangeListener".equals(((JavaHelpers) parm.getEType()).getQualifiedName())) { //$NON-NLS-1$
-							foundAdd = true;
-							continue;
-						}
-					}
-				} else if ("removePropertyChangeListener".equals(method.getName())) { //$NON-NLS-1$
-					List parms = method.getParameters();
-					if (parms.size() == 1) {
-						JavaParameter parm = (JavaParameter) parms.get(0);
-						if ("java.beans.PropertyChangeListener".equals(((JavaHelpers) parm.getEType()).getQualifiedName())) { //$NON-NLS-1$
-							foundRemove = true;
-							continue;
-						}
-					}
-				}
-			}
-
-			defaultBound = (foundAdd && foundRemove) ? Boolean.TRUE : Boolean.FALSE;
-		}
-		return defaultBound.booleanValue();
-	}
-
-	private class EventInfo {
-		
-		public Method addListenerMethod;
-		public Method removeListenerMethod;
-
-		public void setAdder(Method addMethod) {
-			addListenerMethod = addMethod;
-		}
-
-		public void setRemover(Method removeMethod) {
-			removeListenerMethod = removeMethod;
-		}
-
-		// Answer whether this is a valid event info.
-		public boolean isValidInfo() {
-			return (addListenerMethod != null && removeListenerMethod != null);
-		}
-
-		public boolean createEvent(String name) {
-			EventSetDecorator ed = BeaninfoClassAdapter.this.createEvent(name);
-			if (ed == null)
-				return false; // Reflection not wanted.
-
-
-			// See if unicast.
-			boolean unicast = false;
-			List exceptions = addListenerMethod.getJavaExceptions();
-			int len = exceptions.size();
-			for(int i=0; i<len; i++) {
-				if (exceptions.get(i) == BeaninfoClassAdapter.this.tooManyExceptionClass) {
-					unicast = true;
-					break;
-				}
-			}
-			// We'll let listener methods get retrieved dynamically when needed.
-			BeanInfoDecoratorUtility.setProperties(ed, addListenerMethod, removeListenerMethod, unicast, (JavaClass) ((JavaParameter) addListenerMethod.getParameters().get(0)).getEType());
-			return true;
-		}
-
-	}
-
-	/**
-	 * Marh the factory as stale, but leave the overrides alone. They are not stale.
-	 * @param stale
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public void markStaleFactory(ProxyFactoryRegistry stale) {
-		markStaleFactory(stale, false);
-	}
-	
-	/**
-	 * Mark this factory as the stale factory.
-	 * 
-	 * @param clearOverriddes clear the overrides too. They are stale.
-	 */
-	public void markStaleFactory(ProxyFactoryRegistry stale, boolean clearOverriddes) {
-		if (staleFactory == null) {
-			// It's not stale so make it stale.
-			// So that next access will re-introspect
-			defaultBound = null; // So query on next request.
-			staleFactory = new WeakReference(stale);
-
-			// Need to mark the esuperadapter that things have changed so that any 
-			// subtype will know to reuse the parent for anything that requires knowing parent info.
-			Adapter a = EcoreUtil.getExistingAdapter(getTarget(), ESuperAdapter.class);
-			// Simulate that this objects super has changed. This will make all subclasses
-			// think about the super has changed and next retrieving anything that involves the
-			// super will cause a rebuild to occur.
-			Notification note =
-				new ENotificationImpl((InternalEObject) getTarget(), Notification.SET, EcorePackage.ECLASS__ESUPER_TYPES, null, null);
-			if (a != null)
-				a.notifyChanged(note);
-			// Do the same with BeaninfoSuperAdapter so that events also will be rebuilt.
-			a = EcoreUtil.getExistingAdapter(getTarget(), BeaninfoSuperAdapter.ADAPTER_KEY);
-			if (a != null)
-				a.notifyChanged(note);
-			synchronized (this) {
-				needsIntrospection = true;
-				if (clearOverriddes) {
-					retrievedExtensionDocument = CLEAR_EXTENSIONS;
-					if (classEntry != null) {
-						classEntry.markDeleted();
-						classEntry = null; // Get a new one next time.
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * Form a longname for the addkey function.
-	 */
-	private String formLongName(EOperation feature) {
-		Method mthd = null;
-		if (feature instanceof Method)
-			mthd = (Method) feature;
-		else if (feature instanceof MethodProxy)
-			mthd = ((MethodProxy) feature).getMethod();
-		else
-			return null; // Don't know what it is.
-
-		StringBuffer longName = new StringBuffer(100);
-		longName.append(feature.getName()); // Feature Name
-		longName.append(':');
-		longName.append(mthd.getName()); // Method Name
-		longName.append('(');
-		List p = mthd.getParameters();
-		for (int i = 0; i < p.size(); i++) {
-			JavaParameter parm = (JavaParameter) p.get(i);
-			if (i>0)
-				longName.append(',');
-			longName.append(parm.getJavaType().getQualifiedName());
-		}
-
-		return longName.toString();
-	}
-	
-	/*
-	 * More than one operation can have the same name. To identify them uniquely, the long name is created,
-	 * which is formed from the name and the method signature.
-	 */
-	private String formLongName(MethodRecord record) {
-		StringBuffer longName = new StringBuffer(100);
-		longName.append(record.name); // Feature Name
-		longName.append(':');
-		longName.append(record.methodForDescriptor.methodName); // Method Name
-		longName.append('(');
-		String[] p = record.methodForDescriptor.parameterTypeNames;
-		if (p != null)
-			for (int i = 0; i < p.length; i++) {
-				if (i>0)
-					longName.append(',');
-				longName.append(MapJNITypes.getFormalTypeName(p[i]));
-			}
-
-		return longName.toString();
-	}
-	/**
-	 * @see org.eclipse.emf.common.notify.Adapter#notifyChanged(Notification)
-	 */
-	public void notifyChanged(Notification msg) {
-		// In case of removing adapter, make sure we are first removed from the factory so it doesn't know about us anymore.
-		if (msg.getEventType() == Notification.REMOVING_ADAPTER)
-			getAdapterFactory().removeAdapter(this);
-	}
-
-	/**
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		return super.toString() + '(' + (getJavaClass() != null ? getJavaClass().getQualifiedName() : "?") + ')'; //$NON-NLS-1$
-	}
-
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoJavaReflectionKeyExtension.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoJavaReflectionKeyExtension.java
deleted file mode 100644
index 773b911..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoJavaReflectionKeyExtension.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: BeaninfoJavaReflectionKeyExtension.java,v $
- *  $Revision: 1.7 $  $Date: 2005/09/14 23:30:38 $ 
- */
-
-import java.util.Iterator;
-import java.util.List;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.adapters.IJavaReflectionKey;
-import org.eclipse.jem.java.adapters.IJavaReflectionKeyExtension;
-
-/**
- * Java Reflection Key extension to retrieve keys for beaninfo creations.
- * 
- * Handles attributes and behaviors.
- * 
- * @version 	1.0
- * @author R. L. Kulp  
- */
-public class BeaninfoJavaReflectionKeyExtension implements IJavaReflectionKeyExtension {
-	
-	// The format of the keys are:
-	// behaviors:  "classname/behavior/behaviorname"
-	// structural features: "classname/featurename"
-	public static final String 
-		BEHAVIOR = "/operation/",	// Piece in key that indicates this is a behavior. //$NON-NLS-1$
-		EVENT = "/event/",		// Piece in key that indicates this is an event. //$NON-NLS-1$
-		FEATURE = "/";			// Piece in key that indicates this is an attribute. //$NON-NLS-1$
-	
-	/**
-	 * Get the object for this key.
-	 */
-	public Object getObject(String key, IJavaReflectionKey reflectionKey) {
-		if (key != null) {
-			int ibehave = key.indexOf(BEHAVIOR);
-			if (ibehave > -1) {
-				// We have a possible behavior.
-				String classname = key.substring(0, ibehave);
-				int ibehaveName = ibehave+BEHAVIOR.length();
-				if (ibehaveName < key.length()) {
-					JavaClass javaclass = getJavaClass(reflectionKey, classname);
-					if (javaclass != null) {
-						javaclass.getEOperations();	// Get the list introspected and populated if not already.
-						return reflectionKey.primGet(key);	// It should now be there, 
-					}
-				}
-			} else {
-				int ievent = key.indexOf(EVENT);
-				if (ievent > -1) {
-					// We have a possible event.
-					String classname = key.substring(0, ievent);
-					int ieventName = ievent+EVENT.length();
-					if (ieventName < key.length()) {
-						JavaClass javaclass = getJavaClass(reflectionKey, classname);
-						if (javaclass != null) {
-							javaclass.getEvents();	// Get the list introspected and populated if not already.
-							return reflectionKey.primGet(key);	// It should now be there, 
-						}
-					}
-				} else {
-					int ifeature = key.indexOf(FEATURE);
-					if (ifeature > -1) {
-						// We have a possible feature.
-						String classname = key.substring(0, ifeature);
-						int ifeatureName = ifeature+FEATURE.length();
-						if (ifeatureName < key.length()) {
-							String feature = key.substring(ifeatureName);
-							JavaClass javaclass = getJavaClass(reflectionKey, classname);
-							if (javaclass != null) {
-								// This is just a hack until we can get ID situation straightened out.
-								// Need to cause introspection of the attributes and references.
-								javaclass.getEStructuralFeatures();
-								Object result = reflectionKey.primGet(key);	// See if it now got added as an id.
-								if (result == null) {
-									// Well, it could of been added by the diff merge, which as of now can't handle ids.
-									// So we will find it within the attributes/references.
-									result = findFeature(feature, javaclass.getEReferences());
-									if (result == null)
-										result = findFeature(feature, javaclass.getEAttributes());									
-									if (result instanceof EStructuralFeature) {
-										// Need to add it as an id so next time won't come through here.
-										((XMIResource) javaclass.eResource()).setID((EObject) result, key);	// So next time it will find it directly.
-									}
-								}
-								return result;
-							}
-						}
-					}
-				}
-			}
-		}
-						
-		return null;
-	}
-
-	private EStructuralFeature findFeature(String featureName, List featureList) {
-		Iterator itr = featureList.iterator();		
-		while (itr.hasNext()) {
-			EStructuralFeature feature = (EStructuralFeature) itr.next();
-			if (featureName.equals(feature.getName())) {
-				return feature;
-			}
-		}
-		return null;
-	}
-
-	protected JavaClass getJavaClass(IJavaReflectionKey reflectionKey, String classname) {
-		Object eclass = reflectionKey.primGet(classname);
-		if (eclass == null) 
-			eclass = reflectionKey.getJavaType(classname);	// Let it create it.
-		if (eclass instanceof JavaClass)
-			return (JavaClass) eclass;
-		else
-			return null;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoModelSynchronizer.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoModelSynchronizer.java
deleted file mode 100644
index 7d67876..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoModelSynchronizer.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: BeaninfoModelSynchronizer.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.*;
-
-import org.eclipse.jem.internal.adapters.jdom.JavaModelListener;
-/**
- * This class listens for changes to the java model and flushs the
- * appropriate class introspection.
- */
-
-public class BeaninfoModelSynchronizer extends JavaModelListener {
-	protected BeaninfoAdapterFactory fAdapterFactory;
-	protected IJavaProject fProject; // The project this listener is opened on.
-	private static final IPath BEANINFOCONFIG_PATH = new Path(BeaninfoNature.P_BEANINFO_SEARCH_PATH);	//$NON-NLS-1$	
-
-	public BeaninfoModelSynchronizer(BeaninfoAdapterFactory aFactory, IJavaProject aProject) {
-		super(ElementChangedEvent.POST_CHANGE);
-		fAdapterFactory = aFactory;
-		fProject = aProject;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#getJavaProject()
-	 */
-	protected IJavaProject getJavaProject() {
-		return fProject;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#isAlsoClasspathChange(org.eclipse.core.runtime.IPath)
-	 */
-	protected boolean isAlsoClasspathChange(IPath path) {
-		return path.equals(BEANINFOCONFIG_PATH);
-	}
-	
-	/**
-	 * Stop the synchronizer from listening to any more changes.
-	 */
-	public void stopSynchronizer(boolean clearResults) {
-		JavaCore.removeElementChangedListener(this);
-		getAdapterFactory().closeAll(clearResults);
-	}
-
-	public BeaninfoAdapterFactory getAdapterFactory() {
-		return fAdapterFactory;
-	}
-
-	protected void processJavaElementChanged(IJavaProject element, IJavaElementDelta delta) {
-		if (isInClasspath(element)) {
-			if (delta.getKind() == IJavaElementDelta.REMOVED || delta.getKind() == IJavaElementDelta.ADDED) {
-				// Don't need to do anything for delete/close/add/open of main project because there is much more that needs to
-				// be done by BeaninfoNature on project close/delete, so nature listens for this and does the appropriate cleanup.			
-				if (!element.equals(fProject)) {
-					// However, all other projects are required projects and if they are deleted/closed/added/opened when need to do
-					// a full flush because we don't know any of the state, whether they are still there or not.
-					getAdapterFactory().markAllStale();
-				}
-				return;
-			} else if (isClasspathResourceChange(delta)) {
-				getAdapterFactory().markAllStale(); // The .classpath file (or .beaninfoconfig) itself in SOME DEPENDENT PROJECT has changed. 
-				return;
-			}
-			processChildren(element, delta);
-		}
-	}
-
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 * If a working copy, then ignore it because we don't care about changes until
-	 * they are committed. Else, if the CU has changed content then mark all of the
-	 * types in this CU (such as inner classes) as stale.
-	 * If it is not a content change then process the children.
-	 */
-	protected void processJavaElementChanged(ICompilationUnit element, IJavaElementDelta delta) {
-		switch (delta.getKind()) {
-			case IJavaElementDelta.CHANGED :
-				// A file save had occurred. It doesn't matter if currently working copy or not.
-				// It means something has changed to the file on disk, but don't know what.
-				if ((delta.getFlags() & IJavaElementDelta.F_PRIMARY_RESOURCE) != 0) {
-					getAdapterFactory().markStaleIntrospectionPlusInner(getFullNameFromElement(element), false);	// Flush everything, including inner classes.
-				}						
-				
-				break;
-			case IJavaElementDelta.ADDED:
-			case IJavaElementDelta.REMOVED:
-				// Need to know for add because we optimize the beaninfo such that once found as undefined, it won't
-				// introspect again until we mark it stale. So we need to mark it stale to refresh it.
-				
-				// It doesn't matter if totally removed or just moved somewhere else, we will clear out
-				// adapter because there could be a rename which would be a different class.
-				// Currently the element is already deleted or added and there is no way to find the types in the unit to flush.
-				// So instead we ask factory to flush all it any that start with it plus for inner classes.				
-				getAdapterFactory().markStaleIntrospectionPlusInner(getFullNameFromElement(element), true);	// Flush everything, including inner classes.
-				break;
-		}
-	}
-
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-		 */
-	protected void processJavaElementChanged(IClassFile element, IJavaElementDelta delta) {
-		if (delta.getKind() == IJavaElementDelta.REMOVED) {
-			// It doesn't matter if totally removed or just moved somewhere else, we will clear out and remove the
-			// adapter because there could be a rename which would be a different class.
-			// Currently the element is already deleted and there is no way to find the types in the unit to remove.
-			// So instead we ask factory to remove all it any that start with it plus for inner classes.
-			getAdapterFactory().markStaleIntrospectionPlusInner(getFullNameFromElement(element), true);
-			return; // Since the classfile was removed we don't need to process the children (actually the children list will be empty
-		}
-		IJavaElementDelta[] children = delta.getAffectedChildren();
-		for (int ii = 0; ii < children.length; ii++) {
-			processDelta(children[ii]);
-		}
-	}
-
-	protected String getFullNameFromElement(IJavaElement element) {
-		String name = element.getElementName();		
-		if (!(element instanceof ICompilationUnit || element instanceof IClassFile))
-			return name;	// Shouldn't be here
-		
-		// remove extension.
-		int periodNdx = name.lastIndexOf('.');
-		if (periodNdx == -1)
-			return name;	// Shouldn't be here. There should be an extension
-					
-		String typeName = null;
-		String parentName = element.getParent().getElementName();
-		if (parentName == null || parentName.length() == 0)
-			typeName = name.substring(0, periodNdx); // In default package
-		else
-			typeName = parentName + "." + name.substring(0, periodNdx); //$NON-NLS-1$
-								
-		return typeName;
-	}
-
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 * If the classpath has changed, mark all as stale because we don't know what
-	 * has changed. Things that were in the path may no longer be in the path, or
-	 * the order was changed, which could affect the introspection.
-	 */
-	protected void processJavaElementChanged(IPackageFragmentRoot element, IJavaElementDelta delta) {
-		if (isClassPathChange(delta))
-			fAdapterFactory.markAllStale();
-		else
-			super.processJavaElementChanged(element, delta);
-	}
-	
-	protected void processJavaElementChanged(IPackageFragment element, IJavaElementDelta delta) {
-		switch (delta.getKind()) {
-			case IJavaElementDelta.ADDED:
-				break;	// Don't need to do anything on a new package. If this was from a new fragroot, we would recycle already. Otherwise, it will find this package on the first use.
-			case IJavaElementDelta.REMOVED:
-				if (delta.getAffectedChildren().length == 0)
-					fAdapterFactory.markAllStale();
-				break;
-			default :
-				super.processJavaElementChanged(element, delta);
-		}
-	}
-	
-
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 * Something about the type has changed. If it was removed (not a move), then close the
-	 * adapter too.
-	 */
-	protected void processJavaElementChanged(IType element, IJavaElementDelta delta) {
-		if (delta.getKind() == IJavaElementDelta.REMOVED) {
-			// Close it out. Doesn't matter if moved_to, that would be a rename which requires brand new class.
-			// We can't actually get rid of the beaninfo adapter because it may be asked for again
-			// just to see if not defined. It may also come back later and we want to know about
-			// it to recycle the vm.
-			getAdapterFactory().markStaleIntrospection(element.getFullyQualifiedName(), true);	
-		} else
-			getAdapterFactory().markStaleIntrospection(element.getFullyQualifiedName(), false); // Just mark it stale
-		processChildren(element, delta);
-	}
-
-	public String toString() {
-		return super.toString()+" "+fProject.getElementName(); //$NON-NLS-1$
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoNature.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoNature.java
deleted file mode 100644
index 7b278a4..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoNature.java
+++ /dev/null
@@ -1,979 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: BeaninfoNature.java,v $
- *  $Revision: 1.39 $  $Date: 2005/10/26 14:24:56 $ 
- */
-
-import java.io.*;
-import java.text.MessageFormat;
-import java.util.*;
-import java.util.logging.Level;
-
-import javax.xml.parsers.*;
-import javax.xml.transform.*;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamResult;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
-import org.eclipse.jdt.core.*;
-import org.osgi.framework.Bundle;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.xml.sax.InputSource;
-
-import org.eclipse.jem.internal.beaninfo.core.*;
-import org.eclipse.jem.internal.java.beaninfo.IIntrospectionAdapter;
-import org.eclipse.jem.internal.java.init.JavaInit;
-import org.eclipse.jem.internal.plugin.JavaEMFNature;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo.ContainerPaths;
-import org.eclipse.jem.java.adapters.JavaXMIFactory;
-import org.eclipse.jem.util.emf.workbench.ProjectResourceSet;
-import org.eclipse.jem.util.emf.workbench.ResourceHandler;
-
-
-/**
- * The beaninfo nature. It is created for a project and holds the
- * necessary info for beaninfo to be performed on a project.
- */
-
-public class BeaninfoNature implements IProjectNature {
-
-	public static final String NATURE_ID = BeaninfoPlugin.PI_BEANINFO_PLUGINID + ".BeanInfoNature"; //$NON-NLS-1$
-	public static final String P_BEANINFO_SEARCH_PATH = ".beaninfoConfig"; //$NON-NLS-1$
-	
-	public static final QualifiedName CONFIG_INFO_SESSION_KEY = new QualifiedName(BeaninfoPlugin.PI_BEANINFO_PLUGINID, "CONFIG_INFO"); //$NON-NLS-1$
-	public static final QualifiedName BEANINFO_CONTRIBUTORS_SESSION_KEY = new QualifiedName(BeaninfoPlugin.PI_BEANINFO_PLUGINID, "BEANINFO_CONTRIBUTORS"); //$NON-NLS-1$
-
-	private ProxyFactoryRegistry.IRegistryListener registryListener = new ProxyFactoryRegistry.IRegistryListener() {
-		/**
-		 * @see org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry.IRegistryListener#registryTerminated(ProxyFactoryRegistry)
-		 */
-		public void registryTerminated(ProxyFactoryRegistry registry) {
-			markAllStale();
-		};
-	};
-
-	/**
-	 * Get the runtime nature for the project, create it if necessary.
-	 */
-	public static BeaninfoNature getRuntime(IProject project) throws CoreException {
-		JavaEMFNature.createRuntime(project);	// Must force JAVAEMFNature creation first before we try to get ours. There is a chicken/egg problem if we let our nature try to get JavaEMFNature during setProject.
-		if (project.hasNature(NATURE_ID))
-			return (BeaninfoNature) project.getNature(NATURE_ID);
-		else
-			return createRuntime(project);
-	}
-	
-	/**
-	 * Return whether this project has a BeanInfo runtime turned on.
-	 * 
-	 * @param project
-	 * @return <code>true</code> if it has the a BeanInfo runtime.
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static boolean hasRuntime(IProject project) throws CoreException {
-		return project.hasNature(NATURE_ID);
-	}
-
-	/**
-	 * Test if this is a valid project for a Beaninfo Nature. It must be
-	 * a JavaProject.
-	 */
-	public static boolean isValidProject(IProject project) {
-		try {
-			return project.hasNature(JavaCore.NATURE_ID);
-		} catch (CoreException e) {
-			return false;
-		}
-	}
-
-	/**
-	 * Create the runtime.
-	 */
-	private static BeaninfoNature createRuntime(IProject project) throws CoreException {
-		if (!isValidProject(project))
-			throw new CoreException(
-				new Status(
-					IStatus.ERROR,
-					BeaninfoPlugin.PI_BEANINFO_PLUGINID,
-					0,
-					MessageFormat.format(
-						BeanInfoAdapterMessages.INTROSPECT_FAILED_EXC_, 
-						new Object[] { project.getName(), BeanInfoAdapterMessages.BeaninfoNature_InvalidProject}), 
-					null));
-
-		addNatureToProject(project, NATURE_ID);
-		return (BeaninfoNature) project.getNature(NATURE_ID);
-	}
-
-	private static void addNatureToProject(IProject proj, String natureId) throws CoreException {
-		IProjectDescription description = proj.getDescription();
-		String[] prevNatures = description.getNatureIds();
-		String[] newNatures = new String[prevNatures.length + 1];
-		System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
-		newNatures[prevNatures.length] = natureId;
-		description.setNatureIds(newNatures);
-		proj.setDescription(description, null);
-	}
-
-	private IProject fProject;
-	protected ProxyFactoryRegistry fRegistry;
-	protected ResourceSet javaRSet;
-	protected BeaninfoModelSynchronizer fSynchronizer;
-	protected static BeaninfoJavaReflectionKeyExtension fReflectionKeyExtension;
-
-	/** 
-	 * Configures the project with this nature.
-	 * This is called by <code>IProject.getNature</code> and should not
-	 * be called directly by clients.
-	 * The nature extension id is added to the list of natures on the project by
-	 * <code>IProject.getNature</code>, and need not be added here.
-	 *
-	 * @exception CoreException if this method fails.
-	 */
-	public void configure() throws CoreException {
-	}
-
-	/** 
-	 * Removes this nature from the project, performing any required deconfiguration.
-	 * This is called by <code>IProject.removeNature</code> and should not
-	 * be called directly by clients.
-	 * The nature id is removed from the list of natures on the project by
-	 * <code>IProject.removeNature</code>, and need not be removed here.
-	 *
-	 * @exception CoreException if this method fails. 
-	 */
-	public void deconfigure() throws CoreException {
-		removeSharedProperty(P_BEANINFO_SEARCH_PATH, null);
-		cleanup(true, true);
-	}
-	
-	/**
-	 * Shutdown the nature. Called by BeanInfoPlugin to tell the nature that the plugin is being shutdown.
-	 * It needs to cleanup.
-	 * TODO <package-protected> because only BeanInfoPlugin should call it. (public for now but when we make
-	 * BeanInfoNature an API it will be moved into the same package as BeanInfoPlugin).
-	 * 
-	 * @since 1.0.0
-	 */
-	public void shutdown() {
-		cleanup(true, false);
-	}
-
-
-	/**
-	 * Return a new ResourceSet that is linked correctly to this Beaninfo Nature.
-	 * <p>
-	 * This links up a ResourceSet so that it will work correctly with this nature.
-	 * It makes sure that going through the ResourceSet that any "java:/..."
-	 * classes can be found and it makes sure that any new classes are placed into the
-	 * nature's resource set and not resource set doing the calling.
-	 * <p>
-	 * This should be used any time a resource set is needed that is not the
-	 * project wide resource set associated with beaninfos, but will reference
-	 * Java Model classes or instantiate.
-	 * <p>
-	 * An additional change is made too. The ResourceFactoryRegistry's extensionToResourceFactory map is modified
-	 * to have an "java"->XMIResourceFactory entry added to it if EMF Examples is loaded. EMF Examples add
-	 * the "java" extension and sets it to their own special JavaResourceFactory. 
-	 * If EMF Examples is not loaded, then it falls back to the default "*" mapping, which is to XMIResourceFactory.
-	 * This normally causes problems for many
-	 * customers. If users of this resource set really want the EMF examples entry instead, after they retrieve the
-	 * new resource set they can do this:
-	 * <p>
-	 * <pre><code>
-	 * 	rset = beaninfoNature.newResourceSet();
-	 * 	rset.getResourceFactoryRegistry().getExtensionToFactoryMap().remove("java");
-	 * </code></pre>
-	 * 
-	 * @return a ResourceSet that is specially connected to the JEM java model.
-	 * 
-	 * @since 1.0.0
-	 */
-	public ProjectResourceSet newResourceSet() {
-		SpecialResourceSet rset = new SpecialResourceSet();
-		rset.add(new ResourceHandler() {
-			public EObject getEObjectFailed(ResourceSet originatingResourceSet, URI uri, boolean loadOnDemand) {
-				return null; // We don't have any special things we can do in this case.
-			}
-
-			public Resource getResource(ResourceSet originatingResourceSet, URI uri) {
-				// Always try to get it out of the nature's resource set because it may of been loaded there either as 
-				// the "java:..." type or it could of been an override extra file (such as an override EMF package, for
-				// example jcf has a side package containing the definition of the new attribute type. That file
-				// will also be loaded into this resourceset. So to find it we need to go in here and try.
-				//
-				// However, if not found we won't go and try to load the resource. That could load in the wrong place.
-				// Kludge: Because of a bug (feature :-)) in XMLHandler.getPackageFromURI(), it doesn't use getResource(...,true) and it tries instead
-				// to use uri inputstream to load the package when not found. This bypasses our special create resource and so
-				// packages are not automatically created. So we need to do load on demand here instead if it is a java protocol.
-				// EMF will not be fixing this. It is working as designed.
-				return getResourceSet().getResource(uri, JavaXMIFactory.SCHEME.equals(uri.scheme()));
-			}
-
-			public Resource createResource(ResourceSet originatingResourceSet, URI uri) {
-				// This is the one. It has got here because it couldn't find a resource already loaded.
-				// If it is a "java:/..." protocol resource, then we want to make sure it is loaded at the BeaninfoNature context
-				// instead of the lower one.
-				if (JavaXMIFactory.SCHEME.equals(uri.scheme()))
-					return getResourceSet().getResource(uri, true);
-				else
-					return null;
-			}
-		});
-		// [71473] Restore "*.java" to be an XMIResource. If EMF Examples are loaded they overload this and load their special resource for "*.java" which we don't want.
-		// If some user really wants that, they grab the resource resource set and remove our override.
-		if (Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().containsKey("java")) { //$NON-NLS-1$
-			// Need to add an override to go to XMI instead.
-			rset.getResourceFactoryRegistry().getExtensionToFactoryMap().put("java", new XMIResourceFactoryImpl()); //$NON-NLS-1$
-		}
-		return rset;
-	}
-	/**
-	 * Clean up, this means either the project is being closed, deleted, or it means that
-	 * the nature is being removed from the project. Either way that means to
-	 * terminate the VM and remove what we added to the context if the flag says clear it.
-	 * <p>
-	 * This should be called ONLY when this instance of the nature is no longer needed. It
-	 * will be recreated for any new uses. That is because we will be removing ourselves
-	 * from the list of active natures in the BeanInfoPlugin.
-	 * <p>
-	 * <b>Note:</b> This will be called from the BeanInfoCacheController. It knows when the project is
-	 * being closed or deleted.
-	 * 
-	 * @param clearResults clear the results such that any JEM model objects have no BeanInfo
-	 * adapters attached to them. This allows BeanInfo to be GC'd without being hung onto.
-	 *  
-	 * @param deregister Deregister from the BeanInfoPlugin. Normally this will always be true, but it
-	 * will be called with false when BeanInfoPlugin is calling back to shutdown.
-	 */
-	public void cleanup(boolean clearResults, boolean deregister) {
-		if (deregister)
-			BeaninfoPlugin.getPlugin().removeBeanInfoNature(this);
-		fSynchronizer.stopSynchronizer(clearResults);
-		Init.cleanup(javaRSet, clearResults);
-		if (fRegistry != null)
-			fRegistry.terminateRegistry(true);
-
-		javaRSet = null;
-		fRegistry = null;
-		fProject = null;
-		fSynchronizer = null;
-	}
-
-	/** 
-	 * Returns the project to which this project nature applies.
-	 *
-	 * @return the project handle
-	 */
-	public IProject getProject() {
-		return fProject;
-	}
-
-	/**
-	 * Sets the project to which this nature applies.
-	 * Used when instantiating this project nature runtime.
-	 * This is called by <code>IProject.addNature</code>
-	 * and should not be called directly by clients.
-	 *
-	 * @param project the project to which this nature applies
-	 */
-	public void setProject(IProject project) {
-//		BeanInfoCacheController.INSTANCE.getClass();	// Instantiates the controller if not already started.
-		fProject = project;
-		BeaninfoPlugin.getPlugin().addBeanInfoNature(this);
-
-		try {
-			// The nature has been started for this project, need to setup the introspection process now.
-			JavaEMFNature javaNature = JavaEMFNature.createRuntime(fProject);
-			JavaInit.init();
-			if (fReflectionKeyExtension == null) {
-				// Register the reflection key extension.
-				fReflectionKeyExtension = new BeaninfoJavaReflectionKeyExtension();
-				JavaXMIFactory.INSTANCE.registerReflectionKeyExtension(fReflectionKeyExtension);
-			}
-
-			javaRSet = javaNature.getResourceSet();
-			Init.initialize(javaRSet, new IBeaninfoSupplier() {
-				public ProxyFactoryRegistry getRegistry() {
-					return BeaninfoNature.this.getRegistry();
-				}
-
-				public boolean isRegistryCreated() {
-					return BeaninfoNature.this.isRegistryCreated();
-				}
-				
-				public void closeRegistry() {
-					BeaninfoNature.this.closeRegistry();
-				}
-				
-				public IProject getProject() {
-					return BeaninfoNature.this.getProject();
-				}
-
-				public ProjectResourceSet getNewResourceSet() {
-					return BeaninfoNature.this.newResourceSet();
-				}
-
-				public ResourceSet getProjectResourceSet() {
-					return getResourceSet();
-				}
-			});
-			fSynchronizer =
-				new BeaninfoModelSynchronizer(
-					(BeaninfoAdapterFactory) EcoreUtil.getAdapterFactory(javaRSet.getAdapterFactories(), IIntrospectionAdapter.ADAPTER_KEY),
-					JavaCore.create(javaNature.getProject()));
-		} catch (CoreException e) {
-			BeaninfoPlugin.getPlugin().getLogger().log(e.getStatus());
-		}
-	}
-
-	/**
-	 * Close the registry. It needs to be recycled because a class has changed
-	 * and now the new class needs to be accessed.
-	 */
-	protected void closeRegistry() {
-		ProxyFactoryRegistry reg = null;
-		synchronized (this) {
-			reg = fRegistry;
-			fRegistry = null;
-			try {
-				// Wipe out the Session properties so that they are recomputed.
-				getProject().setSessionProperty(CONFIG_INFO_SESSION_KEY, null);
-				getProject().setSessionProperty(BEANINFO_CONTRIBUTORS_SESSION_KEY, null);			
-			} catch (CoreException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.INFO);
-			}
-		}
-		if (reg != null) {
-			reg.removeRegistryListener(registryListener);
-			reg.terminateRegistry();
-		}
-	}
-
-	private static final String PI_CLASS = "class"; //$NON-NLS-1$
-	
-	/**
-	 * Using the given configuration info, compute the BeanInfo config info needed. This sets the
-	 * session properties BEANINFO_CONTRIBUTORS_SESSION_KEY and CONFIG_INFO_SESSION_KEY.
-	 * 
-	 * @param info
-	 * @throws CoreException
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void computeBeanInfoConfigInfo(IConfigurationContributionInfo info) throws CoreException {
-		// First time for this nature, or first time after registry reset. Need to compute the info.
-		// It is possible for this to be called BEFORE the first usage of BeanInfo. The editor usually
-		// brings up the editor's registry before it gets anything from BeanInfo.
-		List contributorsList = new ArrayList(10);
-		if (!info.getContainerIds().isEmpty()) {
-			// Run through all of the visible container ids that are applicable and get BeanInfo contributors.
-			Iterator containerIdItr = info.getContainerIds().values().iterator();
-			while (containerIdItr.hasNext()) {
-				ContainerPaths containerPaths = (ContainerPaths) containerIdItr.next();
-				IConfigurationElement[] contributors = BeaninfoPlugin.getPlugin().getContainerIdContributors(containerPaths.getContainerId(), containerPaths.getVisibleContainerPaths());
-				for (int i = 0; i < contributors.length; i++) {
-					try {
-						Object contributor = contributors[i].createExecutableExtension(PI_CLASS);
-						if (contributor instanceof IBeanInfoContributor)
-							contributorsList.add(contributor);
-					} catch (CoreException e) {
-						BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-					}
-				}
-			}						
-		}
-		
-		if (!info.getPluginIds().isEmpty()) {
-			// Run through all of the visible plugin ids that are applicable and get BeanInfo contributors.
-				Iterator pluginIdItr = info.getPluginIds().entrySet().iterator();
-				while (pluginIdItr.hasNext()) {
-					Map.Entry entry = (Map.Entry) pluginIdItr.next();
-					if (((Boolean) entry.getValue()).booleanValue()) {
-						IConfigurationElement[] contributors = BeaninfoPlugin.getPlugin().getPluginContributors(
-								(String) entry.getKey());
-						if (contributors != null) {
-							for (int i = 0; i < contributors.length; i++) {
-							try {
-								Object contributor = contributors[i].createExecutableExtension(PI_CLASS);
-								if (contributor instanceof IBeanInfoContributor)
-									contributorsList.add(contributor);
-							} catch (CoreException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-							}
-						}
-					}
-				}
-			}
-		}
-			
-			// Save it for all beaninfo processing (and configuration processing if they implement proxy configuration contributor).
-		IBeanInfoContributor[] explicitContributors = (IBeanInfoContributor[]) contributorsList.toArray(new IBeanInfoContributor[contributorsList.size()]);
-		info.getJavaProject().getProject().setSessionProperty(BEANINFO_CONTRIBUTORS_SESSION_KEY, explicitContributors);
-		// Save it for override processing. That happens over and over later after all config processing is done.
-		// Do it last so that if there is a race condition, since this property is a flag to indicate we have data,
-		// we need to make sure the Beaninfo data is already set at the point we set this.
-		// We could actually set it twice because of this, but it is the same data, so, so what.
-		info.getJavaProject().getProject().setSessionProperty(CONFIG_INFO_SESSION_KEY, info);
-	}
-
-	/**
-	 * Get registry, creating it if necessary.
-	 * @return the registry.
-	 * 
-	 * @since 1.0.0
-	 */
-	public ProxyFactoryRegistry getRegistry() {
-		synchronized (this) {
-			if (fRegistry != null)
-				return fRegistry;
-		}
-		// Now need to start the appropriate job. In another class so that it can handle dynamically checking if 
-		// UI is available to even do this (it maybe not in a UI mode, so then just do it.
-		CreateRegistryJobHandler.createRegistry(this);
-		return fRegistry;
-	}
-	
-	/*
-	 * This is <package-protected> so that only the appropriate create job in this
-	 * package can call it. This is because this must be controlled to only be
-	 * done when build not in progress and serial access.
-	 */
-	void createRegistry(IProgressMonitor pm) {
-		pm.beginTask(BeanInfoAdapterMessages.UICreateRegistryJobHandler_StartBeaninfoRegistry, 100); 
-		if (isRegistryCreated()) {
-			pm.done();
-			return; // It had already been created. Could of been because threads were racing to do the creation, and one got there first.
-		}
-
-		try {
-			ConfigurationContributor configurationContributor = (ConfigurationContributor) getConfigurationContributor();
-			configurationContributor.setNature(this);
-			ProxyFactoryRegistry registry = ProxyLaunchSupport.startImplementation(fProject, "Beaninfo", //$NON-NLS-1$
-					new IConfigurationContributor[] { configurationContributor}, false, new SubProgressMonitor(pm, 100));
-			registry.addRegistryListener(registryListener);
-			synchronized(this) {
-				fRegistry = registry;
-			}
-		} catch (CoreException e) {
-			BeaninfoPlugin.getPlugin().getLogger().log(e.getStatus());
-		} finally {
-			pm.done();
-		}
-	}
-	
-	public synchronized boolean isRegistryCreated() {
-		return fRegistry != null;
-	}
-	
-	/**
-	 * Check to see if the nature is still valid. If the project has been
-	 * renamed, the nature is still around, but the project has been closed.
-	 * So the nature is now invalid.
-	 * 
-	 * @return Is this a valid nature. I.e. is the project still open.
-	 */
-	public boolean isValidNature() {
-		return fProject != null;
-	}
-
-	/**
-	 * Set the search path onto the registry.
-	 */
-	protected void setProxySearchPath(ProxyFactoryRegistry registry, List searchPaths) {
-		if (searchPaths != null) {
-			String[] stringSearchPath = (String[]) searchPaths.toArray(new String[searchPaths.size()]);
-			Utilities.setBeanInfoSearchPath(registry, stringSearchPath);
-		} else
-			Utilities.setBeanInfoSearchPath(registry, null);
-	}
-
-	private static final String ENCODING = "UTF-8"; //$NON-NLS-1$
-	static final String sBeaninfos = "beaninfos"; // Root element name //$NON-NLS-1$
-	/**
-	 * Get the persistent search path. It is copy.
-	 */
-	public BeaninfosDoc getSearchPath() {
-		BeaninfosDoc bdoc = null;
-		try {
-			InputStream property = getSharedProperty(P_BEANINFO_SEARCH_PATH);
-			if (property != null) {
-				try {
-					// Need to reconstruct from the XML format.
-					Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(new InputStreamReader(property, ENCODING)));
-					Element root = doc.getDocumentElement();
-					if (root != null && root.getNodeName().equalsIgnoreCase(sBeaninfos)) {
-						bdoc = BeaninfosDoc.readEntry(new DOMReader(), root, getProject());
-					}
-				} finally {
-					try {
-						property.close();
-					} catch (IOException e) {
-					}
-				}
-			}
-		} catch (CoreException e) {
-			BeaninfoPlugin.getPlugin().getLogger().log(e.getStatus());
-		} catch (Exception e) {
-			BeaninfoPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0, "", e)); //$NON-NLS-1$
-		}
-		return bdoc;
-	}
-
-	/**
-	 * Set the persistent search path. No progress monitor.
-	 */
-	public void setSearchPath(BeaninfosDoc searchPath) throws CoreException {
-		setSearchPath(searchPath, null);
-	}
-
-	/**
-	 * Set the persistent search path with a progress monitor
-	 */
-	public void setSearchPath(BeaninfosDoc searchPath, IProgressMonitor monitor) throws CoreException {
-		String property = null;
-		if (searchPath != null && searchPath.getSearchpath().length > 0) {
-			try {
-				Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
-				Element root = doc.createElement(sBeaninfos); // Create Root Element
-				IBeaninfosDocEntry[] entries = searchPath.getSearchpath();
-				for (int i = 0; i < entries.length; i++)
-					root.appendChild(entries[i].writeEntry(doc, getProject())); // Add to the search path
-				doc.appendChild(root); // Add Root to Document
-				StringWriter strWriter = new StringWriter();
-
-				Result result = new StreamResult(strWriter);
-				Source source = new DOMSource(doc);
-				Transformer transformer = TransformerFactory.newInstance().newTransformer();
-				transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
-				transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
-				transformer.transform(source, result);
-				property = strWriter.toString();
-			} catch (TransformerConfigurationException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-			} catch (TransformerException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-			} catch (ParserConfigurationException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-			} catch (FactoryConfigurationError e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-			}
-		}
-
-		if (property != null) {
-			// If it hasn't changed, don't write it back out. This is so that if the file hasn't
-			// been checked out and it is the same, we don't want to bother the user. This is because
-			// we don't know if the user had simply browsed the search path or had actually changed and
-			// set it back to what it was. In either of those cases it would be a bother to ask the
-			// user to checkout the file.
-			InputStream is = getSharedProperty(P_BEANINFO_SEARCH_PATH);
-			if (is != null) {
-				try {
-					try {
-						InputStreamReader reader = new InputStreamReader(is, ENCODING);
-						char[] chars = new char[1000];
-						StringBuffer oldProperty = new StringBuffer(1000);
-						int read = reader.read(chars);
-						while (read != -1) {
-							oldProperty.append(chars, 0, read);
-							read = reader.read(chars);
-						}
-						if (oldProperty.toString().equals(property))
-							return;
-					} catch (IOException e) {
-					} // Didn't change.
-				} finally {
-					try {
-						is.close();
-					} catch (IOException e) {
-					}
-				}
-			}
-			setSharedProperty(P_BEANINFO_SEARCH_PATH, property, monitor);
-		} else
-			removeSharedProperty(P_BEANINFO_SEARCH_PATH, monitor);
-	}
-
-	/**
-	 * Return the resource set for all java packages in this nature.
-	 */
-	public ResourceSet getResourceSet() {
-		return javaRSet;
-	}
-
-	protected void markAllStale() {
-		// Mark all stale so that the registry will be recycled.
-		if (fRegistry != null) {
-			// We have a registry running, we need to indicate recycle is needed.
-			fSynchronizer.getAdapterFactory().markAllStale();
-			// Mark all stale. Next time we need anything it will be recycled.
-		}
-	}
-
-	/**
-	 * Compute the file name to use for a given shared property
-	 */
-	protected String computeSharedPropertyFileName(QualifiedName qName) {
-		return qName.getLocalName();
-	}
-
-	/**
-	 * Retrieve a shared property on a project. If the property is not defined, answers null.
-	 * Note that it is orthogonal to IResource persistent properties, and client code has to decide
-	 * which form of storage to use appropriately. Shared properties produce real resource files which
-	 * can be shared through a VCM onto a server. Persistent properties are not shareable.
-	 *
-	 */
-	protected InputStream getSharedProperty(String propertyFileName) throws CoreException {
-		IFile rscFile = getProject().getFile(propertyFileName);
-		if (rscFile.exists())
-			return rscFile.getContents(true);
-		else
-			return null;
-	}
-
-	/**
-	 * Record a shared persistent property onto a project.
-	 * Note that it is orthogonal to IResource persistent properties, and client code has to decide
-	 * which form of storage to use appropriately. Shared properties produce real resource files which
-	 * can be shared through a VCM onto a server. Persistent properties are not shareable.
-	 * 
-	 * shared properties end up in resource files, and thus cannot be modified during
-	 * delta notifications (a CoreException would then be thrown).
-	 * 
-	 */
-	protected void setSharedProperty(String propertyName, String value, IProgressMonitor monitor) throws CoreException {
-
-		try {
-			IFile rscFile = getProject().getFile(propertyName);
-			InputStream input = new ByteArrayInputStream(value.getBytes(ENCODING));
-			// update the resource content
-			if (rscFile.exists()) {
-				rscFile.setContents(input, true, false, null);
-			} else {
-				rscFile.create(input, true, monitor);
-			}
-		} catch (UnsupportedEncodingException e) {
-		}
-	}
-
-	/**
-	 * Remove a shared persistent property onto a project.
-	 * Note that it is orthogonal to IResource persistent properties, and client code has to decide
-	 * which form of storage to use appropriately. Shared properties produce real resource files which
-	 * can be shared through a VCM onto a server. Persistent properties are not shareable.
-	 * 
-	 * shared properties end up in resource files, and thus cannot be modified during
-	 * delta notifications (a CoreException would then be thrown).
-	 * 
-	 */
-	protected void removeSharedProperty(String propertyName, IProgressMonitor monitor) throws CoreException {
-
-		IFile rscFile = getProject().getFile(propertyName);
-		rscFile.delete(true, true, monitor);
-	}
-
-	/**
-	 * Return a configuration contributor that sets up a vm to allow
-	 * introspection. This will make sure the appropriate paths
-	 * are in the classpath to allow access to the beaninfos, and
-	 * it will setup the beaninfo search path for this project.
-	 */
-	public IConfigurationContributor getConfigurationContributor() {
-		return new ConfigurationContributor(getSearchPath());
-	}
-
-	private static class ConfigurationContributor extends ConfigurationContributorAdapter {
-
-		private BeaninfosDoc doc;
-		List computedSearchPath;
-				
-		// The nature. If the nature is not set then this contributor is one
-		// used by some other later proxy registry to get the beaninfo classes into their paths. In that case
-		// we can expect the config info to be in the session variable for our use. Otherwise we will need to
-		// add it here. Also don't set searchpath stuff if not nature because only the beaninfo one will do introspection.
-		private BeaninfoNature nature;	
-		
-		private IConfigurationContributionInfo info;
-		private IBeanInfoContributor[] explicitContributors;
-
-		public ConfigurationContributor(BeaninfosDoc doc) {
-			this.doc = doc;
-		}
-
-		/*
-		 * Set that this is the nature contributor. Not null, means that this is the contributor being
-		 * used to setup the registry for the project's beaninfo nature. null (default) means that this
-		 * is one created to add to some editor's registry.
-		 * 
-		 * Note: This MUST be set before initialize is called or it will not work correctly. If not set, it 
-		 * will be considered not for BeanInfo nature directly.
-		 */
-		public void setNature(BeaninfoNature nature) {
-			this.nature = nature;
-			if (nature != null)
-				computedSearchPath = new ArrayList(3);	// We will be gathering this info.
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributor#initialize(org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo)
-		 */
-		public void initialize(IConfigurationContributionInfo info) {
-			this.info = info;
-			try {
-				if (info.getJavaProject().getProject().getSessionProperty(CONFIG_INFO_SESSION_KEY) == null) {
-					// TODO For now we will rebuild for each time we open a registry, but it actually is only needed if a classpath
-					// changes for some reason. At that point we can get it out of here.
-					
-					computeBeanInfoConfigInfo(info);					
-				} 
-				explicitContributors = (IBeanInfoContributor[]) info.getJavaProject().getProject().getSessionProperty(BEANINFO_CONTRIBUTORS_SESSION_KEY);
-			} catch (CoreException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e);
-			}
-		}
-		
-		public void contributeClasspaths(final IConfigurationContributionController controller) throws CoreException {
-			// Contribute for this project
-			contributeClasspathsForProject(controller, info.getJavaProject().getProject(), doc, true);
-						
-			if (!info.getProjectPaths().isEmpty()) {
-				// Run through all of the visible projects and contribute the classpaths (which come from the BeanInfo docs, if they have any).
-				IWorkspaceRoot root = info.getJavaProject().getProject().getWorkspace().getRoot();
-				Iterator projIter = info.getProjectPaths().entrySet().iterator();
-				while (projIter.hasNext()) {
-					Map.Entry entry = (Map.Entry) projIter.next();
-					if (((Boolean) entry.getValue()).booleanValue()) {
-						IResource res = root.findMember((IPath) entry.getKey());
-						if (res instanceof IProject && ((IProject) res).isOpen() && BeaninfoNature.hasRuntime((IProject) res))
-							contributeClasspathsForProject(controller, (IProject) res, BeaninfoNature.getRuntime((IProject) res)
-									.getSearchPath(), false);
-					}
-				}
-			}			
-			
-			if (!info.getContainerIds().isEmpty()) {
-				// Run through all of the visible container ids that are applicable.
-				Iterator containerIdItr = info.getContainerIds().values().iterator();
-				while (containerIdItr.hasNext()) {
-					ContainerPaths containerPaths = (ContainerPaths) containerIdItr.next();
-					processBeaninfoEntries(BeaninfoPlugin.getPlugin().getContainerIdBeanInfos(containerPaths.getContainerId(), containerPaths.getVisibleContainerPaths()),
-							controller, info.getJavaProject());
-				}
-				
-			}
-			
-			if (!info.getPluginIds().isEmpty()) {
-				// Run through all of the visible plugin ids that are applicable.
-				Iterator pluginIdItr = info.getPluginIds().entrySet().iterator();
-				while (pluginIdItr.hasNext()) {
-					Map.Entry entry = (Map.Entry) pluginIdItr.next();
-					if (((Boolean) entry.getValue()).booleanValue()) {
-						processBeaninfoEntries(BeaninfoPlugin.getPlugin().getPluginBeanInfos((String) entry.getKey()), controller, info.getJavaProject());
-					}
-				}
-				
-			}
-			
-			if (!info.getContainers().isEmpty()) {
-				// Run through all of the visible containers that implement IBeanInfoContributor and ask them for the contributions.
-				Iterator containerItr = info.getContainers().entrySet().iterator();
-				while (containerItr.hasNext()) {
-					Map.Entry entry = (Map.Entry) containerItr.next();
-					if (((Boolean) entry.getValue()).booleanValue()) {
-						if (entry.getKey() instanceof IBeanInfoContributor)
-							processBeaninfoEntries(((IBeanInfoContributor) entry.getKey()).getBeanInfoEntryContributions(info),
-									controller, info.getJavaProject());
-					}
-				}
-				
-			}			
-				
-			// And finally run through the explicit contributors.				
-			for (int i = 0; i < explicitContributors.length; i++) {
-				final IBeanInfoContributor contributor = explicitContributors[i];
-				processBeaninfoEntries(contributor.getBeanInfoEntryContributions(info), controller, info.getJavaProject());
-				if (contributor instanceof IConfigurationContributor) {
-					Platform.run(new ISafeRunnable() {
-						public void handleException(Throwable exception) {
-							// do nothing. by default platform logs.
-						}
-
-						public void run() throws Exception {;
-							if (contributor instanceof IConfigurationContributor)
-								((IConfigurationContributor) contributor).contributeClasspaths(controller);
-						}
-					});
-				}
-			}
-			
-			// Add the common to the end of the classpath. (Since we are now a jarred plugin, the common is not the plugin jar itself).
-			controller.contributeClasspath(BeaninfoPlugin.getPlugin().getBundle(), (IPath) null, IConfigurationContributionController.APPEND_USER_CLASSPATH, false); //$NON-NLS-1$
-			
-			// Add the beaninfovm.jar and any nls to the end of the classpath.
-			controller.contributeClasspath(BeaninfoPlugin.getPlugin().getBundle(), "vm/beaninfovm.jar", IConfigurationContributionController.APPEND_USER_CLASSPATH, true); //$NON-NLS-1$
-		}
-
-		private IClasspathEntry get(IClasspathEntry[] array, SearchpathEntry se) {
-			for (int i = 0; i < array.length; i++) {
-				if (array[i].getEntryKind() == se.getKind() && array[i].getPath().equals(se.getPath()))
-					return array[i];
-			}
-			return null;
-		}
-
-		private static final IBeaninfosDocEntry[] EMPTY_ENTRIES = new IBeaninfosDocEntry[0];
-		
-		/*
-		 * Contribute classpaths for the specified project. If doc is passed in, then this is the top level and
-		 * all should be added. If no doc, then this is pre-req'd project, and then we will handle exported entries only.
-		 */
-		protected void contributeClasspathsForProject(
-			IConfigurationContributionController controller,
-			IProject project,
-			BeaninfosDoc doc,
-			boolean toplevelProject)
-			throws CoreException {
-			
-			IJavaProject jProject = JavaCore.create(project);
-			IClasspathEntry[] rawPath = jProject.getRawClasspath();
-
-			// Search path of this project
-			IBeaninfosDocEntry[] entries = (doc != null) ? doc.getSearchpath() : EMPTY_ENTRIES;
-
-			for (int i = 0; i < entries.length; i++) {
-				IBeaninfosDocEntry entry = entries[i];
-				if (entry instanceof BeaninfoEntry) {
-					BeaninfoEntry be = (BeaninfoEntry) entry;
-					if (toplevelProject || be.isExported()) {
-						// First project or this is an exported beaninfo, so we process it.
-						processBeaninfoEntry(be, controller, jProject);
-					}
-				} else if (nature != null){
-					// Just a search path entry. There is no beaninfo jar to pick up.
-					// We have a nature, so we process search path.
-					SearchpathEntry se = (SearchpathEntry) entry;
-					if (!toplevelProject) {
-						// We are in a nested project, find the raw classpath entry to see
-						// if this entry is exported. Only do it if exported. (Note: exported is only used on non-source. Source are always exported).
-						IClasspathEntry cpe = get(rawPath, se);
-						if (cpe == null || (cpe.getEntryKind() != IClasspathEntry.CPE_SOURCE && !cpe.isExported())) {
-							continue; // Not exist or not exported, so we don't want it here either.
-						}
-					}
-
-					String pkg = se.getPackage();
-					if (pkg != null) {
-						// Explicit search path
-						if (!computedSearchPath.contains(pkg))
-							computedSearchPath.add(pkg);
-					} else {
-						// We no longer allow this, but just to be on safe side we test for it.
-					}
-				}
-			}
-		}
-
-		protected void processBeaninfoEntries(
-			BeaninfoEntry[] entries,
-			IConfigurationContributionController controller,
-			IJavaProject javaProject)
-			throws CoreException {
-			if (entries != null) {
-				for (int i = 0; i < entries.length; i++)
-					processBeaninfoEntry(entries[i], controller, javaProject);
-			}
-		}
-
-		protected void processBeaninfoEntry(
-			BeaninfoEntry entry,
-			IConfigurationContributionController controller,
-			IJavaProject javaProject)
-			throws CoreException {
-			Object[] cps = entry.getClasspath(javaProject);
-			for (int j = 0; j < cps.length; j++) {
-				Object cp = cps[j];
-				if (cp instanceof IProject)
-					controller.contributeProject((IProject) cp);
-				else if (cp instanceof String)
-					controller.contributeClasspath(ProxyLaunchSupport.convertStringPathToURL((String) cp), IConfigurationContributionController.APPEND_USER_CLASSPATH);
-				else if (cp instanceof IPath) {
-					IPath path = (IPath) cp;
-					Bundle bundle = Platform.getBundle(path.segment(0));
-					if (bundle != null)
-						controller.contributeClasspath(bundle, path.removeFirstSegments(1), IConfigurationContributionController.APPEND_USER_CLASSPATH, true);
-				}
-			}
-
-			if (nature != null) {
-				// Now add in the package names.
-				SearchpathEntry[] sees = entry.getSearchPaths();
-				for (int j = 0; j < sees.length; j++) {
-					SearchpathEntry searchpathEntry = sees[j];
-					if (!computedSearchPath.contains(searchpathEntry.getPackage()))
-						computedSearchPath.add(searchpathEntry.getPackage());
-				}
-			}
-		}
-
-		public void contributeToConfiguration(final ILaunchConfigurationWorkingCopy config) {
-			for (int i = 0; i < explicitContributors.length; i++) {
-				final int ii = i;
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// do nothing. by default platform logs.
-					}
-
-					public void run() throws Exception {
-						IBeanInfoContributor contributor = explicitContributors[ii];
-						if (contributor instanceof IConfigurationContributor)
-							((IConfigurationContributor) contributor).contributeToConfiguration(config);
-					}
-				});
-			}			
-		}
-
-		public void contributeToRegistry(final ProxyFactoryRegistry registry) {
-			if (nature != null)
-				nature.setProxySearchPath(registry, computedSearchPath);
-			for (int i = 0; i < explicitContributors.length; i++) {
-				final int ii = i;
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// do nothing. by default platform logs.
-					}
-
-					public void run() throws Exception {
-						IBeanInfoContributor contributor = explicitContributors[ii];
-						if (contributor instanceof IConfigurationContributor)
-							((IConfigurationContributor) contributor).contributeToRegistry(registry);
-					}
-				});
-			}			
-		}
-	}
-
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoProxyConstants.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoProxyConstants.java
deleted file mode 100644
index 05f82b5..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoProxyConstants.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeaninfoProxyConstants.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:31:29 $ 
- */
-package org.eclipse.jem.internal.beaninfo.adapters;
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * This holds the proxy constants for access in beaninfo. It is created on a per-registry basis and stored in the constants section of the registry so
- * that they can be accessed as needed.
- * <p>
- * To gain access to these constants, use the static accessor method "getConstants()" so that the instance is not created until actually needed.
- * 
- * @since 1.0.0
- */
-public final class BeaninfoProxyConstants {
-
-	private static final Object REGISTRY_KEY = new Object();
-
-	private final IMethodProxy introspectProxy;
-
-	private final IMethodProxy getBeanInfoSearchPathProxy;
-
-	private final IMethodProxy setBeanInfoSearchPathProxy;
-
-	private final IMethodProxy sendBeanInfoProxy;
-
-	/**
-	 * Get the constants instance for the specified registry.
-	 */
-	public static BeaninfoProxyConstants getConstants(ProxyFactoryRegistry registry) {
-		BeaninfoProxyConstants constants = (BeaninfoProxyConstants) registry.getConstants(REGISTRY_KEY);
-		if (constants == null)
-			registry.registerConstants(REGISTRY_KEY, constants = new BeaninfoProxyConstants(registry));
-		return constants;
-	}
-
-	private BeaninfoProxyConstants(ProxyFactoryRegistry registry) {
-
-		IStandardBeanTypeProxyFactory typeFactory = registry.getBeanTypeProxyFactory();
-
-		IBeanTypeProxy introspector = typeFactory.getBeanTypeProxy("java.beans.Introspector"); //$NON-NLS-1$
-		getBeanInfoSearchPathProxy = introspector.getMethodProxy("getBeanInfoSearchPath"); //$NON-NLS-1$
-		setBeanInfoSearchPathProxy = introspector.getMethodProxy("setBeanInfoSearchPath", "[Ljava.lang.String;"); //$NON-NLS-1$ //$NON-NLS-2$
-
-		IBeanTypeProxy modelingBeaninfo = typeFactory.getBeanTypeProxy("org.eclipse.jem.internal.beaninfo.vm.ModelingBeanInfo");//$NON-NLS-1$
-		introspectProxy = modelingBeaninfo.getMethodProxy("introspect", new String[] { "java.lang.Class", "boolean", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-
-		sendBeanInfoProxy = modelingBeaninfo.getMethodProxy("send"); //$NON-NLS-1$
-
-	}
-
-	/**
-	 * Get the sendBeanDecorator method proxy from ModelingBeanInfo.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IMethodProxy getSendBeanInfoProxy() {
-		return sendBeanInfoProxy;
-	}
-	
-	/**
-	 * Get the getBeanInfoSearchPath method proxy from Introspector.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public IMethodProxy getGetBeanInfoSearchPathProxy() {
-		return getBeanInfoSearchPathProxy;
-	}
-
-	/**
-	 * Get the setBeanInfoSearchPath method proxy from Introspector.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public IMethodProxy getSetBeanInfoSearchPathProxy() {
-		return setBeanInfoSearchPathProxy;
-	}
-
-	/**
-	 * Get the introspect method proxy from ModelingBeanInfo.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IMethodProxy getIntrospectProxy() {
-		return introspectProxy;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoSuperAdapter.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoSuperAdapter.java
deleted file mode 100644
index 672d8bc..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/BeaninfoSuperAdapter.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: BeaninfoSuperAdapter.java,v $
- *  $Revision: 1.7 $  $Date: 2005/09/14 23:30:38 $ 
- */
-
-import java.util.Collection;
-import java.util.Iterator;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.common.notify.impl.AdapterImpl;
-import org.eclipse.emf.ecore.impl.ESuperAdapter;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.internal.impl.JavaClassImpl;
-
-/**
- * Used to know when events or any of the super classes change so
- * that we can re-construct our all events list next time we need it.
- * @version 	1.0
- * @author
- */
-public class BeaninfoSuperAdapter extends AdapterImpl {
-
-	public static final Class ADAPTER_KEY = BeaninfoSuperAdapter.class;
-
-	private boolean allEventsCollectionModified = true;
-	private boolean allPropertiesCollectionModified = true;
-	private boolean allOperationsCollectionModified = true;
-
-	public BeaninfoSuperAdapter() {
-		super();
-	}
-
-	public void notifyChanged(Notification msg) {
-		if (msg.getEventType() != Notification.REMOVING_ADAPTER)
-			setFlags(msg.getFeatureID(JavaClass.class));
-	}
-
-	public boolean isAllEventsCollectionModified() {
-		return allEventsCollectionModified;
-	}
-
-	public void setAllEventsCollectionModified(boolean newEventsModified) {
-		allEventsCollectionModified = newEventsModified;
-	}
-
-	public boolean isAllOperationsCollectionModified() {
-		return allOperationsCollectionModified;
-	}
-
-	public void setAllOperationsCollectionModified(boolean newOperationsModified) {
-		allOperationsCollectionModified = newOperationsModified;
-	}
-	
-	public void setAllPropertiesCollectionModified(boolean allPropertiesCollectionModified) {
-		this.allPropertiesCollectionModified = allPropertiesCollectionModified;
-	}
-
-	public boolean isAllPropertiesCollectionModified() {
-		return allPropertiesCollectionModified;
-	}
-	
-	public Collection getSubclasses() {
-		// Get them from the ESuperAdapter. Easiest to do.
-		ESuperAdapter ea = ((JavaClassImpl) getTarget()).getESuperAdapter();
-		return ea.getSubclasses();
-	}
-
-	public boolean isAdapterForType(Object type) {
-		return ADAPTER_KEY.equals(type);
-	}
-
-	void setFlags(int featureId) {
-		switch (featureId) {
-			case JavaRefPackage.JAVA_CLASS__EVENTS :
-				setAllEventsCollectionModified(true);
-				break;
-				
-			case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-				setAllOperationsCollectionModified(true);
-				break;
-
-			case JavaRefPackage.JAVA_CLASS__ESUPER_TYPES:
-				setAllEventsCollectionModified(true);
-				setAllPropertiesCollectionModified(true);
-				break;				
-				
-			case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-				setAllPropertiesCollectionModified(true);
-				break;
-				
-			default :
-				break;
-		}
-		Iterator i = getSubclasses().iterator();
-		while (i.hasNext()) {
-			Notifier n = (Notifier) i.next();
-			BeaninfoSuperAdapter a = (BeaninfoSuperAdapter) EcoreUtil.getExistingAdapter(n, ADAPTER_KEY);
-			if (a != null)
-				a.setFlags(featureId);
-		}
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/CreateRegistryJobHandler.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/CreateRegistryJobHandler.java
deleted file mode 100644
index a676113..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/CreateRegistryJobHandler.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: CreateRegistryJobHandler.java,v $
- *  $Revision: 1.14 $  $Date: 2005/08/24 20:31:29 $ 
- */
-package org.eclipse.jem.internal.beaninfo.adapters;
-
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.*;
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin;
-import org.eclipse.jem.util.logger.proxy.Logger;
-
- 
-
-/**
- * This class is used by BeaninfoNature to handle the creation of the registry,
- * This class will be a singleton. It is needed to handle if UI active without
- * requiring UI plugin. (So headless will work too). The subclass <code>UICreateRegistryJobHandler</code>
- * will be instantiated in case of UI active.
- * @since 1.0.0
- */
-class CreateRegistryJobHandler {
-	private static CreateRegistryJobHandler jobHandler = null;
-	
-	public static void createRegistry(BeaninfoNature nature) {
-		synchronized (CreateRegistryJobHandler.class) {
-			if (jobHandler == null) {
-				if (Platform.getBundle("org.eclipse.ui") != null) {	//$NON-NLS-1$
-					try {
-						// There is a UI, it may not be active, but bring in UICreateRegistryJobHandler to do the
-						// actual work since it can reference the UI.
-						jobHandler = (CreateRegistryJobHandler) Class.forName("org.eclipse.jem.internal.beaninfo.adapters.UICreateRegistryJobHandler").newInstance(); //$NON-NLS-1$
-					} catch (InstantiationException e) {
-						jobHandler = new CreateRegistryJobHandler();
-					} catch (IllegalAccessException e) {
-						jobHandler = new CreateRegistryJobHandler();
-					} catch (ClassNotFoundException e) {
-						jobHandler = new CreateRegistryJobHandler();
-					}
-				}
-			}
-		}
-		
-		// See if Autobuild sleeping or waiting. This could be a race condition for us. We can't wait for it
-		// because we may already have the build rule locked by our thread. No way of testing this if beginRule was used.
-		// We can test if we are a build job (not an inline build), and if so, just go on.
-		// Maybe we can figure out in future if we find race condition happens significant amount of time.
-		IJobManager jobManager = Platform.getJobManager();
-		Job currentJob = jobManager.currentJob();
-		if (currentJob == null || (!currentJob.belongsTo(ResourcesPlugin.FAMILY_AUTO_BUILD) && !currentJob.belongsTo(ResourcesPlugin.FAMILY_MANUAL_BUILD))) {
-			// See if autojob is waiting or sleeping.
-			// Give it up to a second at .2 second intervals to try (i.e. 5 tries)
-			int tries = 5;
-			while (isAutoWaiting() && --tries>0) {
-				try {
-					Thread.sleep(200);	// Wait just .2 seconds to give build a chance to start. If it is still not started, then just go on.
-				} catch (InterruptedException e) {
-				}
-			}
-			if (tries==0) {
-				Logger logger = BeaninfoPlugin.getPlugin().getLogger();
-				if (logger.isLoggingLevel(Level.WARNING))
-					logger.log("Build job waiting when trying to start beaninfo registry. Possible race.", Level.WARNING);	// $NON-NLS-1$ //$NON-NLS-1$
-			}
-		}
-		
-		jobHandler.processCreateRegistry(nature);
-	}
-
-	private static boolean isAutoWaiting() {
-		Job[] autojobs = Platform.getJobManager().find(ResourcesPlugin.FAMILY_AUTO_BUILD);
-		for (int i = 0; i < autojobs.length; i++) {
-			int state = autojobs[i].getState();
-			if (state == Job.WAITING || state == Job.SLEEPING) 
-				return true;
-		}
-		return false;
-	}
-
-	
-	/**
-	 * Process the create of the registry. This should be overridden to
-	 * do what the UI needs. The UI implimentation should call doCreateRegistry at the
-	 * appropriate time.
-	 * 
-	 * @param nature
-	 * 
-	 * @since 1.0.0
-	 */
-	protected void processCreateRegistry(final BeaninfoNature nature) {
-		IJobManager jobManager = Platform.getJobManager();
-		ISchedulingRule buildRule = ResourcesPlugin.getWorkspace().getRuleFactory().buildRule();
-		boolean gotRuleLocally = true;
-		try {
-			try {
-				jobManager.beginRule(buildRule, new NullProgressMonitor());
-			} catch (IllegalArgumentException e) {
-				gotRuleLocally = false;	// This thread already had a rule, and it conflicted with the build rule, so we need to spawn off.
-			}
-			if (gotRuleLocally)
-				doCreateRegistry(nature, new NullProgressMonitor());
-		} finally {
-			jobManager.endRule(buildRule);	// Whether we got the rule or not, we must do endrule.
-		}
-		
-		if (!gotRuleLocally) {
-			// Spawn off to a job and wait for it. Hopefully we don't have a deadlock somewhere.
-			Job doCreateJob = new Job(BeanInfoAdapterMessages.UICreateRegistryJobHandler_StartBeaninfoRegistry) { 
-
-				protected IStatus run(IProgressMonitor monitor) {
-					doCreateRegistry(nature, monitor);
-					return Status.OK_STATUS;
-				}
-			};
-			doCreateJob.schedule();
-			while (true) {
-				try {
-					doCreateJob.join();
-					break;
-				} catch (InterruptedException e) {
-				}
-			}
-		}
-	}
-		
-	/*
-	 * Do the creation. It is expected that the build rule has already been given to this thread.
-	 * It is important that the build rule be given to this thread. This is so that a build won't
-	 * start trying to create the same registry (which has happened in the past) at the same time
-	 * a different thread was trying to start the registry. You would either have a deadlock, or 
-	 * a race and get two different registries started.
-	 * 
-	 * The build rule also means that all beaninfo registry creations will be serialized and have
-	 * a race condition. The unfortunate part is that two independent project's registries can't be
-	 * created at same time. But that is the result of the build rule. We can't allow the builds, so
-	 * we need to stop all parallel beaninfo registry creations.
-	 * 
-	 * @param nature
-	 * @param pm
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final void doCreateRegistry(BeaninfoNature nature, IProgressMonitor pm) {
-		pm.beginTask("", 100);	//$NON-NLS-1$
-		try {
-			nature.createRegistry(new SubProgressMonitor(pm, 100));	
-		} finally {
-			pm.done();
-		}
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/DOMReader.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/DOMReader.java
deleted file mode 100644
index 9f87753..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/DOMReader.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: DOMReader.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
-
-
-/**
- * The internal class for reading dom elements.
- * @version 	1.0
- * @author
- */
-class DOMReader implements IReader {
-	
-	/*
-	 * @see IReader#getChildren(Object)
-	 */
-	public Object getChildren(Object node) {
-		return (node instanceof Node) ? ((Node) node).getChildNodes() : null;
-	}
-	
-	
-	/*
-	 * @see IReader#getLength(Object)
-	 */
-	public int getLength(Object nodeList) {
-		return (nodeList instanceof NodeList) ? ((NodeList) nodeList).getLength() : 0;
-	}
-
-	/*
-	 * @see IReader#getItem(Object, int)
-	 */
-	public Object getItem(Object nodeList, int index) {
-		return (nodeList instanceof NodeList) ? ((NodeList) nodeList).item(index) : null;
-	}
-
-	/*
-	 * @see IReader#isNodeTypeElement(Object)
-	 */
-	public boolean isNodeTypeElement(Object node) {
-		return (node instanceof Node) ? ((Node) node).getNodeType() == Node.ELEMENT_NODE : false;
-	}
-
-	/*
-	 * @see IReader#getNodeName(Object)
-	 */
-	public String getNodeName(Object node) {
-		return (node instanceof Node) ? ((Node) node).getNodeName() : ""; //$NON-NLS-1$
-	}
-
-	/*
-	 * @see IReader#getAttribute(Object, String)
-	 */
-	public String getAttribute(Object element, String attributeName) {
-		return (element instanceof Element) && ((Element) element).hasAttribute(attributeName) ? ((Element) element).getAttribute(attributeName) : null;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/IReader.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/IReader.java
deleted file mode 100644
index ed6bf67..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/IReader.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: IReader.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:31:29 $ 
- */
-/**
- * This is internal interface for reading beaninfoConfig either through IConfigurationElements or
- * w3.dom.Nodes. This is because when reading the .beaninfoConfig we will be using Nodes, but
- * when reading configs from registered extensions they will be IConfigurationElements.
- * @version 	1.0
- * TODO Need to move to core when we make things API.
- */
-public interface IReader {
-	
-	public Object getChildren(Object node);
-	public int getLength(Object nodeList);
-	public Object getItem(Object nodeList, int index);
-	public boolean isNodeTypeElement(Object node);	// Is this an element type node
-	public String getNodeName(Object node);
-	public String getAttribute(Object element, String attributeName);
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/SpecialResourceSet.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/SpecialResourceSet.java
deleted file mode 100644
index 8b291be..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/SpecialResourceSet.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.adapters;
-/*
- *  $RCSfile: SpecialResourceSet.java,v $
- *  $Revision: 1.9 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import org.eclipse.jem.internal.util.emf.workbench.ProjectResourceSetImpl;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
-
-
-/**
- * A Special resource set that is used to link together to the beaninfo
- * nature's resource set and makes sure that any request for a new "java:/..."
- * JavaClass is redirected to the beaninfo nature's resource set. Otherwise
- * the classes will be all over the place and not all gathered in one place.
- * 
- * *package* protected because no one should create one of these. They are
- * returned by the BeaninfoNature.newResourceSet() request.
- * 
- * @version 	1.0
- * @author
- */
-class SpecialResourceSet extends ProjectResourceSetImpl {
-
-	/**
-	 * Constructor for SpecialResourceSet.
-	 * @param aProject
-	 */
-	public SpecialResourceSet() {
-		super(null);
-		JEMUtilPlugin.getSharedCache().stopListening(this);	// We don't care about listening.
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/UICreateRegistryJobHandler.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/UICreateRegistryJobHandler.java
deleted file mode 100644
index 4b1548e..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/UICreateRegistryJobHandler.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: UICreateRegistryJobHandler.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:29 $ 
- */
-package org.eclipse.jem.internal.beaninfo.adapters;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.IJobManager;
-import org.eclipse.core.runtime.jobs.ISchedulingRule;
-import org.eclipse.jface.operation.IRunnableWithProgress;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.progress.IProgressService;
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin;
- 
-
-/**
- * This is the version which can actually reference and use the UI classes. It won't be
- * loaded except if ui plugin is available.
- * 
- * It will check to see if UI is running, and if it is not, then let super class handle.
- * If it is running, then if this is the UI thread, do special but run in ui, else if not then
- * let super handle it normally.
- * 
- * @since 1.0.0
- */
-class UICreateRegistryJobHandler extends CreateRegistryJobHandler {
-	
-	
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.beaninfo.adapters.CreateRegistryJobHandler#processCreateRegistry(org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature)
-	 */
-	protected void processCreateRegistry(final BeaninfoNature nature) {
-		if (PlatformUI.isWorkbenchRunning()) {
-			if (Display.getCurrent() == null)
-				super.processCreateRegistry(nature);	// We are not in the UI thread. Do normal.
-			else {
-				// We are in the UI, so try to run in UI. Really don't want to do this, but we need to
-				// get the build rule, and no way to know if the UI thread already has the build rule.
-				// It would be nice to spawn off thread to do it, but if we had the build rule we couldn't
-				// get it for the spawned thread. So hopefully it won't be long.
-				IProgressService ps = PlatformUI.getWorkbench().getProgressService();				
-				final ISchedulingRule buildRule = ResourcesPlugin.getWorkspace().getRuleFactory().buildRule();
-
-// TODO Note: For now, runInUI is just way too annoying. It always flashes up. It is supposed to only flash up
-// when it is blocked by the rule. I've opened 66683 to address this. I've also opened 66690 to be able
-// to test if the thread has the rule so that runInUI will only be used if UI thread had the rule.
-// For now take the risk that the UI thread won't ever have the rule. This is pretty likely to be true.
-//				final boolean[] gotRuleLocally = new boolean[] {false};				
-//				try {
-//					ps.runInUI(ps, new IRunnableWithProgress() {
-//
-//						public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
-//							gotRuleLocally[0] = true;
-//							doCreateRegistry(nature, new NullProgressMonitor());
-//						}
-//					}, buildRule);
-//				} catch (InvocationTargetException e) {
-//					if (e.getCause() instanceof IllegalArgumentException && !gotRuleLocally[0]) { 
-//						// Error was because rule conflicted with currect rules for this thread. So do in separate thread, should be able to get rule there.
-						try {
-							ps.busyCursorWhile(new IRunnableWithProgress() {
-
-								public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
-									IJobManager jm = Platform.getJobManager();
-									monitor.beginTask("", 200); //$NON-NLS-1$
-									try {
-										jm.beginRule(buildRule, new SubProgressMonitor(monitor, 100));
-										doCreateRegistry(nature, new SubProgressMonitor(monitor, 100));
-									} finally {
-										jm.endRule(buildRule);
-										monitor.done();
-									}
-								}
-							});
-						} catch (InterruptedException e1) {
-						} catch (InvocationTargetException e2) {
-							BeaninfoPlugin.getPlugin().getLogger().log(e2.getCause(), Level.WARNING);
-						}
-//					} else
-//						BeaninfoPlugin.getPlugin().getLogger().log(e.getCause(), Level.WARNING);						
-//				} catch (InterruptedException e) {
-//				}
-			}
-		} else
-			super.processCreateRegistry(nature);	// Workbench not running, do default.
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/messages.properties b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/messages.properties
deleted file mode 100644
index 79ff64c..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/messages.properties
+++ /dev/null
@@ -1,19 +0,0 @@
-###############################################################################
-# Copyright (c) 2004, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/adapters/messages.properties,v $
-# $Revision: 1.6 $  $Date: 2005/08/24 20:31:29 $
-#
-
-INTROSPECT_FAILED_EXC_                           = IWAV0155E Introspection failed on class "{0}." msg="{1}."
-BeaninfoClassAdapter_ClassNotFound               = Class not found
-BeaninfoNature_InvalidProject                    = Invalid project
-UICreateRegistryJobHandler_StartBeaninfoRegistry = Start Beaninfo registry
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeanInfoCacheController.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeanInfoCacheController.java
deleted file mode 100644
index 6bd29a2..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeanInfoCacheController.java
+++ /dev/null
@@ -1,1602 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeanInfoCacheController.java,v $
- *  $Revision: 1.16 $  $Date: 2005/09/13 20:30:46 $ 
- */
-package org.eclipse.jem.internal.beaninfo.core;
-
-import java.io.*;
-import java.util.*;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.emf.common.notify.*;
-import org.eclipse.emf.common.notify.impl.AdapterImpl;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.change.ChangeDescription;
-import org.eclipse.emf.ecore.change.impl.EObjectToChangesMapEntryImpl;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.xmi.XMLResource;
-import org.eclipse.jdt.core.*;
-
-import org.eclipse.jem.internal.beaninfo.adapters.*;
-import org.eclipse.jem.internal.java.beaninfo.IIntrospectionAdapter;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.util.emf.workbench.ProjectResourceSet;
-import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin.CleanResourceChangeListener;
-
-/**
- * Controller of the BeanInfo cache. There is one per workspace (it is a static).
- * 
- * The cache is stored on a per IPackageFragmentRoot basis. Each package fragment root will be:
- * 
- * <pre>
- * 
- *  root{999}/classname.xmi
- *  
- * </pre>
- * 
- * "root{999}" will be a unigue name (root appended with a number}, one for each package fragment root. The "classname.xmi" will be the BeanInfo cache
- * for a class in the root. A root can't have more than one class with the same name, so there shouldn't be any collisions.
- * <p>
- * Now roots can either be in a project, or they can be an external jar (which can be shared between projects).
- * <p>
- * Now all roots for a project will be stored in the project's working location
- * {@link org.eclipse.core.resources.IProject#getWorkingLocation(java.lang.String)}under the ".cache" directory. It will be this format in each
- * project location (under the org.eclipse.jem.beaninfo directory):
- * 
- * <pre>
- * 
- *  .index
- *  root{999}/...
- *  
- * </pre>
- * 
- * The ".index" file will be stored/loaded through an ObjectStream. It will be a {@link BeanInfoCacheController.Index}. It is the index to all of the
- * root's in the directory.
- * <p>
- * All of the external jar roots will be stored in the org.eclipse.jem.beaninfo plugin's state location
- * {@link org.eclipse.core.runtime.Platform#getStateLocation(org.osgi.framework.Bundle)}under the ".cache" directory. The format of this directory
- * will be the same as for each project. And the roots will be for each unique shared external jar (such as the differnt jre's rt.jars).
- * <p>
- * Note: There are so many places where synchronization is needed, so it is decided to synchronize only on BeanInfoCacheController.INSTANCE. It would
- * be too easy to get a dead-lock because the order of synchronizations can't be easily controlled. Since each piece of sync control is very short
- * (except for save of the indices, but that is ok because we don't want them changing while saving) it shouldn't block a lot. There is one place we
- * violate this and that is we do a sync on ClassEntry instance when working with the pending. This is necessary because we don't want the cache write
- * job to hold up everything while writing, so we sync on the entry being written instead. There we must be very careful that we never to
- * BeanInfoCacheControler.INSTANCE sync and then a ClassEntry sync because we could deadlock. The CE access under the covers may do a CE sync and then
- * a BeanInfoCacheController.INSTANCE sync.
- * 
- * @since 1.1.0
- */
-public class BeanInfoCacheController {
-
-	/**
-	 * Singleton cache controller.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final BeanInfoCacheController INSTANCE = new BeanInfoCacheController();
-
-	private BeanInfoCacheController() {
-		// Start up save participent. This only is used for saving indexes and shutdown. Currently the saved state delta
-		// is of no interest. If a project is deleted while we were not up, then the project index would be gone, so
-		// our data will automatically be gone for the project. 
-		// If a class was deleted while the project's beaninfo was not active, the cache will still contain it. If the class ever came back it
-		// would be stale and so recreated. If it never comes back, until a clean is done, it would just hang around.
-		// The problem with delete is it is hard to determine that the file is actually a class of interest. The javamodel
-		// handles that for us but we won't have a javamodel to handle this on start up to tell us the file was a class of interest. So
-		// we'll take the hit of possible cache for non-existant classes. A clean will take care of this.
-		saveParticipant = new SaveParticipant();
-		try {
-			ResourcesPlugin.getWorkspace().addSaveParticipant(BeaninfoPlugin.getPlugin(), saveParticipant);
-		} catch (CoreException e) {
-			BeaninfoPlugin.getPlugin().getLogger().log(e.getStatus());
-		}
-		
-		// Create a cleanup listener to handle clean requests and project deletes. We need to know about project deletes while
-		// active because we may have a project index in memory and that needs to be thrown away.
-		JEMUtilPlugin.addCleanResourceChangeListener(new CleanResourceChangeListener() {
-		
-			protected void cleanProject(IProject project) {
-				// Get rid of the project index and the data for the project.
-				synchronized (BeanInfoCacheController.this) {
-					try {
-						Index projectIndex = (Index) project.getSessionProperty(PROJECT_INDEX_KEY);
-						if (projectIndex != null) {
-							project.setSessionProperty(PROJECT_INDEX_KEY, null);
-							projectIndex.markDead();
-							cleanDirectory(getCacheDir(project).toFile(), true);
-						}
-						BeaninfoNature nature = BeaninfoPlugin.getPlugin().getNature(project);
-						if (nature != null) {
-							BeaninfoAdapterFactory adapterFactory = (BeaninfoAdapterFactory) EcoreUtil.getAdapterFactory(nature.getResourceSet().getAdapterFactories(), IIntrospectionAdapter.ADAPTER_KEY);
-							if (adapterFactory != null) {
-								adapterFactory.markAllStale(true);	// Also clear the overrides.
-							}
-						}						
-					} catch (CoreException e) {
-						// Shouldn't occur. 
-					}
-				}
-			}
-			
-			protected void cleanAll() {
-				synchronized(BeanInfoCacheController.this) {
-					// Get MAIN_INDEX, mark it dead, and then delete everything under it.
-					if (MAIN_INDEX != null) {
-						MAIN_INDEX.markDead();
-						MAIN_INDEX = null;
-						cleanDirectory(getCacheDir(null).toFile(), true);
-					}
-				}
-				super.cleanAll();
-			}
-			
-			public void resourceChanged(IResourceChangeEvent event) {
-				// We don't need to handle PRE_CLOSE because SaveParticipent project save will handle closing.
-				switch (event.getType()) {
-					case IResourceChangeEvent.PRE_DELETE:
-						// Don't need to clear the cache directory because Eclipse will get rid of it.
-						synchronized (BeanInfoCacheController.this) {
-							try {
-								Index projectIndex = (Index) event.getResource().getSessionProperty(PROJECT_INDEX_KEY);
-								if (projectIndex != null) {
-									// No need to remove from the project because the project is going away and will clean itself up.
-									projectIndex.markDead();
-								}
-							} catch (CoreException e) {
-								// Shouldn't occur.
-							}
-						}
-						// Flow into PRE_CLOSE to release the nature.
-					case IResourceChangeEvent.PRE_CLOSE:
-						// About to close or delete, so release the nature, if any.
-						IProject project = (IProject) event.getResource();
-						BeaninfoNature nature = BeaninfoPlugin.getPlugin().getNature(project);
-						if (nature != null) {
-							nature.cleanup(false, true);
-						}
-						break;
-					default:
-						super.resourceChanged(event);
-						break;
-				}
-			}
-		
-		}, IResourceChangeEvent.PRE_DELETE | IResourceChangeEvent.PRE_CLOSE);
-	}
-
-	protected SaveParticipant saveParticipant;
-
-	/**
-	 * An index structure for the Main and Project indexes. Access to the index contents and methods should synchronize on the index itself.
-	 * <p>
-	 * Getting to the index instance should only be through the <code>getMainIndex()</code> and <code>getProjectIndex(IProject)</code> accessors
-	 * so that synchronization and serialization is controlled.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static class Index implements Serializable {
-
-		private static final long serialVersionUID = 1106864425423L;
-
-		/*
-		 * Is this a dirty index, i.e. it has been changed and needs to be saved.
-		 */
-		transient private boolean dirty;
-
-		private static final int DEAD = -1;	// Used in highRootNumber to indicate the index is dead.
-		/**
-		 * The highest root number used. It is incremented everytime one is needed. It doesn't ever decrease to recover removed roots.
-		 * 
-		 * @since 1.1.0
-		 */
-		public int highRootNumber;
-
-		/**
-		 * Map of root names to the root Index. The key is a {@link IPath}. The path will be relative to the workspace if a project root, or an
-		 * absolute local path to the archive if it is an external archive. It is the IPath to package fragment root (either a folder or a jar file).
-		 * <p>
-		 * The value will be a {@link BeanInfoCacheController.RootIndex}. This is the index for the contents of that root.
-		 * 
-		 * @since 1.1.0
-		 */
-		transient public Map rootToRootIndex;
-
-		/**
-		 * @param dirty
-		 *            The dirty to set.
-		 * 
-		 * @since 1.1.0
-		 */
-		public void setDirty(boolean dirty) {
-			synchronized (BeanInfoCacheController.INSTANCE) {
-				this.dirty = dirty;
-			}
-		}
-
-		/**
-		 * @return Returns the dirty.
-		 * 
-		 * @since 1.1.0
-		 */
-		public boolean isDirty() {
-			synchronized (BeanInfoCacheController.INSTANCE) {
-				return dirty;
-			}
-		}
-		
-		/**
-		 * Answer if this index is dead. It is dead if a clean has occurred. This is needed because there could be some ClassEntry's still
-		 * around (such as in the pending write queue) that are for cleaned roots. This is used to test if it has been cleaned.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public boolean isDead() {
-			return highRootNumber == DEAD;
-		}
-		
-		/**
-		 * Mark the index as dead.
-		 * 
-		 * 
-		 * @since 1.1.0
-		 */
-		void markDead() {
-			highRootNumber = DEAD;
-		}
-
-		private void writeObject(ObjectOutputStream os) throws IOException {
-			os.defaultWriteObject();
-			// Now write out the root to root index map. We are not serializing the Map directly using normal Map serialization because
-			// the key of the map is an IPath (which is a Path under the covers) and Path is not serializable.
-			os.writeInt(rootToRootIndex.size());
-			for (Iterator mapItr = rootToRootIndex.entrySet().iterator(); mapItr.hasNext();) {
-				Map.Entry entry = (Map.Entry) mapItr.next();
-				os.writeUTF(((IPath) entry.getKey()).toString());
-				os.writeObject(entry.getValue());
-			}
-		}
-
-		private void readObject(ObjectInputStream is) throws IOException, ClassNotFoundException {
-			is.defaultReadObject();
-			int size = is.readInt();
-			rootToRootIndex = new HashMap(size < 100 ? 100 : size);
-			while (size-- > 0) {
-				rootToRootIndex.put(new Path(is.readUTF()), is.readObject());
-			}
-		}
-	}
-
-	/**
-	 * An index for a root. It has an entry for each class in this root. The class cache entry describes the cache, whether it is stale, what the
-	 * current mod stamp is, etc.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static abstract class RootIndex implements Serializable {
-
-		private static final long serialVersionUID = 1106868674867L;
-
-		transient private IPath cachePath; // Absolute local filesystem IPath to the root cache directory. Computed at runtime because it may change
-										   // if workspace relocated.
-
-		protected Map classNameToClassEntry; // Map of class names to class entries.
-
-		private String rootName; // Name of the root directory in the cache (e.g. "root1").
-
-		protected Index index; // Index containing this root index.
-
-		protected RootIndex() {
-		}
-
-		public RootIndex(String rootName, Index index) {
-			this.rootName = rootName;
-			classNameToClassEntry = new HashMap(100); // When created brand new, put in a map. Otherwise object stream will create the map.
-			this.index = index;
-		}
-		
-		/**
-		 * Get the index that points to this root.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		Index getIndex() {
-			return index;
-		}
-
-		/**
-		 * Return the root directory name
-		 * 
-		 * @return rootname
-		 * 
-		 * @since 1.1.0
-		 */
-		public String getRootName() {
-			return rootName;
-		}
-
-		/**
-		 * Set this RootIndex (and the containing Index) as being dirty and in need of saving.
-		 * 
-		 * 
-		 * @since 1.1.0
-		 */
-		public void setDirty() {
-			index.setDirty(true);
-		}
-
-		/*
-		 * Setup for index. It will initialize the path. Once set it won't set it again. This will be called repeatedly by the cache controller
-		 * because there is no way to know if it was lazily created or was brought in from file. When brought in from file the path is not set because
-		 * it should be relocatable and we don't want absolute paths out on the disk caches, and we don't want to waste time creating the path at load
-		 * time because it may not be needed for a while. So it will be lazily created. <p> If the project is set, then the path will be relative to
-		 * the project's working location. If project is <code> null </code> then it will be relative to the BeanInfo plugin's state location. <p>
-		 * This is <package-protected> because only the creator (BeanInfoCacheController class) should set this up.
-		 * 
-		 * @param project
-		 * 
-		 * @since 1.1.0
-		 */
-		void setupIndex(IProject project) {
-			if (getCachePath() == null)
-				cachePath = getCacheDir(project).append(rootName);
-		}
-
-		/**
-		 * @return Returns the path of the cache directory for the root.
-		 * 
-		 * @since 1.1.0
-		 */
-		public IPath getCachePath() {
-			return cachePath;
-		}
-
-		/**
-		 * Return whether this is a root for a archive or a folder.
-		 * 
-		 * @return <code>true</code> if archive for a root. <code>false</code> if archive for a folder.
-		 * 
-		 * @since 1.1.0
-		 */
-		public abstract boolean isArchiveRoot();
-	}
-
-	/**
-	 * A root index that is for an archive, either internal or external. It contains the archive's modification stamp. Each class cache entry will
-	 * have this same modification stamp. If the archive is changed then all of the class cache entries will be removed because they are all possibly
-	 * stale. No way to know which may be stale and which not.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static class ArchiveRootIndex extends RootIndex {
-
-		private static final long serialVersionUID = 110686867456L;
-
-		private long archiveModificationStamp;
-
-		/*
-		 * For serializer to call.
-		 */
-		protected ArchiveRootIndex() {
-		}
-
-		public ArchiveRootIndex(String rootName, long archiveModificationStamp, Index index) {
-			super(rootName, index);
-			this.archiveModificationStamp = archiveModificationStamp;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jem.internal.beaninfo.core.BeanInfoCacheController.RootIndex#isArchiveRoot()
-		 */
-		public boolean isArchiveRoot() {
-			return true;
-		}
-
-		/*
-		 * Set the modification stamp. <p> <package-protected> because only the cache controller should change it.
-		 * 
-		 * @param archiveModificationStamp The archiveModificationStamp to set.
-		 * 
-		 * @see BeanInfoCacheController#MODIFICATION_STAMP_STALE
-		 * @since 1.1.0
-		 */
-		void setArchiveModificationStamp(long archiveModificationStamp) {
-			this.archiveModificationStamp = archiveModificationStamp;
-			setDirty();
-		}
-
-		/**
-		 * Returns the modification stamp.
-		 * 
-		 * @return Returns the archiveModificationStamp.
-		 * @see BeanInfoCacheController#MODIFICATION_STAMP_STALE
-		 * @since 1.1.0
-		 */
-		public long getArchiveModificationStamp() {
-			return archiveModificationStamp;
-		}
-	}
-
-	/**
-	 * This is a root index for a folder (which will be in the workspace). Each class cache entry can have a different modification stamp with a
-	 * folder root index.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static class FolderRootIndex extends RootIndex {
-
-		private static final long serialVersionUID = 1106868674834L;
-
-		/*
-		 * For serialization.
-		 */
-		protected FolderRootIndex() {
-		}
-
-		/**
-		 * @param rootName
-		 * 
-		 * @since 1.1.0
-		 */
-		public FolderRootIndex(String rootName, Index index) {
-			super(rootName, index);
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jem.internal.beaninfo.core.BeanInfoCacheController.RootIndex#isArchiveRoot()
-		 */
-		public boolean isArchiveRoot() {
-			return false;
-		}
-	}
-
-	/**
-	 * An individual class entry from the cache. It has an entry for each class in the root. The class cache entry describes the cache, whether it is
-	 * stale, what the current mod stamp is, etc.
-	 * <p>
-	 * There is a method to call to see if deleted. This should only be called if entry is being held on to because
-	 * <code>getClassEntry(JavaClass)</code> will never return a deleted entry. There is a method to get the modification stamp of the current cache
-	 * entry. This is the time stamp of the cooresponding class resource (or archive file) that the cache file was created from. If the value is
-	 * <code>IResource.NULL_STAMP</code>, then the cache file is known to be stale. Otherwise if the value is less than a modification stamp of a
-	 * super class then the cache file is stale.
-	 * 
-	 * @see ClassEntry#isDeleted()
-	 * @see ClassEntry#getModificationStamp()
-	 * @see BeanInfoCacheController#getClassEntry(JavaClass)
-	 * @since 1.1.0
-	 */
-	public static class ClassEntry implements Serializable {
-
-		private static final long serialVersionUID = 1106868674666L;
-
-		public static final long DELETED_MODIFICATION_STAMP = Long.MIN_VALUE; // This flag won't be seen externally. It is used to indicate the entry
-																			  // has been deleted for those that have been holding a CE.
-		
-		/**
-		 * Check against the super modification stamp and the interface stamps to see if they were set
-		 * by undefined super class or interface at cache creation time. 
-		 * 
-		 * @since 1.1.0
-		 */
-		public static final long SUPER_UNDEFINED_MODIFICATION_STAMP = Long.MIN_VALUE+1;	
-
-		private long modificationStamp;
-		private long superModificationStamp;	// Stamp of superclass, if any, at time of cache creation.
-		private String[] interfaceNames;	// Interfaces names (null if no interfaces)
-		private long[] interfaceModicationStamps;	// Modification stamps of interfaces, if any. (null if no interfaces).
-		private transient Resource pendingResource;	// Resource is waiting to be saved, but the timestamps are for this pending resource so that we know what it will be ahead of time. At this point the class will be introspected. 
-
-		private RootIndex rootIndex; // The root index this class entry is in, so that any changes can mark the entry as dirty.
-
-		private String className; // The classname for this entry.
-		
-		private boolean saveOperations;	// Flag for saving operations. Once this is set, it will continue to save operations in the cache in addition to everything else.
-
-		private long configurationModificationStamp;	// Modification stamp of the Eclipse configuration. Used to determine if the cache of override files is out of date due to a config change.
-		private boolean overrideCacheExists;	// Flag that there is an override cache to load. This is orthogonal to the config mod stamp because it simply means that on the current configuration there is no override cache.
-		private transient Resource pendingOverrideResource;	// Override resource is waiting to be saved.
-		
-		protected ClassEntry() {
-		}
-
-		ClassEntry(RootIndex rootIndex, String className) {
-			this.setRootIndex(rootIndex);
-			this.className = className;
-			modificationStamp = IResource.NULL_STAMP;
-			rootIndex.classNameToClassEntry.put(className, this);
-		}
-
-		/**
-		 * 
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public String getClassName() {
-			return className;
-		}
-
-		/**
-		 * Return whether the entry has been deleted. This will never be seen in an entry that is still in an index. It is used for entries that have
-		 * been removed from the index. It is for classes (such as the BeanInfoClassAdapter) which are holding onto a copy of entry to let them know.
-		 * <p>
-		 * Holders of entries should call isDeleted if they don't need to further check the mod stamp. Else they should call getModificationStamp and
-		 * check of deleted, stale, or mod stamp. That would save extra synchronizations. If entry is deleted then it should throw the entry away.
-		 * 
-		 * @return <code>true</code> if the entry has been deleted, <code>false</code> if still valid.
-		 * 
-		 * @see ClassEntry#getModificationStamp()
-		 * @see ClassEntry#isStale()
-		 * @see ClassEntry#DELETED_MODIFICATION_STAMP
-		 * @since 1.1.0
-		 */
-		public boolean isDeleted() {
-			return getModificationStamp() == DELETED_MODIFICATION_STAMP;
-		}
-
-		/**
-		 * Mark the entry as deleted. It will also be removed from root index in that case.
-		 * <p>
-		 * Note: It is public only so that BeanInfoClassAdapter can access it. It should not be called by anyone else outside of BeanInfo.
-		 */
-		public synchronized void markDeleted() {
-			if (!isDeleted()) {
-				getRootIndex().classNameToClassEntry.remove(className);
-				setModificationStamp(DELETED_MODIFICATION_STAMP); // Also marks index as dirty.
-			}
-		}
-
-		/**
-		 * Return whether the entry is stale or not. This orthoganal to isDeleted. isDeleted will not be true if isStale and isStale will not be true
-		 * if isDeleted. Normally you should use getModificationStamp and check the value for IResource.NULL_STAMP and other values to bring it down
-		 * to only one synchronized call to CE, but if only needing to know if stale, you can use this.
-		 * 
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 * @see IResource#NULL_STAMP
-		 * @see ClassEntry#getModificationStamp()
-		 * @see ClassEntry#isDeleted()
-		 */
-		public boolean isStale() {
-			return getModificationStamp() == IResource.NULL_STAMP;
-		}
-
-		/**
-		 * Return the modification stamp. For those holding onto an entry, and they need to know more than if just deleted, then they should just the
-		 * return value from getModificationStamp. Else they should use isDeleted or isStale.
-		 * 
-		 * @return modification stamp, or {@link IResource#NULL_STAMP}if stale or not yet created, or {@link ClassEntry#DELETED_MODIFICATION_STAMP}
-		 *         if deleted.
-		 * 
-		 * @see ClassEntry#isDeleted()
-		 * @see ClassEntry#isStale()
-		 * @since 1.1.0
-		 */
-		public synchronized long getModificationStamp() {
-			return modificationStamp;
-		}
-		
-		/**
-		 * Return the super modification stamp.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized long getSuperModificationStamp() {
-			return superModificationStamp;
-		}
-		
-		/**
-		 * Return the interface names or <code>null</code> if no interface names.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized String[] getInterfaceNames() {
-			return interfaceNames;
-		}
-
-		/**
-		 * Return the interface modification stamps or <code>null</code> if no interfaces.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized long[] getInterfaceModificationStamps() {
-			return interfaceModicationStamps;
-		}
-		
-		/*
-		 * Set the modification stamp. <p> <package-protected> because only the cache controller should set it. @param modificationStamp
-		 * 
-		 * @since 1.1.0
-		 */
-		void setModificationStamp(long modificationStamp) {
-			if (this.modificationStamp != modificationStamp) {
-				this.modificationStamp = modificationStamp;
-				getRootIndex().setDirty();
-			}
-		}
-
-		/**
-		 * Answer whether operations are also stored in the cache for this class. By default they are not. Once turned on they
-		 * will always be stored for this class until the class is deleted.
-		 * 
-		 * @return <code>true</code> if operations are cached, <code>false</code> if they are not cached.
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized boolean isOperationsStored() {
-			return saveOperations;
-		}
-		
-		/*
-		 * Set the operations stored flag.
-		 * @param storeOperations
-		 * 
-		 * @see BeanInfoCacheController.ClassEntry#isOperationsStored()
-		 * @since 1.1.0
-		 */
-		void setOperationsStored(boolean storeOperations) {
-			saveOperations = storeOperations;
-		}
-		
-		/**
-		 * Get the configuration modification stamp of the last saved override cache.
-		 * 
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized long getConfigurationModificationStamp() {
-			return configurationModificationStamp;
-		}
-
-		/* 
-		 * Set the configuration modification stamp.
-		 * <p> <package-protected> because only the cache controller should access it.
-		 * 
-		 * @param configurationModificationStamp
-		 * 
-		 * @since 1.1.0
-		 */
-		void setConfigurationModificationStamp(long configurationModificationStamp) {
-			this.configurationModificationStamp = configurationModificationStamp;
-			getRootIndex().setDirty();
-		}
-		
-		/**
-		 * Answer whether there is an override cache available.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized boolean overrideCacheExists() {
-			return overrideCacheExists;
-		}
-		
-		/*
-		 * Set the override cache exists flag.
-		 * <p> <package-protected> because only the cache controller should access it.
-		 * @param overrideCacheExists
-		 * 
-		 * @since 1.1.0
-		 */
-		void setOverrideCacheExists(boolean overrideCacheExists) {
-			this.overrideCacheExists = overrideCacheExists;
-		}
-		
-		/**
-		 * Get the pending resource or <code>null</code> if not pending.
-		 * 
-		 * @return the pending resource or <code>null</code> if not pending.
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized Resource getPendingResource() {
-			return pendingResource;
-		}
-		
-		/*
-		 * Set the entry. The sequence get,do something,set must be grouped within a synchronized(ClassEntry). 
-		 * <p> <package-protected> because only the cache controller should access it. 
-		 * @param cacheResource The cacheResource to set.
-		 * 
-		 * @since 1.1.0
-		 */
-		void setPendingResource(Resource pendingResource) {
-			this.pendingResource = pendingResource;
-		}
-
-		/**
-		 * Get the pending override resource or <code>null</code> if not pending.
-		 * 
-		 * @return the pending override resource or <code>null</code> if not pending.
-		 * 
-		 * @since 1.1.0
-		 */
-		public synchronized Resource getPendingOverrideResource() {
-			return pendingOverrideResource;
-		}
-		
-		/*
-		 * Set the entry. The sequence get,do something,set must be grouped within a synchronized(ClassEntry). 
-		 * <p> <package-protected> because only the cache controller should access it. 
-		 * @param cacheResource The cacheResource to set.
-		 * 
-		 * @since 1.1.0
-		 */
-		void setPendingOverrideResource(Resource pendingOverrideResource) {
-			this.pendingOverrideResource = pendingOverrideResource;
-		}
-
-		/*
-		 * <package-protected> because only the cache controller should access it. @param rootIndex The rootIndex to set.
-		 * 
-		 * @since 1.1.0
-		 */
-		void setRootIndex(RootIndex rootIndex) {
-			this.rootIndex = rootIndex;
-		}
-
-		/*
-		 * <package-protected> because only the cache controller should access it. @return Returns the rootIndex.
-		 * 
-		 * @since 1.1.0
-		 */
-		RootIndex getRootIndex() {
-			return rootIndex;
-		}
-		
-		/*
-		 * <package-protected> because only the cache controller should access it.
-		 * 
-		 * @since 1.1.0
-		 */
-		void setSuperModificationStamp(long superModificationStamp) {
-			this.superModificationStamp = superModificationStamp;
-		}
-
-		/*
-		 * <package-protected> because only the cache controller should access it.
-		 * 
-		 * @since 1.1.0
-		 */
-		void setInterfaceNames(String[] interfaceNames) {
-			this.interfaceNames = interfaceNames;
-		}
-
-		/*
-		 * <package-protected> because only the cache controller should access it.
-		 * 
-		 * @since 1.1.0
-		 */
-		void setInterfaceModificationStamps(long[] interfaceModificationStamps) {
-			this.interfaceModicationStamps = interfaceModificationStamps;
-		}
-		
-	}
-
-	/*
-	 * Main index for the external jars. This variable should not be referenced directly except through the getMainIndex() accessor. That controls
-	 * synchronization and restoration as needed.
-	 */
-	private static Index MAIN_INDEX;
-
-	/*
-	 * Key into the Project's session data for the project index. The Project index is stored in the project's session data. That
-	 * way when the project is closed or deleted it will go away. 
-	 * 
-	 * The project indexes will be read in as needed on a per-project basis. This variable should not be
-	 * referenced directly except through the getProjectIndex(IProject) accessor. That controls synchronization and restoration as needed.
-	 * Only during cleanup and such where we don't want to create one if it doesn't exist you must use sync(this). Be careful to keep 
-	 * the sync small.
-	 */
-	private static final QualifiedName PROJECT_INDEX_KEY = new QualifiedName(BeaninfoPlugin.PI_BEANINFO_PLUGINID, "project_index");	//$NON-NLS-1$
-
-	/*
-	 * Suffix for class cache files.
-	 */
-	private static final String CLASS_CACHE_SUFFIX = ".xmi"; //$NON-NLS-1$
-	/*
-	 * Suffic for class override cache files.
-	 */
-	private static final String OVERRIDE_CACHE_SUFFIX = ".override.xmi"; //$NON-NLS-1$
-
-	/**
-	 * Return the current class entry for the JavaClass, or <code>null</code> if no current entry.
-	 * 
-	 * @param jclass
-	 * @return class entry or <code>null</code> if no current entry.
-	 * 
-	 * @since 1.1.0
-	 */
-	public ClassEntry getClassEntry(JavaClass jclass) {
-		IType type = (IType) jclass.getReflectionType();
-		RootIndex rootIndex = getRootIndex(type);
-		String className = jclass.getQualifiedNameForReflection();
-		return getClassEntry(rootIndex, className, false);
-	}
-
-	/**
-	 * Enumeration for newCache: Signals that this cache is the Reflection Cache with no operations in it.
-	 * @since 1.1.0
-	 */
-	public final static int REFLECTION_CACHE = 1;
-	/**
-	 * Enumeration for newCache: Signals that this cache is the Reflection Cache with operations in it.
-	 * @since 1.1.0
-	 */
-	public final static int REFLECTION_OPERATIONS_CACHE = 2;
-	/**
-	 * Enumeration for newCache: Signals that this cache is the Overrides cache.
-	 * @since 1.1.0
-	 */
-	public final static int OVERRIDES_CACHE = 3;
-	/**
-	 * A new cache entry for the given class has been created. Need to write it out.
-	 * 
-	 * @param jclass
-	 *            the JavaClass the cache is for.
-	 * @param cache
-	 *            the ChangeDescription to put out if cacheType is Reflection types, a List if override cache type.
-	 * @param cacheType
-	 *            {@link BeanInfoCacheController.ClassEntry#REFLECTION_CACHE} for the enum values.
-	 * @return new class entry (or old one if same one). Should always replace one being held by this one. <code>null</code> if cache could not be
-	 *         updated for some reason.
-	 * @since 1.1.0
-	 */
-	public ClassEntry newCache(JavaClass jclass, Object cache, int cacheType) {
-		if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER)) {
-			Logger logger = BeaninfoPlugin.getPlugin().getLogger();
-			String type = cacheType!=OVERRIDES_CACHE?"Class":"Overrides"; //$NON-NLS-1$ //$NON-NLS-2$
-			if (cacheType == OVERRIDES_CACHE && cache == null)
-				type+="  empty"; //$NON-NLS-1$
-			logger.log("Creating cache for class "+jclass.getQualifiedNameForReflection()+" cache type="+type, Level.FINER); //$NON-NLS-1$ //$NON-NLS-2$
-		}
-		ChangeDescription cd = null;
-		if (cacheType != OVERRIDES_CACHE) {
-			// First go through the cd and remove any empty changes. This is because we created the feature change before we knew what went into
-			// it, and at times nothing goes into it.
-			cd = (ChangeDescription) cache;
-			for (Iterator iter = cd.getObjectChanges().iterator(); iter.hasNext();) {
-				EObjectToChangesMapEntryImpl fcEntry = (EObjectToChangesMapEntryImpl) iter.next();
-				if (((List) fcEntry.getValue()).isEmpty())
-					iter.remove(); // Empty changes, remove it.
-			}
-		}
-		IType type = (IType) jclass.getReflectionType();
-		RootIndex rootIndex = getRootIndex(type);
-		String className = jclass.getQualifiedNameForReflection();
-		ClassEntry ce = getClassEntry(rootIndex, className, true); // Create it if not existing.
-		// Sync on ce so that only can create a cache for a class at a time and so that writing (if occurring at the same time for the class) can be
-		// held up.
-		// this is a violation of the agreement to only sync on THIS, but it is necessary or else the write job would lock everything out while it is
-		// writing. This way it only locks out one class, if the class is at the same time.
-		// We shouldn't have deadlock because here we lock ce and then THIS (maybe). The write job will lock ce, and then lock THIS. Everywhere else
-		// we must
-		// also do lock ce then THIS. Mustn't do other way around or possibility of deadlock. Be careful that any synchronized methods in this class
-		// do
-		// not lock an existing ce.
-		ResourceSet cacheRset = null;
-		synchronized (ce) {
-			Resource cres;
-			if (cacheType != OVERRIDES_CACHE) {
-				cres = ce.getPendingResource();
-				if (cres != null) {
-					// We have a pending, so clear and reuse the resource.
-					cres.getContents().clear();
-				} else {
-					// Not currently writing or waiting to write, so create a new resource.
-					cres = jclass.eResource().getResourceSet().createResource(
-							URI.createFileURI(rootIndex.getCachePath().append(className + CLASS_CACHE_SUFFIX).toString()));
-				}
-				cacheRset = cres.getResourceSet();
-				ce.setOperationsStored(cacheType == REFLECTION_OPERATIONS_CACHE);
-				ce.setPendingResource(cres);
-				cres.getContents().add(cd);
-				// Archives use same mod as archive (retrieve from rootindex), while non-archive use the underlying resource's mod stamp.
-				if (rootIndex.isArchiveRoot())
-					ce.setModificationStamp(((ArchiveRootIndex) rootIndex).getArchiveModificationStamp());
-				else {
-					try {
-						ce.setModificationStamp(type.getUnderlyingResource().getModificationStamp());
-					} catch (JavaModelException e) {
-						BeaninfoPlugin.getPlugin().getLogger().log(e);
-						ce.markDeleted(); // Mark as deleted in case this was an existing that someone is holding.
-						return null; // Couldn't do it, throw cache entry away. This actually should never occur.
-					}
-				}
-				// Need to get the supers info. 
-				List supers = jclass.getESuperTypes();
-				if (!supers.isEmpty()) {
-					// We assume that they all have been introspected. This was done back in main introspection. If they are introspected they will have a class entry.
-					BeaninfoClassAdapter bca = BeaninfoClassAdapter.getBeaninfoClassAdapter((EObject) supers.get(0));
-					ClassEntry superCE = bca.getClassEntry();
-					if (superCE != null)
-						ce.setSuperModificationStamp(superCE.getModificationStamp());
-					else
-						ce.setSuperModificationStamp(ClassEntry.SUPER_UNDEFINED_MODIFICATION_STAMP);	// No classentry means undefined. So put something in so that when it becomes defined we will know.
-					if(supers.size() == 1) {
-						ce.setInterfaceNames(null);
-						ce.setInterfaceModificationStamps(null);
-					} else {
-						String[] interNames = new String[supers.size()-1];
-						long[] interMods = new long[interNames.length];
-						for (int i = 1, indx = 0; i < interNames.length; i++, indx++) {
-							JavaClass javaClass = (JavaClass) supers.get(i);
-							bca = BeaninfoClassAdapter.getBeaninfoClassAdapter(javaClass);
-							bca.introspectIfNecessary();	// Force introspection to get a valid super mod stamp.
-							superCE = bca.getClassEntry();
-							interNames[indx] = javaClass.getQualifiedNameForReflection();
-							if (superCE != null)
-								interMods[indx] = superCE.getModificationStamp();
-							else
-								interMods[indx] = ClassEntry.SUPER_UNDEFINED_MODIFICATION_STAMP;	// No classentry means undefined. So put something in so that when it becomes defined we will know.
-						}
-						ce.setInterfaceNames(interNames);
-						ce.setInterfaceModificationStamps(interMods);
-					}
-				} else {
-					ce.setSuperModificationStamp(IResource.NULL_STAMP);
-					ce.setInterfaceNames(null);
-					ce.setInterfaceModificationStamps(null);
-				}
-			} else {
-				// We are an override cache.
-				if (cache != null) { 
-					cres = ce.getPendingOverrideResource();
-					if (cres != null) {
-						// We have a pending, so clear and reuse the resource.
-						cres.getContents().clear();
-					} else {
-						// Not currently writing or waiting to write, so create a new resource.
-						cres = jclass.eResource().getResourceSet().createResource(
-								URI.createFileURI(rootIndex.getCachePath().append(className + OVERRIDE_CACHE_SUFFIX).toString()));
-					}
-					cacheRset = cres.getResourceSet();
-					cres.getContents().addAll((List) cache);
-					ce.setPendingOverrideResource(cres);
-					ce.setOverrideCacheExists(true);
-				} else {
-					ce.setPendingOverrideResource(null);
-					ce.setOverrideCacheExists(false);
-				}
-				ce.setConfigurationModificationStamp(Platform.getPlatformAdmin().getState(false).getTimeStamp());
-			}
-		}
-		queueClassEntry(ce, cacheRset); // Now queue it up.
-		return ce;
-	}
-
-	/**
-	 * Get the cache resource for the given java class.
-	 * <p>
-	 * NOTE: It is the responsibility of the caller to ALWAYS remove the Resource from its resource set when done with it.
-	 * 
-	 * @param jclass
-	 * @param ce the class entry for the jclass
-	 * @param reflectCache <code>true</code> if this the reflection/introspection cache or <code>false</code> if this is the override cache.
-	 * @return the loaded cache resource, or <code>null</code> if not there (for some reason) or an error trying to load it.
-	 * 
-	 * @since 1.1.0
-	 */
-	public Resource getCache(JavaClass jclass, ClassEntry ce, boolean reflectCache) {
-		String className = jclass.getQualifiedNameForReflection();
-		if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER)) {
-			Logger logger = BeaninfoPlugin.getPlugin().getLogger();
-			String type = reflectCache?"Class":"Overrides"; //$NON-NLS-1$ //$NON-NLS-2$
-			logger.log("Loading cache for class "+className+" cache type="+type, Level.FINER); //$NON-NLS-1$ //$NON-NLS-2$
-		}
-
-		if (reflectCache) {
-			boolean waitForJob = false;
-			synchronized (ce) {
-				if (ce.getPendingResource() != null) {
-					// We have one pending. So wait until write cache job is done, and then load it in.
-					// Note: Can't just copy the pending resource because it has references to JavaClasses
-					// and these could be in a different project (since this could be a workspace wide class).
-					// We would get the wrong java classes then when we apply it. 
-					waitForJob = true;
-					if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER))
-						BeaninfoPlugin.getPlugin().getLogger().log("Using pending class cache.", Level.FINER); //$NON-NLS-1$
-				}
-			}
-			if (waitForJob)
-				waitForCacheSaveJob();	
-
-			try {
-				return jclass.eResource().getResourceSet().getResource(
-						URI.createFileURI(ce.getRootIndex().getCachePath().append(
-								className + CLASS_CACHE_SUFFIX).toString()), true);
-			} catch (Exception e) {
-				// Something happened and couldn't load it.
-				// TODO - need to remove the Level.INFO arg when the beaninfo cache is working dynamically
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.INFO);
-				return null;
-			}
-		} else {
-			boolean waitForJob = false;
-			synchronized (ce) {
-				if (ce.getPendingOverrideResource() != null) {
-					// We have one pending. So wait until write cache job is done, and then load it in.
-					// Note: Can't just copy the pending resource because it has references to JavaClasses
-					// and these could be in a different project (since this could be a workspace wide class).
-					// We would get the wrong java classes then when we apply it. 
-					waitForJob = true;
-					if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER))
-						BeaninfoPlugin.getPlugin().getLogger().log("Using pending override cache.", Level.FINER); //$NON-NLS-1$
-				}
-			}
-			if (waitForJob)
-				waitForCacheSaveJob();	
-
-			try {
-				return jclass.eResource().getResourceSet().getResource(
-						URI.createFileURI(ce.getRootIndex().getCachePath().append(
-								className + OVERRIDE_CACHE_SUFFIX).toString()), true);
-			} catch (Exception e) {
-				// Something happened and couldn't load it.
-				// TODO - need to remove the Level.INFO arg when the beaninfo cache is working dynamically
-				BeaninfoPlugin.getPlugin().getLogger().log(e, Level.INFO);
-				return null;
-			}
-		}
-	}
-
-	private synchronized ClassEntry getClassEntry(RootIndex rootIndex, String className, boolean createEntry) {
-		ClassEntry ce = (ClassEntry) rootIndex.classNameToClassEntry.get(className);
-		if (createEntry && ce == null) {
-			// Need to create one.
-			ce = new ClassEntry(rootIndex, className);
-			// Don't actually mark the rootIndex dirty until the cache for it is actually saved out.
-		}
-		return ce;
-	}
-
-	private static final String ROOT_PREFIX = "root"; //$NON-NLS-1$
-
-	/*
-	 * Get the root index for the appropriate cache for the given java class.
-	 */
-	private RootIndex getRootIndex(IType type) {
-		IPackageFragmentRoot root = (IPackageFragmentRoot) type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
-		if (!root.isExternal()) {
-			// So it is in a project. Get the project index.
-			return getRootIndex(root, root.getJavaProject().getProject());
-		} else {
-			// It is an external jar (archive), so needs to come from main index, no project.
-			return getRootIndex(root, null);
-		}
-	}
-
-	/*
-	 * Get the root index for the given root. A Project index if project is not null.
-	 */
-	private synchronized RootIndex getRootIndex(IPackageFragmentRoot root, IProject project) {
-		Index index = project != null ? getProjectIndex(project) : getMainIndex();
-		IPath rootPath = root.getPath();
-		RootIndex rootIndex = (RootIndex) index.rootToRootIndex.get(rootPath);
-		if (rootIndex == null) {
-			// Need to do a new root path.
-			String rootName = ROOT_PREFIX + (++index.highRootNumber);
-			rootIndex = root.isArchive() ? createArchiveRootIndex(root, rootName, index) : new FolderRootIndex(rootName, index);
-			index.rootToRootIndex.put(rootPath, rootIndex);
-			// Don't set index dirty until we actually save a class cache file. Until then it only needs to be in memory.
-		}
-		rootIndex.setupIndex(project); // Set it up, or may already be set, so it will do nothing in that case.
-		return rootIndex;
-	}
-
-	/*
-	 * Create an archive root with the given root number and root.
-	 */
-	private RootIndex createArchiveRootIndex(IPackageFragmentRoot rootArchive, String rootName, Index index) {
-		long modStamp = IResource.NULL_STAMP;
-		if (rootArchive.isExternal()) {
-			modStamp = rootArchive.getPath().toFile().lastModified();
-		} else {
-			try {
-				modStamp = rootArchive.getUnderlyingResource().getModificationStamp();
-			} catch (JavaModelException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e);
-			}
-		}
-		return new ArchiveRootIndex(rootName, modStamp, index);
-	}
-
-	private static final String INDEXFILENAME = ".index"; //$NON-NLS-1$
-
-	private static final String CACHEDIR = ".cache"; // Cache directory (so as not to conflict with any future BeanInfo Plugin specific data files. //$NON-NLS-1$
-
-	/*
-	 * Get the cache directory for the project (or if project is null, the main plugin cache directory).
-	 */
-	// TODO: make this one private
-	public static IPath getCacheDir(IProject project) {
-		if (project != null)
-			return project.getWorkingLocation(BeaninfoPlugin.getPlugin().getBundle().getSymbolicName()).append(CACHEDIR);
-		else
-			return BeaninfoPlugin.getPlugin().getStateLocation().append(CACHEDIR);
-	}
-
-	/*
-	 * Get the project index. Synchronized so that we can create it if necessary and not get race conditions.
-	 */
-	private synchronized Index getProjectIndex(IProject project) {
-		try {
-			Index index = (Index) project.getSessionProperty(PROJECT_INDEX_KEY);
-			if (index == null) {
-				// Read the index in.
-				File indexDirFile = getCacheDir(project).append(INDEXFILENAME).toFile();
-				if (indexDirFile.canRead()) {
-					ObjectInputStream ois = null;
-					try {
-						ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(indexDirFile)));
-						index = (Index) ois.readObject();
-					} catch (InvalidClassException e) {
-						// This is ok. It simply means the cache index is at a downlevel format and needs to be reconstructed.
-					} catch (IOException e) {
-						BeaninfoPlugin.getPlugin().getLogger().log(e);
-					} catch (ClassNotFoundException e) {
-						BeaninfoPlugin.getPlugin().getLogger().log(e);
-					} finally {
-						if (ois != null)
-							try {
-								ois.close();
-							} catch (IOException e) {
-								BeaninfoPlugin.getPlugin().getLogger().log(e);
-							}
-					}
-				}
-
-				if (index == null) {
-					// Doesn't yet exist or it couldn't be read for some reason, or it was downlevel cache in which case we just throw it away and create
-					// new).
-					index = new Index();
-					index.highRootNumber = 0;
-					index.rootToRootIndex = new HashMap();
-				}
-
-				project.setSessionProperty(PROJECT_INDEX_KEY, index); // We either created a new one, or we were able to load it.
-			}
-			return index;
-		} catch (CoreException e) {
-			// Shouldn't occur,
-			return null;
-		}
-	}
-
-	/*
-	 * Get the main index. Synchronized so that we can create it if necessary and not get race conditions.
-	 */
-	private synchronized Index getMainIndex() {
-		if (MAIN_INDEX == null) {
-			// Read the index in.
-			File indexDirFile = getCacheDir(null).append(INDEXFILENAME).toFile();
-			if (indexDirFile.canRead()) {
-				ObjectInputStream ois = null;
-				try {
-					ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(indexDirFile)));
-					MAIN_INDEX = (Index) ois.readObject();
-				} catch (InvalidClassException e) {
-					// This is ok. It just means that the cache index is at a downlevel format and needs to be reconstructed.
-				} catch (IOException e) {
-					BeaninfoPlugin.getPlugin().getLogger().log(e);
-				} catch (ClassNotFoundException e) {
-					BeaninfoPlugin.getPlugin().getLogger().log(e);
-				} finally {
-					if (ois != null)
-						try {
-							ois.close();
-						} catch (IOException e) {
-							BeaninfoPlugin.getPlugin().getLogger().log(e);
-						}
-				}
-			}
-
-			if (MAIN_INDEX == null) {
-				// Doesn't yet exist or it couldn't be read for some reason, or it was downlevel cache in which case we just throw it away and create
-				// new).
-				MAIN_INDEX = new Index();
-				MAIN_INDEX.highRootNumber = 0;
-				MAIN_INDEX.rootToRootIndex = new HashMap();
-			}
-
-		}
-		return MAIN_INDEX;
-	}
-
-	// -------------- Save Participant code -----------------
-
-	protected class SaveParticipant implements ISaveParticipant {
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.core.resources.ISaveParticipant#doneSaving(org.eclipse.core.resources.ISaveContext)
-		 */
-		public void doneSaving(ISaveContext context) {
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.core.resources.ISaveParticipant#prepareToSave(org.eclipse.core.resources.ISaveContext)
-		 */
-		public void prepareToSave(ISaveContext context) throws CoreException {
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.core.resources.ISaveParticipant#rollback(org.eclipse.core.resources.ISaveContext)
-		 */
-		public void rollback(ISaveContext context) {
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.core.resources.ISaveParticipant#saving(org.eclipse.core.resources.ISaveContext)
-		 */
-		public void saving(ISaveContext context) throws CoreException {
-			boolean fullsave = false;
-			switch (context.getKind()) {
-				case ISaveContext.PROJECT_SAVE:
-					IProject project = context.getProject();
-					synchronized (BeanInfoCacheController.INSTANCE) {
-						// Write the index. The cache save job will eventually run and at that point write out the pending cache files too.
-						// They don't need to be written before the project save is complete.
-						Index projectIndex = (Index) project.getSessionProperty(PROJECT_INDEX_KEY);
-						if (projectIndex != null && projectIndex.isDirty())
-							if (reconcileIndexDirectory(project, projectIndex))
-								writeIndex(project, projectIndex);
-							else {
-								// It was empty, just get rid of the index. The directories have already been cleared.
-								projectIndex.markDead();
-								project.setSessionProperty(PROJECT_INDEX_KEY, null);
-							}
-					}
-					break;
-				case ISaveContext.FULL_SAVE:
-					fullsave = true;
-					waitForCacheSaveJob();
-				// Now flow into the snapshot save to complete the fullsave.
-				case ISaveContext.SNAPSHOT:
-					// For a snapshot, just the dirty indexes, no clean up. If fullsave, cleanup the indexes, but only save the dirty.
-					synchronized (BeanInfoCacheController.INSTANCE) {
-						if (MAIN_INDEX != null) {
-							if (fullsave) {
-								if (reconcileIndexDirectory(null, MAIN_INDEX)) {
-									if (MAIN_INDEX.isDirty())
-										writeIndex(null, MAIN_INDEX);
-								} else {
-									// It was empty, just get rid of the index. The directories have already been cleared.
-									MAIN_INDEX.markDead();
-									MAIN_INDEX = null;
-								}
-							} else if (MAIN_INDEX.isDirty())
-								writeIndex(null, MAIN_INDEX);
-						}
-						// Now do the project indexes. We have to walk all open projects to see which have an index. Since we are
-						// doing a major save, the hit will ok
-						IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
-						for (int i=0; i<projects.length; i++) {
-							project = projects[i];
-							if (project.isOpen()) {
-								Index index = (Index) project.getSessionProperty(PROJECT_INDEX_KEY);
-								if (index != null) {
-									if (fullsave) {
-										if (reconcileIndexDirectory(project, index)) {
-											if (index.isDirty())
-												writeIndex(project, index);
-										} else {
-											// It was empty, just get rid of the index from memory. It has already been deleted from disk.
-											index.markDead();
-											project.setSessionProperty(PROJECT_INDEX_KEY, null);
-										}
-									} else if (index.isDirty())
-										writeIndex(project, index);
-								}
-							}
-						}
-					}
-			}
-		}
-
-		/*
-		 * Write an index. Project if not null indicates a project index.
-		 */
-		private void writeIndex(IProject project, Index index) {
-			ObjectOutputStream oos = null;
-			try {
-				File indexDirFile = getCacheDir(project).toFile();
-				indexDirFile.mkdirs();
-				File indexFile = new File(indexDirFile, INDEXFILENAME);
-				oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(indexFile)));
-				oos.writeObject(index);
-				index.setDirty(false);
-			} catch (IOException e) {
-				BeaninfoPlugin.getPlugin().getLogger().log(e);
-			} finally {
-				if (oos != null)
-					try {
-						oos.close();
-					} catch (IOException e) {
-						BeaninfoPlugin.getPlugin().getLogger().log(e);
-					}
-			}
-		}
-
-		/*
-		 * Reconcile the index directory of unused (empty) root directories. If after reconciling the index is empty, then it will delete the index file too. @return
-		 * true if index not empty, false if index was empty and was erased too.
-		 */
-		private boolean reconcileIndexDirectory(IProject project, Index index) {
-			// clean out unused rootIndexes
-			File indexDir = getCacheDir(project).toFile();
-			if (indexDir.canWrite()) {
-				// Create a set of all root names for quick look up.
-				if (index.rootToRootIndex.isEmpty()) {
-					// It is empty, clear everything, including index file.
-					cleanDirectory(indexDir, false);
-					return false;
-				} else {
-					// Need a set of the valid rootnames for quick lookup of names in the directory list.
-					// And while accumulating this list, clean out the root indexes cache too (i.e. the class cache files).
-					final Set validFiles = new HashSet(index.rootToRootIndex.size());
-					validFiles.add(INDEXFILENAME);
-					for (Iterator itr = index.rootToRootIndex.values().iterator(); itr.hasNext();) {
-						RootIndex rootIndex = (RootIndex) itr.next();
-						if (reconcileClassCacheDirectory(rootIndex, project)) {
-							// The class cache has been reconciled, and there are still some classes left, so keep the root index.
-							validFiles.add(rootIndex.getRootName());
-						} else {
-							itr.remove(); // The root index is empty, so get rid of it. Since not a valid name, it will be deleted in next step.
-							index.setDirty(true); // Also set it dirty in case it wasn't because we need to write out the container Index since it was
-							// changed.
-						}
-					}
-					// Get list of files and delete those that are not a valid name (used root name, or index file)
-					String[] fileNames = indexDir.list();
-					for (int i = 0; i < fileNames.length; i++) {
-						if (!validFiles.contains(fileNames[i])) {
-							File file = new File(indexDir, fileNames[i]);
-							if (file.isDirectory())
-								cleanDirectory(file, true);
-							else
-								file.delete();
-						}
-					}
-					return true;
-				} 
-			} else 
-				return true;	// Can't write, so treat as leave alone.
-		}
-
-		/*
-		 * Reconcile the class cache directory for the root index. Return true if reconciled good but not empty. Return false if the class cache
-		 * directory is now empty. In this case we should actually get rid of the entire root index. This makes sure that the directory matches
-		 * the contents of the index by removing any file not found in the index.
-		 */
-		private boolean reconcileClassCacheDirectory(RootIndex rootIndex, IProject project) {
-			if (rootIndex.classNameToClassEntry.isEmpty())
-				return false; // There are no classes, so get rid the entire root index.
-			else {
-				final Set validFiles = rootIndex.classNameToClassEntry.keySet(); // The keys (classnames) are the filenames (without extension)
-																					// that
-				// should be kept.
-				File indexDir = getCacheDir(project).append(rootIndex.getRootName()).toFile();
-				// Get list of files that are not a valid name (used classname)
-				String[] fileNames = indexDir.list();
-				if (fileNames != null) {
-					for (int i = 0; i < fileNames.length; i++) {
-						String fileName = fileNames[i];
-						if (fileName.endsWith(OVERRIDE_CACHE_SUFFIX)) {
-							// Ends with out class cache extension, see if valid classname.
-							String classname = fileName.substring(0, fileName.length() - OVERRIDE_CACHE_SUFFIX.length());
-							ClassEntry ce = (ClassEntry) rootIndex.classNameToClassEntry.get(classname);
-							if (ce != null && ce.overrideCacheExists())
-								continue; // It is one of ours. Keep it.
-						} else if (fileName.endsWith(CLASS_CACHE_SUFFIX)) {
-							// Ends with out class cache extension, see if valid classname.
-							if (validFiles.contains(fileName.substring(0, fileName.length() - CLASS_CACHE_SUFFIX.length()))) // Strip down to just
-																																// class and see if
-																																// one of ours.
-								continue; // It is one of ours. Keep it.
-						}
-						// Not valid, get rid of it.
-						File file = new File(indexDir, fileName);
-						if (file.isDirectory())
-							cleanDirectory(file, true);
-						else
-							file.delete();
-
-					}
-				}
-				return true;
-			}
-		}
-	}
-	
-	private static void cleanDirectory(File dir, boolean eraseDir) {
-		if (dir.canWrite()) {
-			File[] files = dir.listFiles();
-			for (int i = 0; i < files.length; i++) {
-				if (files[i].isDirectory())
-					cleanDirectory(files[i], true);
-				else
-					files[i].delete();
-			}
-			if (eraseDir)
-				dir.delete();
-		}
-	}	
-
-	//-------------- Save Class Cache Entry Job -------------------
-	// This is write queue for class caches. It is a FIFO queue. It is sychronized so that adds/removes are controlled.
-	// Entries are ClassEntry's. The class entry has the resource that needs to be written out. It will be set to null
-	// by the job when it is written. The job will have a ClassEntry locked while it is retrieving and resetting the resource
-	// field in the entry.
-	//
-	// The process is the new cache will lock, create resource, set resource into the CE and release lock. Then add the CE to the queue
-	// and schedule the job (in case job is not running).
-	//
-	// The job will lock the CE, get resource from the CE, write it out, set it back to null, release the CE). If the resource is null,
-	// then it was already processed (this could happen if the job didn't get a chance to save it before another entry was posted
-	// and this is the second request and it was actually processed by the first request).
-	// IE:
-	// 1) resource created, queue entry added
-	// 2) 2nd req, job not processed yet, resource recreated and put back into CE, new queue entry.
-	// 3) job pulls from queue, locks ce, grabs resource, writes out the resource, sets back to null, release ce.
-	// 4) job pulls from queue. This time the resoure is null so it skips it.
-	//
-	// Need to lock Ce during entire create and write because the resource set is not reentrant so can't be writing it while creating it.
-
-	private List cacheWriteQueue = null;
-
-	void waitForCacheSaveJob() {
-		// For a full save we want to get the class cache files written too, so we need to manipulate the job to get it to finish ASAP.
-		if (cacheWriteJob != null) {
-			if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER))
-				BeaninfoPlugin.getPlugin().getLogger().log("Forcing a cache save job to start early.", Level.FINER); //$NON-NLS-1$
-			switch (cacheWriteJob.getState()) {
-				case Job.SLEEPING:
-					// It could be waiting a long time, so we need to wake it up at a high priority to get it running ASAP.
-					cacheWriteJob.setPriority(Job.INTERACTIVE); // Need to get it going right away
-					cacheWriteJob.wakeUp();
-					// Now drop into the wait.
-				default:
-					// Now wait for it (if not running this will return right away).
-					try {
-						cacheWriteJob.join();
-					} catch (InterruptedException e) {
-					}
-			}
-		}
-	}
-
-	static final Map SAVE_CACHE_OPTIONS;
-	static {
-		SAVE_CACHE_OPTIONS = new HashMap(3);
-		SAVE_CACHE_OPTIONS.put(XMLResource.OPTION_SAVE_TYPE_INFORMATION, Boolean.TRUE);
-		SAVE_CACHE_OPTIONS.put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-        SAVE_CACHE_OPTIONS.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
-	}
-
-	protected Job cacheWriteJob = null;
-	protected Adapter projectReleaseAdapter = new AdapterImpl() {
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.emf.common.notify.impl.AdapterImpl#isAdapterForType(java.lang.Object)
-		 */
-		public boolean isAdapterForType(Object type) {
-			return type == BeanInfoCacheController.this;	// We're making the BeanInfoCacheController.this be the adapter type.
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
-		 */
-		public void notifyChanged(Notification msg) {
-			if (msg.getEventType() == ProjectResourceSet.SPECIAL_NOTIFICATION_TYPE && msg.getFeatureID(BeanInfoCacheController.class) == ProjectResourceSet.PROJECTRESOURCESET_ABOUT_TO_RELEASE_ID) {
-				// This is an about to be closed. If we have an active write job, bring it up to top priority and wait for it to finish.
-				// This will make sure any resources in the project are written. There may not be any waiting, but this is doing a close
-				// project, which is slow already relatively speaking, that waiting for the cache write job to finish is not bad.
-				waitForCacheSaveJob();
-			}
-		}
-	};
-
-	private void queueClassEntry(ClassEntry ce, ResourceSet rset) {
-		if (cacheWriteQueue == null) {
-			cacheWriteQueue = Collections.synchronizedList(new LinkedList());
-			cacheWriteJob = new Job(BeaninfoCoreMessages.BeanInfoCacheController_Job_WriteBeaninfoCache_Title) { 
-
-				protected IStatus run(IProgressMonitor monitor) {
-					monitor.beginTask("", cacheWriteQueue.size() + 10); // This is actually can change during the run, so we add 10 for the heck of it. //$NON-NLS-1$
-					if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER))
-						BeaninfoPlugin.getPlugin().getLogger().log("Starting write BeanInfo Cache files.", Level.FINER); //$NON-NLS-1$
-					while (!monitor.isCanceled() && !cacheWriteQueue.isEmpty()) {
-						ClassEntry ce = (ClassEntry) cacheWriteQueue.remove(0); // Get first one.
-						boolean dead = false;
-						synchronized (BeanInfoCacheController.this) {
-							if (ce.getRootIndex().getIndex().isDead()) {
-								dead = true;	// The index is dead, so don't write it. We still need to go through and get the pending resource out of its resource set so that it goes away.
-							}
-						}
-						synchronized (ce) {
-							Resource cres = ce.getPendingResource();
-							if (cres != null) {
-								try {
-									if (!dead)
-										cres.save(SAVE_CACHE_OPTIONS);
-								} catch (IOException e) {
-									BeaninfoPlugin.getPlugin().getLogger().log(e);
-								} finally {
-									// Remove the resource from resource set, clear out the pending.
-									cres.getResourceSet().getResources().remove(cres);
-									ce.setPendingResource(null);
-								}
-							}
-							cres = ce.getPendingOverrideResource();
-							if (cres != null) {
-								try {
-									if (!dead)
-										cres.save(SAVE_CACHE_OPTIONS);
-								} catch (IOException e) {
-									BeaninfoPlugin.getPlugin().getLogger().log(e);
-								} finally {
-									// Remove the resource from resource set, clear out the pending.
-									cres.getResourceSet().getResources().remove(cres);
-									ce.setPendingOverrideResource(null);
-								}
-							}
-							
-							monitor.worked(1);
-						}
-					}
-					monitor.done();
-					if (BeaninfoPlugin.getPlugin().getLogger().isLoggingLevel(Level.FINER))
-						BeaninfoPlugin.getPlugin().getLogger().log("Finished write BeanInfo Cache files.", Level.FINER); //$NON-NLS-1$
-					return Status.OK_STATUS;
-				}
-			};
-			cacheWriteJob.setPriority(Job.SHORT);
-			cacheWriteJob.setSystem(true);
-		}
-		if (rset != null && EcoreUtil.getExistingAdapter(rset, this) == null) {
-			// If it is a project resource set, then add ourselves as listeners so we know when released.
-			if (rset instanceof ProjectResourceSet)
-				rset.eAdapters().add(projectReleaseAdapter);
-		}
-		cacheWriteQueue.add(ce);
-		cacheWriteJob.schedule(60 * 1000L); // Put off for 1 minute to let other stuff go on. Not important that it happens immediately.
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeanInfoContributorAdapter.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeanInfoContributorAdapter.java
deleted file mode 100644
index 8fa415b..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeanInfoContributorAdapter.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeanInfoContributorAdapter.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:28 $ 
- */
-package org.eclipse.jem.internal.beaninfo.core;
-
-import java.io.FileNotFoundException;
-
-import org.eclipse.core.resources.IResourceStatus;
-import org.eclipse.core.runtime.*;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.common.util.WrappedException;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin.IContributorOverrideRunnable;
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
-
- 
-/**
- * A default implementation of IBeanInfoContributor for users to subclass. Default does nothing.
- * <p>
- * But this does supply several very useful utility methods.
- * 
- * @since 1.0.0
- */
-public class BeanInfoContributorAdapter implements IBeanInfoContributor {
-	
-	/**
-	 * An empty array of BeaninfoEntry. Available for subclasses to return if they
-	 * decide there is nothing to return.
-	 */
-	public static final BeaninfoEntry[] EMPTY_BEANINFO_ENTRIES = new BeaninfoEntry[0];
-	
-	/**
-	 * Return true if the given fragment is part of the package. Used by subclasses to determine
-	 * if a override associated with a given fragment should be used for the package.
-	 * <p>
-	 * In other words, <code>org.eclipse</code> as a fragment and and <code>org.eclipse.core</code> as
-	 * a packagePath will answer true, but if you swapped them it will answer false.
-	 * 
-	 * @param fragment
-	 * @param packagePath
-	 * @return <code>true</code> if the given fragment is a leading part of the package.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected boolean isFragment(IPath fragment, IPath packagePath) {
-		return fragment.isPrefixOf(packagePath);
-	}
-	
-	/**
-	 * Return the unmatched portion of the package path from a fragment. Used by subclasses
-	 * to get the part of the package path that is after the fragment. This is then used to
-	 * append to the path from the override to get the full path to override files for this
-	 * package.
-	 * <p>
-	 * This will return the part of the packagePath that is not matched by the fragment. 
-	 * <p>
-	 * Note: It is important that the fragment and packagePath have first been tested through
-	 * isFragment. Otherwise an invalid result will be returned.
-	 * 
-	 * @param fragment
-	 * @param packagePath
-	 * @return the part of the package path not matched.
-	 * 
-	 * @see BeanInfoContributorAdapter#isFragment(IPath, IPath)
-	 * @since 1.0.0
-	 */
-	protected String getUnmatchedPath(IPath fragment, IPath packagePath) {
-		return fragment.removeFirstSegments(packagePath.segmentCount()).toString();
-	}
-	
-	/**
-	 * Subclasses can use this helper method to get the override resource from the given (plugin) bundle. 
-	 * 
-	 * @param bundle the bundle to use.
-	 * @param relativePath path of file relative to the plugin.
-	 * @param resource set to load into.
-	 * @param runnable the runnable that is being used for the override. It is used to determine if resource already used once.
-	 * @return the resource or <code>null</code> if couldn't be loaded or if it was already used once.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected Resource loadOverrideResource(Bundle bundle, String relativePath, ResourceSet rset, BeaninfoPlugin.IContributorOverrideRunnable runnable) {
-		URI uri = URI.createURI(JEMUtilPlugin.PLATFORM_PROTOCOL+":/"+JEMUtilPlugin.PLATFORM_PLUGIN+'/'+bundle.getSymbolicName()+'/'+relativePath); //$NON-NLS-1$
-		if (runnable.resourceContributed(uri))
-			return null;	// Already contributed once.
-		Resource result = null;
-		try {
-			result = rset.getResource(uri, true);
-		} catch (WrappedException e) {
-			// FileNotFoundException is ok
-			if (!(e.exception() instanceof FileNotFoundException)) {
-				if (e.exception() instanceof CoreException
-					&& ((CoreException) e.exception()).getStatus().getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
-					// This is ok. Means uri_mapping not set so couldn't find in Workspace, also ok.
-				} else {
-					BeaninfoPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0, "Error loading file\"" + uri + "\"", e.exception())); //$NON-NLS-1$ //$NON-NLS-2$						
-				}
-			}
-			// In case it happened after creating resource but during load. Need to get rid of it in the finally.
-			result = null;
-			Resource res = rset.getResource(uri, false);
-			if (res != null)
-				rset.getResources().remove(res);
-		} catch (Exception e) {
-			// Couldn't load it for some reason.
-			BeaninfoPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, BeaninfoPlugin.PI_BEANINFO_PLUGINID, 0, "Error loading file\"" + uri + "\"", e)); //$NON-NLS-1$ //$NON-NLS-2$
-			// In case it happened after creating resource but during load. Need to get rid of it in the finally.
-			result = null;
-			Resource res = rset.getResource(uri, false);
-			if (res != null)
-				rset.getResources().remove(res);
-		};
-		return result;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.beaninfo.core.IBeanInfoContributor#getBeanInfoEntryContributions(org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo)
-	 */
-	public BeaninfoEntry[] getBeanInfoEntryContributions(IConfigurationContributionInfo info) {
-		return EMPTY_BEANINFO_ENTRIES;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.beaninfo.core.IBeanInfoContributor#runOverrides(org.eclipse.core.runtime.IPath, java.lang.String, org.eclipse.jem.java.JavaClass, org.eclipse.emf.ecore.resource.ResourceSet, org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin.IContributorOverrideRunnable)
-	 */
-	public void runOverrides(IPath packagePath, String className, JavaClass javaClass, ResourceSet rset, IContributorOverrideRunnable runnable) {
-		// Default is do nothing
-	}
-		
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoCoreMessages.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoCoreMessages.java
deleted file mode 100644
index 2dd5656..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoCoreMessages.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class BeaninfoCoreMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.beaninfo.core.messages";//$NON-NLS-1$
-
-	private BeaninfoCoreMessages() {
-		// Do not instantiate
-	}
-
-	public static String BeanInfoCacheController_Job_WriteBeaninfoCache_Title;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, BeaninfoCoreMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoEntry.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoEntry.java
deleted file mode 100644
index a6ac99d..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoEntry.java
+++ /dev/null
@@ -1,373 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: BeaninfoEntry.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.jdt.core.*;
-import org.w3c.dom.*;
-
-import org.eclipse.jem.internal.beaninfo.adapters.*;
-
-/**
- * Beaninfo entry. Location of the beaninfos. Much like a standard classpath entry.
- * The BeanInfos are either in a jar or another project. They can be supplied as
- * a local file in the project, or as an external jar, or as external jar through a
- * variable, or an external jar through a plugin.
- * <p>
- * An external jar through containers is not valid because container are attached to
- * projects. they aren't standalone.
- * 
- * @version 	1.0
- * @author
- */
-public class BeaninfoEntry implements IBeaninfosDocEntry {
-
-	final static String sBeaninfo = "beaninfo"; // Beaninfo entry, shared with BeaninfosDoc. //$NON-NLS-1$
-	
-	public static final int BIE_PLUGIN = 100;	// Beaninfo jar can be found in a plugin.
-
-	static int kindFromString(String kindStr) {
-		if (kindStr == null || kindStr.length() == 0)
-			return BIE_PLUGIN;	// Default to plugin. If coming from beaninfoconfig, there should always be kind. But if coming from plugin.xml there shouldn't be one.
-		if (kindStr.equalsIgnoreCase("con")) //$NON-NLS-1$
-			return IClasspathEntry.CPE_CONTAINER;
-		if (kindStr.equalsIgnoreCase("var")) //$NON-NLS-1$
-			return IClasspathEntry.CPE_VARIABLE;
-		if (kindStr.equalsIgnoreCase("src")) //$NON-NLS-1$
-			return IClasspathEntry.CPE_SOURCE;
-		if (kindStr.equalsIgnoreCase("lib")) //$NON-NLS-1$
-			return IClasspathEntry.CPE_LIBRARY;
-		if (kindStr.equalsIgnoreCase("plugin")) //$NON-NLS-1$
-			return BIE_PLUGIN;
-		return -1;
-	}
-
-	static String kindToString(int kind) {
-
-		switch (kind) {
-			case IClasspathEntry.CPE_PROJECT :
-				return "src"; // backward compatibility //$NON-NLS-1$
-			case IClasspathEntry.CPE_SOURCE :
-				return "src"; //$NON-NLS-1$
-			case IClasspathEntry.CPE_LIBRARY :
-				return "lib"; //$NON-NLS-1$
-			case IClasspathEntry.CPE_VARIABLE :
-				return "var"; //$NON-NLS-1$
-			case IClasspathEntry.CPE_CONTAINER:
-				return "con"; //$NON-NLS-1$
-			case BIE_PLUGIN:
-				return "plugin";	//$NON-NLS-1$
-			default :
-				return "unknown"; //$NON-NLS-1$
-		}
-	}
-
-	/**
-	 * Return the appropriate kind of entry when we know it is a classpath entry.
-	 */
-	public static IClasspathEntry createEntry(int kind, IPath path, IProject project, boolean isExported) {
-		switch (kind) {
-
-			case IClasspathEntry.CPE_LIBRARY :
-				if (path.isAbsolute())
-					return JavaCore.newLibraryEntry(path, null, null, isExported);
-				break;
-
-			case IClasspathEntry.CPE_SOURCE :
-				if (path.isAbsolute()) {
-					// must be an entry in this project or specify another project
-					String projSegment = path.segment(0);
-					if (project != null && projSegment != null && projSegment.equals(project.getName())) {
-						// this project
-						return JavaCore.newSourceEntry(path);
-					} else {
-						// another project
-						return JavaCore.newProjectEntry(path, isExported);
-					}
-				}
-				break;
-
-			case IClasspathEntry.CPE_VARIABLE :
-				return JavaCore.newVariableEntry(path, null, null, isExported);
-			
-			case IClasspathEntry.CPE_CONTAINER:
-				return JavaCore.newContainerEntry(path, isExported);
-
-		}
-
-		return null;
-	}
-	/**
-	 * Read the entry in from the element.
-	 */
-	public static BeaninfoEntry readEntry(IReader reader, Object element, IProject project) {
-		String elementKind = reader.getAttribute(element, BeaninfosDoc.sKind);
-		String pathStr = reader.getAttribute(element, BeaninfosDoc.sPath);
-		// ensure path is absolute
-		IPath path = new Path(pathStr);
-		int kind = kindFromString(elementKind);
-		if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && kind != BIE_PLUGIN && !path.isAbsolute()) {
-			path = project != null ? project.getFullPath().append(path) : path.makeAbsolute(); // Some folder/jar within this project
-		}
-
-		// exported flag
-		String exportedString = reader.getAttribute(element, BeaninfosDoc.sExported);
-		boolean isExported = "true".equalsIgnoreCase(exportedString); //$NON-NLS-1$
-		//$NON-NLS-1$
-
-		// recreate the entry
-		IClasspathEntry cpEntry = null;
-		IPath pluginPath = null;
-		if (kind != BIE_PLUGIN) {
-			cpEntry = createEntry(kind, path, project, isExported);
-		} else {
-			if (path.isAbsolute())
-				pluginPath = path;
-			else {
-				// Kludge This should only be a plugin type if from configuration element. So we will cast to that
-				// and get the plugin id to create an absolute plugin path.
-				if (element instanceof IConfigurationElement) {
-					pluginPath = new Path('/'+((IConfigurationElement) element).getDeclaringExtension().getNamespace()).append(path);
-				} else
-					return null;	// Not valid because can't have plugin from .beaninfoconfig file.
-			}
-		}
-
-		ArrayList searchpaths = new ArrayList();
-		Object children = reader.getChildren(element);
-		int childrenLength = reader.getLength(children);
-		for (int i = 0; i < childrenLength; i++) {
-			Object child = reader.getItem(children, i);
-			if (reader.isNodeTypeElement(child)) {
-				Object entry = null;
-				if (reader.getNodeName(child).equalsIgnoreCase(SearchpathEntry.sSearchpath)) {
-					entry = SearchpathEntry.readEntry(reader, child, project, true);
-				}
-				if (entry != null)
-					searchpaths.add(entry);
-			}
-		}
-
-		if (cpEntry != null)
-			return new BeaninfoEntry(
-				cpEntry,
-				(SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]),
-				isExported);
-		else return new BeaninfoEntry(
-				pluginPath,
-				(SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]),
-				isExported);
-	}
-
-	protected IClasspathEntry entry; // Store it as a classpath entry for convienence. It is the RAW classpath entry. This is only used when pointing to something other than a plugin.
-	protected IPath pluginPath;	// When stored in a plugin, this will be set instead.
-	protected boolean isExported;
-	protected SearchpathEntry[] searchpaths;
-	
-	/**
-	 * Used when the beaninfo jar is within a plugin. In that case, the first segment
-	 * of the path is the plugin descriptor, and the rest is the path from the plugin
-	 * directory to the jar.
-	 */
-	public BeaninfoEntry(IPath pluginPath, SearchpathEntry[] searchpaths, boolean isExported) {
-		this(searchpaths, isExported);
-		this.pluginPath = pluginPath;
-	}
-
-	/**
-	 * Used when the beaninfo jar/folder is either an external jar/folder or is somewhere else
-	 * in the workspace. In that case the entry is the RAW classpath entry to that code.
-	 */
-	public BeaninfoEntry(IClasspathEntry entry, SearchpathEntry[] searchpaths, boolean isExported) {
-		this(searchpaths, isExported);
-		this.entry = entry;
-	}
-	
-	protected BeaninfoEntry(SearchpathEntry[] searchpaths, boolean isExported) {
-		this.isExported = isExported;
-		this.searchpaths = searchpaths != null ? searchpaths : new SearchpathEntry[0];
-	}
-	
-	public SearchpathEntry[] getSearchPaths() {
-		return searchpaths;
-	}
-	
-	public void setSearchPaths(SearchpathEntry[] searchpaths) {
-		this.searchpaths = searchpaths;
-	}
-	
-	public boolean isExported() {
-		return isExported;
-	}
-	
-	public void setIsExported(boolean isExported) {
-		this.isExported = isExported;
-	}
-
-	public Node writeEntry(Document doc, IProject project) {
-
-		Element element = doc.createElement(sBeaninfo);
-		IPath path = null;
-		if (entry != null) {
-			element.setAttribute(BeaninfosDoc.sKind, kindToString(entry.getEntryKind()));
-			path = entry.getPath();
-			if (entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE && entry.getEntryKind() != IClasspathEntry.CPE_CONTAINER) {
-				// translate to project relative from absolute (unless a device path)
-				if (path.isAbsolute()) {
-					if (path.segment(0).equals(project.getFullPath().segment(0))) {
-						path = path.removeFirstSegments(1);
-						path = path.makeRelative();
-					} else {
-						path = path.makeAbsolute();
-					}
-				}
-			}
-		} else {
-			element.setAttribute(BeaninfosDoc.sKind, kindToString(BIE_PLUGIN));
-			path = pluginPath;
-		}
-
-		element.setAttribute(BeaninfosDoc.sPath, path.toString()); //$NON-NLS-1$
-		if (isExported()) {
-			element.setAttribute(BeaninfosDoc.sExported, "true"); //$NON-NLS-1$
-		}
-
-		for (int i = 0; i < searchpaths.length; i++) {
-			SearchpathEntry spe = searchpaths[i];
-			element.appendChild(spe.writeEntry(doc, project));
-		}
-
-		return element;
-	}
-	
-	/**
-	 * If this is not a plugin info, then return the classpath entry.
-	 */
-	public IClasspathEntry getClasspathEntry() {
-		return entry;
-	}
-
-	/**
-	 * Return the resolved classpaths. Each entry in the array will be either:
-	 * 1) IProject - If it is a project type entry. Want the whole project
-	 * 2) String - an absolute external path to a jar
-	 * 3) IPath - a path to a plugin jar. The first segment is the plugin id, the rest is the path relative to that plugin.
-	 *            
-	 * 
-	 * @param javaProject
-	 * @return The array of paths, or <code>null</code> if no paths.
-	 * 
-	 * @since 1.0.0
-	 */
-	public Object[] getClasspath(IJavaProject javaProject) {
-		if (entry != null) {
-			// It is a standard CPE Entry.
-			IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-			List paths = new ArrayList(1);
-			IClasspathEntry resolvedEntry = JavaCore.getResolvedClasspathEntry(entry);
-			resolveEntry(root, paths, resolvedEntry, javaProject);
-			return paths.toArray();
-		} else if (pluginPath != null) 
-			return new Object[] {pluginPath};
-		
-		return null;
-
-	}
-	
-	private void resolveEntry(IWorkspaceRoot root, List paths, IClasspathEntry entry, IJavaProject javaProject) {
-		switch (entry.getEntryKind()) {
-			case IClasspathEntry.CPE_PROJECT :
-				IProject reqProject = (IProject) root.findMember(entry.getPath().lastSegment());
-				// Project entries only have one segment.
-				if (reqProject != null && reqProject.isOpen())
-					paths.add(reqProject);
-				break;
-
-			case IClasspathEntry.CPE_SOURCE :
-				reqProject = (IProject) root.findMember(entry.getPath().segment(0));
-				// Find project from the first segment.
-				IJavaProject jProject = JavaCore.create(reqProject);
-				if (jProject != null) {
-					try {
-						IPath outputLocation = jProject.getOutputLocation();
-						IResource resource = root.findMember(outputLocation);
-						if (resource != null) {
-							paths.add(resource.getLocation().toString());
-						}
-					} catch(JavaModelException e) {
-					}
-				}
-				break;
-
-			case IClasspathEntry.CPE_LIBRARY :
-				IResource library = root.findMember(entry.getPath());
-				// can be external or in workspace
-				paths.add((library != null) ? library.getLocation().toString() : entry.getPath().toString());
-				break;
-				
-			case IClasspathEntry.CPE_CONTAINER:
-				try {
-					IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
-					if (container != null) {
-						IClasspathEntry[] entries = container.getClasspathEntries();
-						for (int i = 0; i < entries.length; i++) {
-							resolveEntry(root, paths, entries[i], javaProject);
-						}
-					}
-				} catch (JavaModelException e) {
-					BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-				}			
-		}
-	}
-
-	public int getKind() {
-		return entry != null ? entry.getEntryKind() : BIE_PLUGIN;
-	}
-	
-	public IPath getPath() {
-		return entry != null ? entry.getPath() : pluginPath;
-	}
-	
-	public boolean equals(Object other) {
-		if (this == other)
-			return true;
-			
-		if (!(other instanceof BeaninfoEntry))
-			return false;
-
-		// Return equal if the classpath entry is the same classpath entry or plugin path entry.
-		// The search path doesn't have any affect on the semantic equality.
-		BeaninfoEntry otherEntry = (BeaninfoEntry) other;
-		if (isExported != otherEntry.isExported)
-			return false;	
-		if (entry != null)
-			return entry.equals(otherEntry.entry);
-		
-		return pluginPath.equals(otherEntry.pluginPath);
-	}
-	
-	public int hashCode() {
-		if (entry != null)
-			return entry.hashCode() ^ (isExported ? Boolean.TRUE : Boolean.FALSE).hashCode();
-		else
-			return pluginPath.hashCode() ^ (isExported ? Boolean.TRUE : Boolean.FALSE).hashCode();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoPlugin.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoPlugin.java
deleted file mode 100644
index 029af91..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoPlugin.java
+++ /dev/null
@@ -1,752 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: BeaninfoPlugin.java,v $
- *  $Revision: 1.19 $  $Date: 2005/10/14 17:45:04 $ 
- */
-
-
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.*;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.jdt.core.IClasspathContainer;
-import org.eclipse.jdt.core.JavaCore;
-import org.osgi.framework.Bundle;
-import org.osgi.framework.BundleContext;
-
-import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ContainerPathContributionMapping.ContainerContributionEntry;
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo.ContainerPaths;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jem.util.logger.proxyrender.EclipseLogger;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
-
-
-/**
- * The plugin class for the org.eclipse.jem.internal.proxy.core plugin.
- */
-
-public class BeaninfoPlugin extends Plugin {
-	public static final String PI_BEANINFO_PLUGINID = "org.eclipse.jem.beaninfo";	// Plugin ID, used for QualifiedName. //$NON-NLS-1$
-	public static final String PI_BEANINFO_OVERRIDES = "overrides";	// ID of the overrides extension point. //$NON-NLS-1$
-	
-	private static BeaninfoPlugin BEANINFO_PLUGIN = null;
-		
-	public BeaninfoPlugin() {	
-		BEANINFO_PLUGIN = this;
-	}
-	
-	/**
-	 * Accessor method to get the singleton plugin.
-	 */
-	public static BeaninfoPlugin getPlugin() {
-		return BEANINFO_PLUGIN;
-	}
-	
-	/**
-	 * Special Override file name used when need to apply an override to a class that is at the root.
-	 * A root is one that doesn't have a super type. These are <code>java.lang.Object</code>, interfaces, and any
-	 * undefined classes (i.e. classes that don't actually exist).
-	 */
-	public static final String ROOT = "..ROOT.."; //$NON-NLS-1$
-	
-
-	/**
-	 * Special override scheme to refer to the current java class. (As in "X:ROOT#//@root").
-	 * @since 1.2.0
-	 */
-	public static final String ROOT_SCHEMA = "X";
-	
-	/**
-	 * Special override opaque part to refer to the current java class. (As in "X:ROOT#//@root").
-	 * @since 1.2.0
-	 */
-	public static final String ROOT_OPAQUE = "ROOT";
-	
-	/**
-	 * The extension used on any override file when you pass in a path through the method that takes a string.
-	 */
-	public static final String OVERRIDE_EXTENSION = "override";	//$NON-NLS-1$
-		
-	
-	/*
-	 * Map of open natures. This map is needed because on shutdown of beaninfo plugin we need
-	 * to shutdown the natures. If we don't do that there is a slight possibility of an error
-	 * because proxy plugin will shutdown and this can cause a callback into beaninfo which has
-	 * already been shutdown. It calls back through the registry listener that BeaninfoNature
-	 * added to the registry to notify that the registry is being shutdown.
-	 * 
-	 * Also BeanInfoCacheController needs to know so that it can tell it the project is closing or
-	 * being deleted or that it needs to be cleared due to a clear request.
-	 */
-	private Map openNatures;
-	
-	private ContainerPathContributionMapping beaninfoEntryContributionsMapping;
-	private ContainerPathContributionMapping contributorContributionsMapping;
-	private Map pluginToBeaninfoEntryContributions;
-	private Map pluginToContributors;
-	
-	/*
-	 * Override contributions from extension point.
-	 * ocFragments: Array of fragments paths. When a match is found for a path, the index
-	 * 		is the index into the ocContainerIds and ocPluginIds array for the contributions.
-	 * ocContainerIds: The first dimension is the index of the fragment that the list of OverrideContributions is for.
-	 * 		The second dimension is the array of contributions for that fragment, one per container id.
-	 * ocPluginIds: The first dimension is the index of the fragment that the list of OverrideContributions is for.
-	 * 		The second dimension is the array of contributions for that fragment, one per plugin id.
-	 * 
-	 * If a particular fragment doesn't have any entries of container and/or plugin, then EMPTY_OC is used for that
-	 * entry so that we don't need to check for null.
-	 * 
-	 * How this is used is for a particular path requested, the ocFragments will be searched for the fragments that
-	 * are appropriate, then the index of the entry is used to walk through the OC[] array returned from the ocContainerIds
-	 * or ocPluginIds. Each contribution would be checked to see if the container id/plugin id is in the visible classpath (through 
-	 * the info data stored in the persistent property). If it is, then the overrides from that contribution will be used.
-	 */
-	private IPath ocFragments[];
-	private OverrideContribution[][] ocContainerIds;
-	private OverrideContribution[][] ocPluginIds;
-	
-	private static final OverrideContribution[] EMPTY_OC = new OverrideContribution[0];	// Used for an empty contribution list for a fragment.
-
-	public synchronized BeaninfoEntry[] getContainerIdBeanInfos(String containerID, String[] containerPaths) {
-		if (beaninfoEntryContributionsMapping == null)
-			processBeanInfoContributionExtensionPoint();
-		return (BeaninfoEntry[]) beaninfoEntryContributionsMapping.getContributors(containerID, containerPaths);
-	}
-	
-	public synchronized BeaninfoEntry[] getPluginBeanInfos(String pluginid) {
-		if (pluginToBeaninfoEntryContributions == null)
-			processBeanInfoContributionExtensionPoint();
-		return (BeaninfoEntry[]) pluginToBeaninfoEntryContributions.get(pluginid);
-	}
-	
-	public synchronized IConfigurationElement[] getPluginContributors(String pluginid) {
-		if (pluginToContributors == null)
-			processBeanInfoContributionExtensionPoint();
-		return (IConfigurationElement[]) pluginToContributors.get(pluginid);
-	}	
-	
-	public synchronized IConfigurationElement[] getContainerIdContributors(String containerID, String[] containerPaths) {
-		if (contributorContributionsMapping == null)
-			processBeanInfoContributionExtensionPoint();
-		return (IConfigurationElement[]) contributorContributionsMapping.getContributors(containerID, containerPaths);
-	}	
-	
-	public static final String PI_BEANINFO_CONTRIBUTION_EXTENSION_POINT = PI_BEANINFO_PLUGINID+".registrations"; //$NON-NLS-1$
-	public static final String PI_REGISTRATION = "registration"; //$NON-NLS-1$
-	public static final String PI_BEANINFO = "beaninfo";  //$NON-NLS-1$
-	public static final String PI_OVERRIDE = "override"; //$NON-NLS-1$
-	public static final String PI_CONTRIBUTOR = "contributor"; //$NON-NLS-1$
-	public static final String PI_PACKAGE = "package"; //$NON-NLS-1$
-	public static final String PI_PATH = "path"; //$NON-NLS-1$
-	
-	protected synchronized void processBeanInfoContributionExtensionPoint() {
-		ContributorExtensionPointInfo info = ProxyPlugin.processContributionExtensionPoint(PI_BEANINFO_CONTRIBUTION_EXTENSION_POINT);
-		ConfigurationElementReader reader = new ConfigurationElementReader();
-		// Process the container IDs first. We can't use the info directly because the actual configuration elements of interest are
-		// sub-elements of the info. The info contains the container path that we need.
-		beaninfoEntryContributionsMapping = new ContainerPathContributionMapping(BeaninfoEntry.class);
-		contributorContributionsMapping = new ContainerPathContributionMapping(IConfigurationElement.class);
-
-		Map fragmentsToIds = new HashMap();
-		for (Iterator iter = info.containerPathContributions.containerIdToContributions.entrySet().iterator(); iter.hasNext();) {
-			Map.Entry entry= (Map.Entry) iter.next();
-			String containerid = (String) entry.getKey();
-			ContainerContributionEntry[] contribElements = (ContainerContributionEntry[]) entry.getValue();
-			for (int i = 0; i < contribElements.length; i++) {
-				ContainerContributionEntry contribElement = contribElements[i];
-				IConfigurationElement element = (IConfigurationElement) contribElement.getContribution();
-				if (PI_REGISTRATION.equals(element.getName())) {
-					IConfigurationElement[] children = element.getChildren();
-					for (int j = 0; j < children.length; j++) {
-						IConfigurationElement child = children[j];
-						if (PI_BEANINFO.equals(child.getName())) {
-							// This is a beaninfo entry
-							BeaninfoEntry be = BeaninfoEntry.readEntry(reader, child, null);
-							if (be != null)
-								beaninfoEntryContributionsMapping.addContribution(containerid, contribElement.getContainerPathPattern(), be);
-						} else if (PI_OVERRIDE.equals(child.getName())) {
-							addOverrideEntry(fragmentsToIds, true, containerid, contribElement.getContainerPathPattern(), child);
-						}
-					}
-				} else if (PI_CONTRIBUTOR.equals(element.getName())) {
-					contributorContributionsMapping.addContribution(containerid, contribElement.getContainerPathPattern(), element);
-				}
-			}
-		}
-			
-		beaninfoEntryContributionsMapping.finalizeMapping();
-		contributorContributionsMapping.finalizeMapping();
-		
-		// Now process the plugin IDs.
-		pluginToBeaninfoEntryContributions = new HashMap(info.pluginToContributions.size());		
-		for (Iterator iter = info.pluginToContributions.entrySet().iterator(); iter.hasNext();) {
-			Map.Entry entry= (Map.Entry) iter.next();
-			String pluginId = (String) entry.getKey();
-			IConfigurationElement[] configElements = (IConfigurationElement[]) entry.getValue();
-			for (int i = 0; i < configElements.length; i++) {
-				IConfigurationElement element = configElements[i];
-				if (PI_REGISTRATION.equals(element.getName())) {
-					IConfigurationElement[] children = element.getChildren();
-					for (int j = 0; j < children.length; j++) {
-						IConfigurationElement child = children[j];
-						if (PI_BEANINFO.equals(child.getName())) {
-							// This is a beaninfo entry
-							BeaninfoEntry be = BeaninfoEntry.readEntry(reader, child, null);
-							if (be != null)
-								addEntry(pluginToBeaninfoEntryContributions, pluginId, be);
-						} else if (PI_OVERRIDE.equals(child.getName())) {
-							addOverrideEntry(fragmentsToIds, false, pluginId, null, child);
-						}
-					}
-				} else if (PI_CONTRIBUTOR.equals(element.getName())) {
-						if (pluginToContributors == null)
-							pluginToContributors = new HashMap(5);	// These are rare, don't create until necessary.
-						addEntry(pluginToContributors, pluginId, element);
-					}
-				}
-			}
-			
-		// Now go through and turn all of the contribution lists into arrays.
-		for (Iterator iter = pluginToBeaninfoEntryContributions.entrySet().iterator(); iter.hasNext();) {
-			Map.Entry entry = (Map.Entry) iter.next();
-			entry.setValue(((List) entry.getValue()).toArray(new BeaninfoEntry[((List) entry.getValue()).size()]));
-		}
-		
-		if (pluginToContributors == null)
-				pluginToContributors = Collections.EMPTY_MAP;	// Since we don't have any.
-		else {
-			for (Iterator iter = pluginToContributors.entrySet().iterator(); iter.hasNext();) {
-				Map.Entry entry = (Map.Entry) iter.next();
-				entry.setValue(((List) entry.getValue()).toArray(new IConfigurationElement[((List) entry.getValue()).size()]));
-			}			
-		}
-		
-		// Now handle the entire list of fragments.
-		ocFragments = new IPath[fragmentsToIds.size()];
-		ocContainerIds = new OverrideContribution[ocFragments.length][];
-		ocPluginIds = new OverrideContribution[ocFragments.length][];
-		Iterator iter;
-		int fragIndex;
-		for (iter = fragmentsToIds.entrySet().iterator(), fragIndex=0; iter.hasNext(); fragIndex++) {
-			Map.Entry mapEntry = (Map.Entry) iter.next();
-			ocFragments[fragIndex] = (IPath) mapEntry.getKey();
-			Map[] mapValue = (Map[]) mapEntry.getValue();
-			if (mapValue[0] == null)
-				ocContainerIds[fragIndex] = EMPTY_OC;
-			else {
-				Map containers = mapValue[0];
-				List ocContributions = new ArrayList();
-				for (Iterator ocIterator = containers.entrySet().iterator(); ocIterator.hasNext();) {
-					Map.Entry containerEntry = (Map.Entry) ocIterator.next();
-					String containerID = (String) containerEntry.getKey();
-					for (Iterator patternIterator = ((Map) containerEntry.getValue()).entrySet().iterator(); patternIterator.hasNext();) {
-						Map.Entry patternEntry = (Entry) patternIterator.next();
-						OverrideContribution oc = new OverrideContribution();
-						oc.id = containerID;
-						oc.pattern = (Pattern) patternEntry.getKey();
-						List[] ocLists = (List[]) patternEntry.getValue();
-						oc.pluginIds = (String[]) ocLists[0].toArray(new String[ocLists[0].size()]);
-						oc.paths = (String[]) ocLists[1].toArray(new String[ocLists[1].size()]);
-						ocContributions.add(oc);
-					}
-				}
-				ocContainerIds[fragIndex] = (OverrideContribution[]) ocContributions.toArray(new OverrideContribution[ocContributions.size()]);
-			}
-			if (mapValue[1] == null)
-				ocPluginIds[fragIndex] = EMPTY_OC;
-			else {
-				Map plugins = mapValue[1];
-				OverrideContribution[] ocContribution = ocPluginIds[fragIndex] = new OverrideContribution[plugins.size()];
-				int ocIndex;
-				Iterator ocIterator;
-				for (ocIterator = plugins.entrySet().iterator(), ocIndex=0; ocIterator.hasNext(); ocIndex++) {
-					Map.Entry pluginEntry = (Map.Entry) ocIterator.next();
-					OverrideContribution oc = ocContribution[ocIndex] = new OverrideContribution();
-					oc.id = (String) pluginEntry.getKey();
-					List[] ocLists = (List[]) pluginEntry.getValue();
-					oc.pluginIds = (String[]) ocLists[0].toArray(new String[ocLists[0].size()]);
-					oc.paths = (String[]) ocLists[1].toArray(new String[ocLists[1].size()]);
-				}
-			}			
-		}
-	}
-	
-	/*
-	 * Add an entry to the map. If the key doesn't exist, create an entry as an array. Then add the entry to array.
-	 */
-	private void addEntry(Map map, Object key, Object entry) {
-		List mapEntry = (List) map.get(key);
-		if (mapEntry == null) {
-			mapEntry = new ArrayList(1);
-			map.put(key, mapEntry);
-		}
-		mapEntry.add(entry);
-	}
-	
-	/*
-	 * Add an entry to the map.
-	 * id is the container path pattern/plugin id.
-	 * 
-	 * The structure of the map is:
-	 * 	key: fragment name
-	 * 	value: Map[2], where [0] is for container id, and [1] is for plugin ids.
-	 * 		Map[x]:
-	 * 			key: container/plugin id
-	 * 			value: Map(pattern->List(FinalOverride)) for container, of FinalOverride for plugin. 
-	 * 
-	 * FinalOverride: List[2], where [0] is list of plugin ids for the override, and [1] is list of paths for the override files relative to that plugin id.
-	 * 
-	 * After all done these maps/list will be boiled down to the arrays that will be used for lookup.
-	 */
-	private void addOverrideEntry(Map map, boolean container, Object id, Pattern pattern, IConfigurationElement entry) {
-		
-		String packageName = entry.getAttributeAsIs(PI_PACKAGE);
-		String plugin = null;
-		String pathString = entry.getAttributeAsIs(PI_PATH);
-		IPath fragment = null; 
-		if (packageName != null && packageName.length() > 0 && pathString != null && pathString.length() > 0) { 
-			fragment = new Path(packageName.replace('.', '/'));
-			if (pathString.charAt(pathString.length()-1) != '/')
-				pathString += '/';
-			if (pathString.charAt(0) != '/')
-				plugin = entry.getDeclaringExtension().getNamespace();
-			else {
-				if (pathString.length() > 4) {
-					int pend = pathString.indexOf('/', 1);
-					if (pend == -1 || pend >= pathString.length()-1)
-						return;	// invalid
-					plugin = pathString.substring(1, pend);
-					pathString = pathString.substring(pend+1);
-				} else
-					return;	// invalid
-			}
-		}
-		if (pathString.length() < 2)
-			return;	// invalid
-
-		Map[] mapEntry = (Map[]) map.get(fragment);
-		if (mapEntry == null) {
-			mapEntry = new HashMap[2];
-			map.put(fragment, mapEntry);
-		}
-		List[] idEntry;
-		if (container) {
-			if (mapEntry[0] == null)
-				mapEntry[0] = new HashMap(2);
-			
-			Map patternMap = (Map) mapEntry[0].get(id);
-			if (patternMap == null)
-				mapEntry[0].put(id, patternMap = new HashMap());
-			
-			idEntry = (List[]) patternMap.get(pattern);
-			if (idEntry == null) {
-				patternMap.put(pattern, idEntry = new List[] { new ArrayList(1), new ArrayList(1)});
-			}
-		} else {
-			if (mapEntry[1] == null)
-				mapEntry[1] = new HashMap(2);
-
-			idEntry = (List[]) mapEntry[1].get(id);
-			if (idEntry == null) {
-				mapEntry[1].put(id, idEntry = new List[] { new ArrayList(1), new ArrayList(1)});
-			}
-		}
-		idEntry[0].add(plugin);
-		idEntry[1].add(pathString);
-
-
-	}	
-			
-	/*
-	 * This is an list of overrides that are available as a contribution for a specific fragment.
-	 * <ul>
-	 * <li>The id of this contribution. Either container (Pattern) or plugin id depending on which list it was in..
-	 * <li>The plugins array lists the plugin ids for all of the paths in this contribution.
-	 * <li>The paths array lists the folder path under that corresponding plugin from "pluginIds".
-	 * </ul> 
-	 * <p>
-	 * 
-	 * @since 1.0.0
-	 */
-	private static class OverrideContribution {
-		public String id;
-		public Pattern pattern;	// Used only for containers.
-		public String[] pluginIds;
-		public String[] paths;
-	}
-	
-	/**
-	 * The runnable is to used to apply override. 
-	 * <p>
-	 * This will be called in sequence for each override path found. It is send in on the apply overrides call. This
-	 * interface implementation is private.
-	 * <p>
-	 * Clients (implementers of the IBeanInfoContributor) will be passed in the subinterface <code>IContributorOverrideRunnable</code> which
-	 * inherits from this interface.
-	 * <p>
-	 * This interface is not intended to be implemented by clients. 
-	 * 
-	 * @since 1.0.0
-	 * @see BeaninfoPlugin#applyOverrides(IProject, String, String, ResourceSet, IOverrideRunnable)
-	 */
-	public interface IOverrideRunnable {
-		/**
-		 * This will be called with the directory path to use. It will be called over and over for every
-		 * override path found for a package. The path will be complete, including trailing '/'.
-		 * It will be in a URI format for a directory. The overriderunnable implementation will then append the filename call (i.e. classbeingintrospected.override) to get a complete path.
-		 * <p>
-		 * Clients (IBeanInfoContributor implementers) can call this to apply a specific override file to the current
-		 * class being processed.
-		 * 
-		 * @param overridePath the path will be complete, including trailing '/'. It will be in a URI format for a directory. The override file name (classname.override) will be appended to this and retrieved and applied.
-		 * 
-		 * @since 1.0.0
-		 */
-		public void run(String overridePath);
-		
-		/**
-		 * This will be called with the actual resource to use. This will be called by special contributors that want
-		 * a special explicit override resource to be used.
-		 * <p>
-		 * Contributors should use the ResourceSet that was passed into them. This is so that anything java class that
-		 * the override resource points to will be found.
-		 * <p>
-		 * This resource will be automatically removed by BeanInfo after being applied. It must not be left around because
-		 * in the process of being applied it will be modified, so it could not be reused. 
-		 *  
-		 * @param overrideResource the resource to apply to the current class. NOTE: This resource WILL be removed from
-		 * the resource set it is in automatically by this call. It won't be left around because the action of apply
-		 * will actually modify the resource.
-		 * 
-		 * @since 1.0.0
-		 */
-		public void run(Resource overrideRes);
-	}
-	
-	/**
-	 * IBeanInfoContributor runnable to use to apply overrides.
-	 * <p>
-	 * An implementation of this will be passed in to IBeanInfoContributor's so that they can call back to apply the overrides. They
-	 * should call the appropriate run method once for each override to be applied. The run can be called more than once from each IBeanInfoContributor.
-	 * <p>
-	 * It inherits from <code>IOverrideRunnable</code>, so see that for more methods to call.
-	 * <p>
-	 * This interface is not intended to be implemented by clients.
-	 * 
-	 * @see BeaninfoPlugin.IOverrideRunnable for more methods that can be called.
-	 * @since 1.0.0
-	 */
-	public interface IContributorOverrideRunnable extends IOverrideRunnable {
-		
-		/**
-		 * Tests if path has already been contributed once for the current class.
-		 * <p>
-		 * This can be called by the IBeanInfoContributor for overrides to test if the path (same path as for the IOverrideRunnable.run(String) method)
-		 * has already been contributed once for this class. It can be used to save time. However it is not necessary because
-		 * BeanInfo will not permit it to be contributed more than once for a class.
-		 * 
-		 * @param path
-		 * @return <code>true</code> if used already.
-		 * 
-		 * @see IOverrideRunnable#run(String)
-		 * @since 1.0.0
-		 */
-		public boolean pathContributed(String path);
-		
-		/**
-		 * Tests if the URI has already been contributed once for the current class.
-		 * <p>
-		 * This can be called by an IBeanInfoContributor for overrides to see if the URI (same path as the URI from the IOverrideRunnable.run(Resource) method)
-		 * has already been contributed once for this class. It can be used to save time. However, not necessary because
-		 * BeanInfo will not permit the URI to be contributed more than once for a class.
-		 * 
-		 * @param resourceURI
-		 * @return <code>true</code> if used already.
-		 * 
-		 * @see IOverrideRunnable#run(Resource)
-		 * @since 1.0.0
-		 */
-		public boolean resourceContributed(URI resourceURI);
-	}
-	
-	private static final String[] NO_PATHS = new String[0];
-	
-	/**
-	 * Return just the contributed override paths (through the BeanInfo registrations). Does not include any paths that are contributed from
-	 * IBeanInfoContributor's. This is used by the BeanInfoClassAdapter to load the overrides files into one cache file so that it can
-	 * be done at one time the next time it is needed.
-	 * 
-	 * @param project
-	 * @param packageName
-	 * @return array of path strings to the override. The files may not exist, they is just possible overrides. 
-	 * 
-	 * @since 1.1.0
-	 */
-	public String[] getOverridePaths(IProject project, String packageName) {
-		final IPath packagePath = new Path(packageName.replace('.', '/')+'/');
-		List overridePaths = new ArrayList();
-		try {
-			IConfigurationContributionInfo info = (IConfigurationContributionInfo) project.getSessionProperty(BeaninfoNature.CONFIG_INFO_SESSION_KEY);
-			if (info == null) {
-				// It hasn't been created yet, so we need to create our own internal version here.
-				info = ProxyLaunchSupport.createDefaultConfigurationContributionInfo(JavaCore.create(project));					
-				BeaninfoNature.computeBeanInfoConfigInfo(info);
-			}
-			synchronized (this) {
-				if (ocFragments == null)
-					processBeanInfoContributionExtensionPoint(); // We haven't processed them yet.
-			}
-			
-			// Cache of tested patterns. (Pattern->Boolean). If a pattern has been tested against all visible container paths we don't need to test the
-			// pattern again if it is found again. (Note: This works for efficiency because ProxyPlugin uses the same pattern instance for
-			// same pattern found while processing one extension point). The value is true if the pattern matches a visible container path.
-			Map testedPatterns = new HashMap();	
-			for (int fragmentIndex = 0; fragmentIndex < ocFragments.length; fragmentIndex++) {
-				if (ocFragments[fragmentIndex].isPrefixOf(packagePath)) {
-					String leftOver = null;	// The left over portion of the package. This will be set first time needed. 
-					OverrideContribution[] cntrContributions = ocContainerIds[fragmentIndex];
-					for (int ocindex = 0; ocindex < cntrContributions.length; ocindex++) {
-						OverrideContribution contribution = cntrContributions[ocindex];
-						Boolean tested = (Boolean) testedPatterns.get(contribution.pattern);
-						if (tested == null) {
-							tested = Boolean.FALSE;
-							ContainerPaths containerPaths = (ContainerPaths) info.getContainerIds().get(contribution.id);
-							if (containerPaths != null) {
-								String[] visible = containerPaths.getVisibleContainerPaths();
-								for (int i = 0; i < visible.length; i++) {
-									if (contribution.pattern.matcher(visible[i]).matches()) {
-										tested = Boolean.TRUE;
-										break;
-									}
-								}
-							}
-							testedPatterns.put(contribution.pattern, tested);
-						}
-						
-						if (tested.booleanValue()) {
-							for (int cindex = 0; cindex < contribution.pluginIds.length; cindex++) {
-								// Because of URIConverters and normalization in org.eclipse.jem.util stuff, we
-								// need to have plugin uri's in the form "platform:/plugin/pluginname".
-								// Bundle's don't return this format. They return bundle:/stuff
-								// So we will simple create it of the platform:/plugin format.
-								// To save time, we will first see if we have the bundle.
-								Bundle bundle = Platform.getBundle(contribution.pluginIds[cindex]);
-								if (bundle != null) {
-									if (leftOver == null)
-										leftOver = getLeftOver(ocFragments[fragmentIndex], packagePath);
-									overridePaths.add(JEMUtilPlugin.PLATFORM_PROTOCOL+":/"+JEMUtilPlugin.PLATFORM_PLUGIN+'/'+bundle.getSymbolicName()+'/'+contribution.paths[cindex]+leftOver); //$NON-NLS-1$
-								}
-							}
-						}
-					}
-					
-					OverrideContribution[] pluginContributions = ocPluginIds[fragmentIndex];
-					for (int ocindex = 0; ocindex < pluginContributions.length; ocindex++) {
-						OverrideContribution contribution = pluginContributions[ocindex];
-						Boolean visible = (Boolean) info.getPluginIds().get(contribution.id);
-						if (visible != null && visible.booleanValue()) {
-							for (int cindex = 0; cindex < contribution.pluginIds.length; cindex++) {
-								Bundle bundle = Platform.getBundle(contribution.pluginIds[cindex]);
-								if (bundle != null) {
-									if (leftOver == null)
-										leftOver = getLeftOver(ocFragments[fragmentIndex], packagePath);
-									overridePaths.add(JEMUtilPlugin.PLATFORM_PROTOCOL+":/"+JEMUtilPlugin.PLATFORM_PLUGIN+'/'+bundle.getSymbolicName()+'/'+contribution.paths[cindex]+leftOver); //$NON-NLS-1$
-								}
-							}
-						}
-					}
-				}
-			}
-		} catch (CoreException e) {
-			getLogger().log(e, Level.INFO);
-		}
-		return overridePaths.isEmpty() ? NO_PATHS : (String[]) overridePaths.toArray(new String[overridePaths.size()]);
-	}
-	
-	/**
-	 * Apply the runnable to all of the override paths that are applicable to the 
-	 * given package name. It will run through the explicit contributors and the IContainers that implement IBeanInfoContributor.
-	 * <p>
-	 * The package name uses '.' to delineate the fragments of the name,
-	 * i.e. use "<code>java.lang</code>" as a package name.
-	 * <p>
-	 * Note: This is not meant to be called by clients. It is public only because an internal class in another package needs to call it.
-	 * TODO This should be package-protected. Later the other class will be moved into this package.
-	 * 
-	 * @param project the project to run against.
-	 * @param packageName
-	 * @param className class name of the class that is being overridden.
-	 * @param javaClass the java class the overrides will be applied to.
-	 * @param resource set that contributors can use to temporarily load dynamic override files.
-	 * @param runnable use this runnable to actually apply overrides.
-	 * 
-	 * @since 1.0.0
-	 */
-	public void applyOverrides(final IProject project, String packageName, final String className, final JavaClass javaClass, final ResourceSet rset, final IOverrideRunnable runnable) {
-		final IPath packagePath = new Path(packageName.replace('.', '/')+'/');
-		try {
-			IConfigurationContributionInfo info = (IConfigurationContributionInfo) project.getSessionProperty(BeaninfoNature.CONFIG_INFO_SESSION_KEY);
-			if (info == null) {
-				// It hasn't been created yet, so we need to create our own internal version here.
-				info = ProxyLaunchSupport.createDefaultConfigurationContributionInfo(JavaCore.create(project));					
-				BeaninfoNature.computeBeanInfoConfigInfo(info);
-			}
-			final IBeanInfoContributor[] explicitContributors = (IBeanInfoContributor[]) project.getSessionProperty(BeaninfoNature.BEANINFO_CONTRIBUTORS_SESSION_KEY);
-			synchronized (this) {
-				if (ocFragments == null)
-					processBeanInfoContributionExtensionPoint(); // We haven't processed them yet.
-			}
-
-			final Set usedPaths = new HashSet(10);	// Set of used paths. So that the contributors don't supply a path already used. This could cause problems if they did.
-			final IContributorOverrideRunnable contribRunnable = new IContributorOverrideRunnable() {
-				public void run(String overridePath) {
-					if (!usedPaths.contains(overridePath)) {
-						usedPaths.add(overridePath);
-						runnable.run(overridePath);
-					}
-				}
-				
-				public void run(Resource overrideRes) {
-					if (!usedPaths.contains(overrideRes.getURI())) {
-						usedPaths.add(overrideRes.getURI());
-						try {
-							runnable.run(overrideRes);
-						} finally {
-							overrideRes.getResourceSet().getResources().remove(overrideRes);
-						}
-					}
-				}
-				
-				public boolean pathContributed(String path) {
-					return usedPaths.contains(path);
-				}
-				
-				public boolean resourceContributed(URI resourceURI) {
-					return usedPaths.contains(resourceURI);
-				}
-			};
-			
-			// Run through the containers that implement IBeanInfoContributor.
-			for (Iterator iter = info.getContainers().entrySet().iterator(); iter.hasNext();) {
-				Map.Entry mapEntry = (Map.Entry) iter.next();
-				final IClasspathContainer container = (IClasspathContainer) mapEntry.getKey();
-				if (container instanceof IBeanInfoContributor && ((Boolean) mapEntry.getValue()).booleanValue()) {
-					Platform.run(new ISafeRunnable() {
-						public void handleException(Throwable exception) {
-							// Standard run logs to .log
-						}
-						public void run() throws Exception {
-							((IBeanInfoContributor) container).runOverrides(packagePath, className, javaClass, rset, contribRunnable);						
-						}
-					});
-				}
-			}
-			
-			// Run through the explicit contributors.
-			for (int i=0; i<explicitContributors.length; i++) {
-				final int ii = i;
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// Standard run logs to .log
-					}
-					public void run() throws Exception {
-						explicitContributors[ii].runOverrides(packagePath, className, javaClass, rset, contribRunnable);						
-					}
-				});
-			}			
-		} catch (CoreException e) {
-			getLogger().log(e, Level.INFO);
-		}
-	}
-	
-	private String getLeftOver(IPath fragment, IPath packagePath) {
-		return packagePath.removeFirstSegments(fragment.segmentCount()).toString();
-	}
-	
-	private Logger logger;
-	public Logger getLogger() {
-		if (logger == null)
-			logger = EclipseLogger.getEclipseLogger(this);
-		return logger;
-	}
-	
-	/**
-	 * Add that a BeanInfo nature is active. This is used to tell it to shutdown when beaninfo shuts down.
-	 * TODO <package-protected> because only BeanInfoNature should call it. (public for now but when we make
-	 * BeanInfoNature an API it will be moved into the same package as BeanInfoPlugin).
-	 * 
-	 * @param nature
-	 * 
-	 * @since 1.0.0
-	 */
-	public void addBeanInfoNature(BeaninfoNature nature) {
-		if (openNatures == null)
-			openNatures = new HashMap();
-		openNatures.put(nature.getProject(), nature);
-	}
-	
-	/**
-	 * Mark that a BeanInfo nature is not active. This is used to tell it to shutdown when beaninfo shuts down.
-	 * TODO <package-protected> because only BeanInfoNature should call it. (public for now but when we make
-	 * BeanInfoNature an API it will be moved into the same package as BeanInfoPlugin).
-	 * 
-	 * @param nature
-	 * 
-	 * @since 1.0.0
-	 */
-	public void removeBeanInfoNature(BeaninfoNature nature) {
-		if (openNatures != null)
-			openNatures.remove(nature.getProject());
-	}
-	
-	/**
-	 * Return the registered nature, if any, for the project. This will not cause the
-	 * nature to be created.
-	 * <p>
-	 * <package-protected> because only BeanInfoCacheController should access it.
-	 * @param project
-	 * @return nature for project or <code>null</code> if not registered.
-	 * 
-	 * @since 1.1.0
-	 */
-	BeaninfoNature getNature(IProject project) {
-		return (BeaninfoNature) openNatures.get(project);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.core.runtime.Plugin#stop(org.osgi.framework.BundleContext)
-	 */
-	public void stop(BundleContext context) throws Exception {
-		if (openNatures != null && !openNatures.isEmpty()) {
-			for (Iterator natureItr = openNatures.values().iterator(); natureItr.hasNext();) {
-				BeaninfoNature nature = (BeaninfoNature) natureItr.next();
-				nature.shutdown();
-			}
-		}
-			
-		super.stop(context);
-	}
-}
-
-
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoRegistration.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoRegistration.java
deleted file mode 100644
index ca350c9..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoRegistration.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: BeaninfoRegistration.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import org.eclipse.core.runtime.IConfigurationElement;
-
-/**
- * This is the registration information for registered beaninfos in the BeaninfoPlugin.
- * @version 	1.0
- * @author
- */
-public class BeaninfoRegistration {
-	
-	protected BeaninfosDoc doc;
-	protected IConfigurationElement variableElement;	// This is used to get contributor element. If null, then no contributor.
-	
-	public BeaninfoRegistration() {
-	}
-	
-	/**
-	 * Construct with a BeaninfosDoc
-	 */
-	public BeaninfoRegistration(BeaninfosDoc doc) {
-		this.doc = doc;
-	}
-	
-	/**
-	 * Construct with a BeaninfosDoc and variable element.
-	 */
-	public BeaninfoRegistration(BeaninfosDoc doc, IConfigurationElement variableElement) {
-		this.doc = doc;
-		this.variableElement = variableElement;
-	}	
-
-	/**
-	 * Gets the doc.
-	 * @return Returns a BeaninfosDoc
-	 */
-	public BeaninfosDoc getDoc() {
-		return doc;
-	}
-
-	/**
-	 * Sets the doc.
-	 * @param doc The doc to set
-	 */
-	public void setDoc(BeaninfosDoc doc) {
-		this.doc = doc;
-	}
-
-	/**
-	 * Gets the variableElement.
-	 * @return Returns a IConfigurationElement
-	 */
-	public IConfigurationElement getVariableElement() {
-		return variableElement;
-	}
-
-	/**
-	 * Sets the variableElement.
-	 * @param variableElement The variableElement to set
-	 */
-	public void setVariableElement(IConfigurationElement variableElement) {
-		this.variableElement = variableElement;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfosDoc.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfosDoc.java
deleted file mode 100644
index ad2299a..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfosDoc.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: BeaninfosDoc.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-import java.util.ArrayList;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.IPath;
-import org.w3c.dom.*;
-
-import org.eclipse.jem.internal.beaninfo.adapters.*;
-/**
- * Beaninfos document in-memory format.
- */
-
-public class BeaninfosDoc implements IBeaninfosDocEntry {
-
-	protected IBeaninfosDocEntry[] searchpath;
-
-	static final String sExported = "exported"; //$NON-NLS-1$
-
-	static final String sKind = "kind"; //$NON-NLS-1$
-
-	static final String sPath = "path"; //$NON-NLS-1$
-
-	public BeaninfosDoc() {
-	}
-
-	public BeaninfosDoc(IBeaninfosDocEntry[] searchpath) {
-		this.searchpath = searchpath;
-	}
-
-	public int getKind() {
-		return -1;	// N.A.
-	}
-	
-	public IPath getPath() {
-		return null;	// N.A.
-	}
-	
-	public static BeaninfosDoc readEntry(IReader reader, Object root, IProject project) {
-		ArrayList paths = new ArrayList();
-		Object children = reader.getChildren(root);
-		int childrenLength = reader.getLength(children);
-		for (int i = 0; i < childrenLength; i++) {
-			Object child = reader.getItem(children, i);
-			if (reader.isNodeTypeElement(child)) {
-				Object entry = null;
-				if (reader.getNodeName(child).equalsIgnoreCase(BeaninfoEntry.sBeaninfo)) {
-					entry = BeaninfoEntry.readEntry(reader, child, project);
-				} else if (reader.getNodeName(child).equalsIgnoreCase(SearchpathEntry.sSearchpath)) {
-					entry = SearchpathEntry.readEntry(reader, child, project, false);
-				}
-				if (entry != null)
-					paths.add(entry);
-			}
-		}
-		return new BeaninfosDoc((IBeaninfosDocEntry[]) paths.toArray(new IBeaninfosDocEntry[paths.size()]));
-	}
-
-	public IBeaninfosDocEntry[] getSearchpath() {
-		return searchpath;
-	}
-
-	public void setSearchpath(IBeaninfosDocEntry[] searchpath) {
-		this.searchpath = searchpath;
-	}
-
-	public Node writeEntry(Document doc, IProject project) {
-		Element root = doc.createElement(SearchpathEntry.sSearchpath); // Create Root Element
-		for (int i = 0; i < searchpath.length; i++) {
-			root.appendChild(searchpath[i].writeEntry(doc, project)); // Add to the document
-		}
-		return root;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/ConfigurationElementReader.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/ConfigurationElementReader.java
deleted file mode 100644
index 71d0bdb..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/ConfigurationElementReader.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: ConfigurationElementReader.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.lang.reflect.Array;
-
-import org.eclipse.core.runtime.IConfigurationElement;
-
-import org.eclipse.jem.internal.beaninfo.adapters.*;
-
-
-/**
- * For reading from IConfigurationElements
- * @version 	1.0
- * @author
- */
-class ConfigurationElementReader implements IReader {
-
-	/*
-	 * @see IReader#getChildren(Object)
-	 */
-	public Object getChildren(Object node) {
-		return (node instanceof IConfigurationElement) ? ((IConfigurationElement) node).getChildren() : new IConfigurationElement[0];
-	}
-
-	/*
-	 * @see IReader#getLength(Object)
-	 */
-	public int getLength(Object nodeList) {
-		return (nodeList instanceof IConfigurationElement[]) ? Array.getLength(nodeList) : 0;
-	}
-
-	/*
-	 * @see IReader#getItem(Object, int)
-	 */
-	public Object getItem(Object nodeList, int index) {
-		return (nodeList instanceof IConfigurationElement[]) ? Array.get(nodeList, index) : null;
-	}
-
-	/*
-	 * @see IReader#isNodeTypeElement(Object)
-	 */
-	public boolean isNodeTypeElement(Object node) {
-		return node instanceof IConfigurationElement;
-	}
-
-	/*
-	 * @see IReader#getNodeName(Object)
-	 */
-	public String getNodeName(Object node) {
-		return (node instanceof IConfigurationElement) ? ((IConfigurationElement) node).getName() : ""; //$NON-NLS-1$
-	}
-
-	/*
-	 * @see IReader#getAttribute(Object, String)
-	 */
-	public String getAttribute(Object element, String attributeName) {
-		return (element instanceof IConfigurationElement) ? ((IConfigurationElement) element).getAttributeAsIs(attributeName) : null;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeanInfoContributor.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeanInfoContributor.java
deleted file mode 100644
index f1f9966..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeanInfoContributor.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IBeanInfoContributor.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:31:28 $ 
- */
-package org.eclipse.jem.internal.beaninfo.core;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo;
-import org.eclipse.jem.java.JavaClass;
- 
-/**
- * Interface for BeanInfo contributors. Supplied either as additional interface on a IClasspathContainer, or as
- * an explicit contributor for BeanInfos from the manifest files.
- * <p>
- * Implementations of this interface allows a dynamic supply of BeanInfo contributions (beaninfo jars and search paths)
- * and override files. This is used when the default plugin extension mechanism is too static for the requirements. 
- * <p>
- * There is a very useful default implementation (<code>BeanInfoContributorAdapter</code>) that can be subclassed. The
- * default doesn't do anything on its own. But it does have a very useful utility method for loading resources.
- * 
- * @see org.eclipse.jem.internal.beaninfo.core.BeanInfoContributorAdapter
- * @since 1.0.0
- */
-public interface IBeanInfoContributor {
-	
-	/**
-	 * Return the BeanInfoEntry contributions that are needed.
-	 * <p>
-	 * This will be called by BeanInfo when it determines that this contributor is applicable 
-	 * for the current project being processed. BeaninfoEntry's define the BeanInfo jars and search paths to use.
-	 * 
-	 * @param info
-	 * @return BeanInfo contributions or <code>null</code> if none to contribute.
-	 * 
-	 * @since 1.0.0
-	 */
-	public BeaninfoEntry[] getBeanInfoEntryContributions(IConfigurationContributionInfo info);
-	
-	/**
-	 * For the given package path run the override contributions through the runnable.
-	 * <p>
-	 * This will be called by BeanInfo when it determines that this
-	 * contributor is applicable for the current project being processed.
-	 * <p>
-	 * Implementations must call the runnable (the argument <code>runnable</code>) for each override file that is to be applied to the incoming class.
-	 * You can either call the run method that passes in a string pointing to a directory where your override file is
-	 * located (i.e. <code>overrideFileName.override</code> where "overrideFileName" is the name passed. Or you can call the run method that 
-	 * takes a Resource that is already loaded (and maybe modified or created locally).
-	 * 
-	 * @param packagePath
-	 * @param overrideFileName the overrideFileName that the overrides is for. This can be used in very special cases to provide 
-	 * exact override files instead of letting the path be searched. An example would be for providing a file that isn't the same name as the class.
-	 * A very special case is <code>ROOT</code>. This is used when asking to apply root overrides to classes that have no 
-	 * super type. 
-	 * @param javaClass the java class that the overrides will be applied to. Note: Do not call any property, features, events, or operations calls
-	 * or any property, events, or operations Utilities against this class. That is because this class is being introspected at this time
-	 * and those calls will return invalid values if called at this point since introspection is not yet complete. 
-	 * @param resource set that contributors can use to temporarily load dynamic override files.
-	 * @param runnable the runnable that you call to actually apply the override files.
-	 * 
-	 * @see BeaninfoPlugin#ROOT
-	 * @see BeaninfoPlugin#OVERRIDE_EXTENSION
-	 * @since 1.0.0
-	 */
-	public void runOverrides(IPath packagePath, String overrideFileName, JavaClass javaClass, ResourceSet rset, BeaninfoPlugin.IContributorOverrideRunnable runnable);
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeaninfoSupplier.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeaninfoSupplier.java
deleted file mode 100644
index 0bd69e7..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeaninfoSupplier.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: IBeaninfoSupplier.java,v $
- *  $Revision: 1.5 $  $Date: 2005/09/13 20:30:46 $ 
- */
-
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-
-import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
-import org.eclipse.jem.util.emf.workbench.ProjectResourceSet;
-/**
- * Interface to supply information for beaninfo to decouple
- * the introspection from the desktop.
- */
-
-public interface IBeaninfoSupplier {
-	
-	/**
-	 * @return Return the registry to use. Initialize it if not already initialized.
-	 */
-	public ProxyFactoryRegistry getRegistry();
-	
-	/**
-	 * Used to know if we currently have a registry created in the supplier.
-	 * 
-	 * @return true if there is a registry currently in the supplier.
-	 */
-	public boolean isRegistryCreated();
-	
-	/**
-	 * Close the registry. This tells the registry to close. This is necessary
-	 * at times because of changes to classes require the registry to be
-	 * reconstructed.
-	 */
-	public void closeRegistry();
-	
-	/**
-	 * Return the project that this supplier is for.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public IProject getProject();
-	
-	/**
-	 * Create a new resource set based upon the current project. This resource set is hooked into the
-	 * project's resource set so that any searches for java classes.
-	 * 
-	 * @return a new resource set that is hooked into the project's java resource set.
-	 * 
-	 * @since 1.2.0
-	 */
-	public ProjectResourceSet getNewResourceSet();
-	
-	/**
-	 * The project resource set for this supplier.
-	 * @return
-	 * 
-	 * @since 1.2.0
-	 */
-	public ResourceSet getProjectResourceSet();
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeaninfosDocEntry.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeaninfosDocEntry.java
deleted file mode 100644
index f81dade..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/IBeaninfosDocEntry.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: IBeaninfosDocEntry.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:28 $ 
- */
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.IPath;
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
-
-/**
- * Interface for DOM Doc writable entries.
- * 
- * @version 	1.0
- * @author
- */
-public interface IBeaninfosDocEntry {
-	public Node writeEntry(Document doc, IProject project);
-	
-	public int getKind();
-	public IPath getPath();
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Init.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Init.java
deleted file mode 100644
index 4ac93b5..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Init.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: Init.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:28 $ 
- */
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoAdapterFactory;
-import org.eclipse.jem.internal.java.beaninfo.IIntrospectionAdapter;
-import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
-
-/**
- * Static initializer class to initialize the beaninfo stuff.
- * It is disconnected from the desktop and so doesn't require it.
- */
-
-public class Init {
-	
-	// So it can't be instantiated.
-	private Init() {
-	};
-
-	/**
-	 * Initialize the context with an IBeaninfoSupplier, used to set up the
-	 * introspection process. 
-	 *
-	 * The beaninfo supplier is responsible for setting up the bean info search path,
-	 * including removing the sun beaninfos, if desired.
-	 */
-	public static void initialize(ResourceSet rset, final IBeaninfoSupplier supplier) {
-		rset.getAdapterFactories().add(new BeaninfoAdapterFactory(supplier));
-	}
-
-	/**
-	 * Initialize the registry now that it is available.
-	 */
-	public static void initialize(ProxyFactoryRegistry registry) {
-		// Remove the "sun.beans.info" from the beaninfo search path because
-		// we completely override the sun bean infos.
-		Utilities.removeBeanInfoPath(registry, "sun.beans.infos"); //$NON-NLS-1$
-	}
-
-	/**
-	 * Cleanup from the context because we are being removed.
-	 * If clearResults is true, then the factory should clear the results of introspection
-	 * from the everything because the context will still be around.
-	 */
-	public static void cleanup(ResourceSet rset, boolean clearResults) {
-		BeaninfoAdapterFactory factory =
-			(BeaninfoAdapterFactory) EcoreUtil.getAdapterFactory(rset.getAdapterFactories(), IIntrospectionAdapter.ADAPTER_KEY);
-		rset.getAdapterFactories().remove(factory);
-		if (factory != null)
-			factory.closeAll(clearResults);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/SearchpathEntry.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/SearchpathEntry.java
deleted file mode 100644
index ff80e01..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/SearchpathEntry.java
+++ /dev/null
@@ -1,189 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: SearchpathEntry.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.w3c.dom.*;
-
-import org.eclipse.jem.internal.beaninfo.adapters.*;
-
-/**
- * Searchpath entry. Beaninfo searchpath entry (i.e. package name). Can include
- * kind/path/exported if not a child of the BeaninfoEntry.
- * 
- * Note: if not a child of a BeanInfoEntry, then the path refers to a package
- * in the classpath, so container is supported here.
- * 
- * @version 	1.0
- * @author
- */
-public class SearchpathEntry implements IBeaninfosDocEntry {
-
-	final static String sSearchpath = "searchpath"; // Searchpath entry, shared with BeaninfosDoc. //$NON-NLS-1$
-	final static String sPackage = "package"; // Package name. //$NON-NLS-1$
-
-	/**
-	 * Read the entry in from the element.
-	 */
-	public static SearchpathEntry readEntry(IReader reader, Object element, IProject project, boolean beaninfoChild) {
-		String packageName = reader.getAttribute(element, sPackage);
-		if (beaninfoChild)
-			return new SearchpathEntry(packageName); // Kind/path aren't valid on beaninfo children.
-
-		String elementKind = reader.getAttribute(element, BeaninfosDoc.sKind);
-		String pathStr = reader.getAttribute(element, BeaninfosDoc.sPath);
-		int kind = BeaninfoEntry.kindFromString(elementKind);		
-		IPath path = null;
-		if (pathStr != null) {
-			// ensure path is absolute
-			path = new Path(pathStr);
-			if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && !path.isAbsolute()) {
-				path = project != null ? project.getFullPath().append(path) : path.makeAbsolute(); // Some folder/jar within this project
-			}
-		}
-
-		// create the appropriate entry
-		boolean valid = true;
-		switch (kind) {
-
-			case IClasspathEntry.CPE_LIBRARY :
-				valid = path != null && path.isAbsolute();
-				break;
-
-			case IClasspathEntry.CPE_SOURCE :
-				if (path == null)
-					valid = false;
-				else if (path.isAbsolute()) {
-					// must be an entry in this project or specify another project
-					String projSegment = path.segment(0);
-					if (project == null || projSegment == null || !projSegment.equals(project.getName())) {
-						// another project
-						kind = IClasspathEntry.CPE_PROJECT;
-					}
-				}
-				break;
-
-			case IClasspathEntry.CPE_VARIABLE :
-			case IClasspathEntry.CPE_CONTAINER:				
-				break;
-
-			default :
-				valid = false;
-				break;
-		}
-
-		if (valid)
-			return new SearchpathEntry(kind, path, packageName);
-		else
-			return null;
-
-	}
-
-	protected int kind = -1; // Under Beaninfo entry, these don't have kind/path's.
-	protected IPath path;	// Path can be null if under beaninfo entry
-	protected String packageName;	// Packagename can be null if kind/path refer to a project or registered variable.
-	protected boolean isExported;
-
-	public SearchpathEntry(int kind, IPath path, String packageName) {
-		this.kind = kind;
-		this.path = path;
-		this.packageName = packageName;
-	}
-
-	public SearchpathEntry(String packageName) {
-		this.packageName = packageName;
-	}
-
-	public int getKind() {
-		return kind;
-	}
-	
-	public IPath getPath() {
-		return path;
-	}
-
-	public String getPackage() {
-		return packageName;
-	}
-
-	public Node writeEntry(Document doc, IProject project) {
-
-		Element element = doc.createElement(sSearchpath);
-		if (kind != -1) {
-			// A non-beaninfo child
-			element.setAttribute(BeaninfosDoc.sKind, BeaninfoEntry.kindToString(kind));
-			IPath tPath = path;
-			if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER) {
-				// translate to project relative from absolute (unless a device path)
-				if (tPath.isAbsolute()) {
-					if (tPath.segment(0).equals(project.getFullPath().segment(0))) {
-						tPath = tPath.removeFirstSegments(1);
-						tPath = tPath.makeRelative();
-					} else {
-						tPath = tPath.makeAbsolute();
-					}
-				}
-			}
-
-			element.setAttribute(BeaninfosDoc.sPath, tPath.toString());
-		}
-		if (packageName != null)
-			element.setAttribute(sPackage, packageName);
-		return element;
-	}
-	
-	public boolean equals(Object other) {
-		if (this == other)
-			return true;
-			
-		if (!(other instanceof SearchpathEntry))
-			return false;
-	
-		SearchpathEntry otherEntry = (SearchpathEntry) other;
-		if (kind != otherEntry.kind)
-			return false;
-			
-		if (path == null)
-			if (otherEntry.path != null)
-				return false;
-			else
-				;
-		else if (!path.equals(otherEntry.path))
-			return false;
-			
-		if (packageName == null)
-			if (otherEntry.packageName != null)
-				return false;
-			else
-				;
-		else if (!packageName.equals(otherEntry.packageName))
-			return false;
-			
-		return true;
-	}
-	
-	public int hashCode() {
-		int hashCode = kind;
-		if (path != null)
-			hashCode ^= path.hashCode();
-		if (packageName != null)
-			hashCode ^= packageName.hashCode();
-		return hashCode;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Utilities.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Utilities.java
deleted file mode 100644
index 3e2643e..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Utilities.java
+++ /dev/null
@@ -1,497 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.core;
-/*
- *  $RCSfile: Utilities.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:28 $ 
- */
-import java.util.Iterator;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-
-import org.eclipse.jem.internal.beaninfo.*;
-import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature;
-import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoProxyConstants;
-import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.java.*;
-
-/**
- * Beaninfo (introspection) utilities methods
- */
-
-public final class Utilities {
-	
-	private Utilities() {
-	}
-
-	/**
-	 * Utility to return the class as a JavaClass. If it actually is a JavaType this will
-	 * fail with a ClassCastException.
-	 * @param className
-	 * @param rset
-	 * @return java class
-	 * 
-	 * @throws ClassCastException if not a java class, but instead a java primitive.
-	 * @since 1.1.0
-	 */
-	public static JavaClass getJavaClass(String className, ResourceSet rset) {
-		return (JavaClass) getJavaType(className, rset);
-	}
-	
-	/**
-	 * Utility to return the class as a JavaHelpers.
-	 * 
-	 * @param className
-	 * @param rset
-	 * @return java helpers.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static JavaHelpers getJavaType(String className, ResourceSet rset) {
-		return (JavaHelpers) rset.getEObject(getJavaClassURI(className), true);
-	}
-	
-	/**
-	 * Create a URI to the given classname.
-	 * <p>
-	 * Note: It must be in normal form, i.e. fully-qualified, if primitive spelled out (e.g. "int" not I), and if
-	 * arrays it must readable form (e.g. "new java.lang.String[]" and not "[Ljava.lang.String;").
-	 * 
-	 * @param className
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static URI getJavaClassURI(String className) {
-		return URI.createURI((new JavaURL(className)).getFullString());
-	}
-
-	/** 
-	 * Utility to return the EClassifier from the given IBeanTypeProxy.
-	 */
-	public static EClassifier getJavaClass(IBeanTypeProxy type, ResourceSet rset) {
-		if (type != null) {
-			return getJavaType(type.getFormalTypeName(), rset);
-		} else
-			return null;
-	}
-
-	/**
-	 * Utility to return the Method from the given IMethodProxy.
-	 */
-	public static Method getMethod(IMethodProxy method, ResourceSet rset) {
-		return method != null ? (Method) rset.getEObject(URI.createURI(getMethodURL(method)), true) : null;
-	}
-
-	/**
-	 * Answer the URL String for Method from the given IMethodProxy
-	 */
-	public static String getMethodURL(IMethodProxy method) {
-		String className = method.getClassType().getTypeName();
-		IBeanTypeProxy[] parms = method.getParameterTypes();
-		String[] parmTypes = parms.length > 0 ? new String[parms.length] : null;
-		for (int i = 0; i < parms.length; i++) {
-			parmTypes[i] = parms[i].getFormalTypeName();
-		}
-		return computeMethodURL(className, method.getName(), parmTypes);
-	}
-	
-	protected static String computeMethodURL(String fullyQualifiedClassName, String methodName, String[] parmTypes) {
-		int classStart = fullyQualifiedClassName.lastIndexOf('.');
-		StringBuffer url = new StringBuffer(50);
-		url.append("java:/"); //$NON-NLS-1$
-		if (classStart > -1)
-			url.append(fullyQualifiedClassName.substring(0, classStart));
-		url.append('#');
-		url.append(computeMethodID(fullyQualifiedClassName.substring(classStart + 1), methodName, parmTypes));
-		return url.toString();
-	}
-	
-	protected static String computeFieldURL(String fullyQualifiedClassName, String fieldName) {
-		int classStart = fullyQualifiedClassName.lastIndexOf('.');
-		StringBuffer url = new StringBuffer(50);
-		url.append("java:/"); //$NON-NLS-1$
-		if (classStart > -1)
-			url.append(fullyQualifiedClassName.substring(0, classStart));
-		url.append('#');
-		url.append(fullyQualifiedClassName.substring(classStart + 1));
-		url.append(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
-		url.append(fieldName);
-		return url.toString();
-	}
-	
-	/**
-	 * Return the field uri for the given classname, fieldname.
-	 * @param fullyQualifiedClassName
-	 * @param fieldName
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static URI getFieldURI(String fullyQualifiedClassName, String fieldName) {
-		return URI.createURI(computeFieldURL(fullyQualifiedClassName, fieldName));
-	}
-	/**
-	 * Return the method uri for the given classname, methodname, parm types.
-	 * @param fullyQualifiedClassName
-	 * @param methodName
-	 * @param parmTypes <code>null</code> if there are no parms.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static URI getMethodURI(String fullyQualifiedClassName, String methodName, String[] parmTypes) {
-		return URI.createURI(computeMethodURL(fullyQualifiedClassName, methodName, parmTypes));
-	}
-
-	/**
-	 * Turn it into an URI.
-	 */
-	public static URI getMethodURI(IMethodProxy method) {
-		return URI.createURI(getMethodURL(method));
-	}
-
-	/**
-	 * Utility to compute the Java Modeling METHODID from method declaring class name,
-	 * method name, and parameter class names.
-	 */
-	public static String computeMethodID(String className, String methodName, String[] parameterTypes) {
-		StringBuffer out = new StringBuffer(50);
-		out.append(className);
-		out.append(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
-		out.append(methodName);
-		out.append(ReflectionAdaptor.C_METHOD_PARM_DELIMITER);
-		if (parameterTypes != null)
-			for (int i = 0; i < parameterTypes.length; i++) {
-				out.append(parameterTypes[i]);
-				if (i < parameterTypes.length - 1)
-					out.append(ReflectionAdaptor.C_PARM_PARM_DELIMITER);
-			}
-		if (className.equals(methodName))
-			out.append(ReflectionAdaptor.S_CONSTRUCTOR_TOKEN); //It's a constructor
-		return out.toString();
-	}
-
-	/**
-	 * Utility to retrieve the BeanDecorator.
-	 */
-	public static BeanDecorator getBeanDecorator(EModelElement model) {
-		return (BeanDecorator) getDecorator(model, BeanDecorator.class);
-	}
-	/**
-	 * Utility to retrieve a decorator of the specified class.
-	 */
-	public static EAnnotation getDecorator(EModelElement model, Class decoratorClass) {
-		Iterator itr = model.getEAnnotations().iterator();
-		while (itr.hasNext()) {
-			EAnnotation decr = (EAnnotation) itr.next();
-			if (decoratorClass.isInstance(decr))
-				return decr;
-		}
-		return null;
-	}
-
-	/**
-	 * Utility to retrieve the EventSetDecorator.
-	 */
-	public static EventSetDecorator getEventSetDecorator(EModelElement model) {
-		return (EventSetDecorator) getDecorator(model, EventSetDecorator.class);
-	}
-
-	/**
-	 * Utility to retrieve the MethodDecorator.
-	 */
-	public static MethodDecorator getMethodDecorator(EModelElement model) {
-		return (MethodDecorator) getDecorator(model, MethodDecorator.class);
-	}
-
-	/**
-	 * Utility to retrieve the PropertyDecorator.
-	 */
-	public static PropertyDecorator getPropertyDecorator(EModelElement model) {
-		return (PropertyDecorator) getDecorator(model, PropertyDecorator.class);
-	}
-
-	/**
-	 * Utility to return an iterator on the list which will return the property decorators
-	 * of only the properties in the EList passed in. If the property does not have a
-	 * property decorator, then it is not a beaninfo property.
-	 */
-	public static Iterator getPropertiesIterator(final EList properties) {
-		return new Iterator() {
-			private Iterator itr = properties.iterator();
-			private boolean hasNext = true;
-			private PropertyDecorator next;
-			{
-				findNext();
-			}
-			public boolean hasNext() {
-				return hasNext;
-			}
-
-			public Object next() {
-				PropertyDecorator temp = next;
-				findNext();
-				return temp;
-			}
-
-			public void remove() {
-				throw new UnsupportedOperationException();
-			}
-
-			private void findNext() {
-				while (itr.hasNext()) {
-					EModelElement nextOne = (EModelElement) itr.next();
-					next = getPropertyDecorator(nextOne);
-					if (next != null) {
-						return;
-					}
-				}
-				hasNext = false;
-			}
-		};
-	}
-
-	/**
-	 * Utility to return an iterator on the list which will return the EventSet decorators
-	 * of only the BeanEvents in the EList passed in.
-	 */
-	public static Iterator getEventSetsIterator(final EList events) {
-		return new Iterator() {
-			private Iterator itr = events.iterator();
-			private boolean hasNext = true;
-			private EventSetDecorator next;
-			{
-				findNext();
-			}
-			public boolean hasNext() {
-				return hasNext;
-			}
-
-			public Object next() {
-				EventSetDecorator temp = next;
-				findNext();
-				return temp;
-			}
-
-			public void remove() {
-				throw new UnsupportedOperationException();
-			}
-
-			private void findNext() {
-				while (itr.hasNext()) {
-					EModelElement nextOne = (EModelElement) itr.next();
-					next = getEventSetDecorator(nextOne);
-					if (next != null) {
-						return;
-					}
-				}
-				hasNext = false;
-			}
-		};
-	}
-
-	/**
-	 * Utility to return an iterator on the list which will return the Method decorators
-	 * of only the Methods in the EList passed in.
-	 */
-	public static Iterator getMethodsIterator(final EList methods) {
-		return new Iterator() {
-			private Iterator itr = methods.iterator();
-			private boolean hasNext = true;
-			private MethodDecorator next;
-			{
-				findNext();
-			}
-			public boolean hasNext() {
-				return hasNext;
-			}
-
-			public Object next() {
-				MethodDecorator temp = next;
-				findNext();
-				return temp;
-			}
-
-			public void remove() {
-				throw new UnsupportedOperationException();
-			}
-
-			private void findNext() {
-				while (itr.hasNext()) {
-					EModelElement nextOne = (EModelElement) itr.next();
-					next = getMethodDecorator(nextOne);
-					if (next != null) {
-						return;
-					}
-				}
-				hasNext = false;
-			}
-		};
-	}
-
-	/**
-	 * Get the search path from the remote vm. 
-	 * 
-	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
-	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
-	 * saved across invocations of the workspace if it is not updated through the nature).
-	 */
-	public static IArrayBeanProxy getBeanInfoSearchPath(ProxyFactoryRegistry registry) {
-		return (IArrayBeanProxy) BeaninfoProxyConstants
-			.getConstants(registry)
-			.getGetBeanInfoSearchPathProxy()
-			.invokeCatchThrowableExceptions(
-			null);
-	}
-
-	/**
-	 * Set the search path to the array of strings passed in on the remote vm.
-	 *
-	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
-	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
-	 * saved across invocations of the workspace if it is not updated through the nature).	 
-	 */
-	public static void setBeanInfoSearchPath(ProxyFactoryRegistry registry, String[] paths) {
-
-		try {
-			BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
-			JavaStandardBeanProxyConstants jConstants = JavaStandardBeanProxyConstants.getConstants(registry);
-			IStandardBeanProxyFactory proxyFactory = registry.getBeanProxyFactory();
-			IArrayBeanProxy newPath = proxyFactory.createBeanProxyWith(jConstants.getStringType(), paths != null ? paths.length : 0);
-			if (paths != null)
-				for (int i = 0; i < paths.length; i++)
-					newPath.set(proxyFactory.createBeanProxyWith(paths[i]), i);
-			biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
-		} catch (ThrowableProxy e) {
-		}
-	}
-
-	/**
-	 * From the Beaninfo Nature, insert a path to the beaninfo path at the given index, -1 means at the end.
-	 * If index is larger than the current path, it will also add at the end.
-	 */
-	public static void insertBeanInfoSearchPath(BeaninfoNature nature, IBeaninfosDocEntry path, int index) throws CoreException {
-		BeaninfosDoc infoPath = nature.getSearchPath();
-		IBeaninfosDocEntry[] oldPath = infoPath.getSearchpath();
-
-		IBeaninfosDocEntry[] newPath = new IBeaninfosDocEntry[oldPath.length + 1];
-
-		if (index == -1 || index >= oldPath.length) {
-			// At the end or past end
-			System.arraycopy(oldPath, 0, newPath, 0, oldPath.length);
-			newPath[oldPath.length] = path;
-		} else {
-			// In the middle
-			System.arraycopy(oldPath, 0, newPath, 0, index);
-			newPath[index] = path;
-			System.arraycopy(oldPath, index, newPath, index + 1, oldPath.length - index);
-		}
-
-		infoPath.setSearchpath(newPath);
-		nature.setSearchPath(infoPath);
-	}
-
-	/**
-	 * Insert a path to the beaninfo path at the given index, -1 means at the end.
-	 * If index is larger than the current path, it will also add at the end.
-	 *
-	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
-	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
-	 * saved across invocations of the workspace if it is not updated through the nature).	 
-	 */
-	public static void insertBeanInfoSearchPath(ProxyFactoryRegistry registry, String path, int index) {
-		try {
-			BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
-			IArrayBeanProxy infoPath = (IArrayBeanProxy) biConstants.getGetBeanInfoSearchPathProxy().invoke(null);
-			int pathLength = infoPath.getLength();
-
-			IStandardBeanProxyFactory proxyFactory = registry.getBeanProxyFactory();
-
-			IArrayBeanProxy newPath = proxyFactory.createBeanProxyWith(infoPath.getTypeProxy(), pathLength + 1);
-			IBeanProxy stringProxy = proxyFactory.createBeanProxyWith(path);
-
-			JavaStandardBeanProxyConstants constants = JavaStandardBeanProxyConstants.getConstants(registry);
-			if (index == -1 || index >= pathLength) {
-				// At the end or past end
-				constants.arraycopy(infoPath, 0, newPath, 0, infoPath.getLength());
-				newPath.set(stringProxy, pathLength);
-			} else {
-				// In the middle
-				constants.arraycopy(infoPath, 0, newPath, 0, index);
-				newPath.set(stringProxy, index);
-				constants.arraycopy(infoPath, index, newPath, index + 1, pathLength - index);
-			}
-
-			biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
-		} catch (ThrowableProxy e) {
-		}
-	}
-
-	/**
-	 * From the Beaninfo Nature, remove the specified path from the beaninfo search path.
-	 * Not an error if not found.
-	 */
-	public static void removeBeanInfoPath(BeaninfoNature nature, IBeaninfosDocEntry path) throws CoreException {
-		BeaninfosDoc infoPath = nature.getSearchPath();
-		IBeaninfosDocEntry[] oldPath = infoPath.getSearchpath();
-
-		for (int i = 0; i < oldPath.length; i++) {
-			if (path.equals(oldPath[i])) {
-				// We found it, so remove it.
-				IBeaninfosDocEntry[] newPath = new IBeaninfosDocEntry[oldPath.length - 1];
-				System.arraycopy(oldPath, 0, newPath, 0, i);
-				if (i < oldPath.length - 1)
-					System.arraycopy(oldPath, i + 1, newPath, i, oldPath.length - i - 1);
-				infoPath.setSearchpath(newPath);
-				nature.setSearchPath(infoPath);
-				return;
-			}
-		}
-	}
-
-	/**
-	 * Remove the specified path from the beaninfo search path.
-	 * Not an error if not found.
-	 *
-	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
-	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
-	 * saved across invocations of the workspace if it is not updated through the nature).	 	 
-	 */
-	public static void removeBeanInfoPath(ProxyFactoryRegistry registry, String path) {
-		try {
-			BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
-			IArrayBeanProxy infoPath = (IArrayBeanProxy) biConstants.getGetBeanInfoSearchPathProxy().invoke(null);
-			int pathLength = infoPath.getLength();
-
-			for (int i = 0; i < pathLength; i++) {
-				IStringBeanProxy aPath = (IStringBeanProxy) infoPath.get(i);
-				if (path.equals(aPath.stringValue())) {
-					// We found it, so remove it.
-					IArrayBeanProxy newPath = registry.getBeanProxyFactory().createBeanProxyWith(infoPath.getTypeProxy(), pathLength - 1);
-					JavaStandardBeanProxyConstants constants = JavaStandardBeanProxyConstants.getConstants(registry);
-					constants.arraycopy(infoPath, 0, newPath, 0, i);
-					if (i < pathLength - 1)
-						constants.arraycopy(infoPath, i + 1, newPath, i, pathLength - i - 1);
-					biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
-					return;
-				}
-			}
-		} catch (ThrowableProxy e) {
-		}
-	};
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/messages.properties b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/messages.properties
deleted file mode 100644
index a634116..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/messages.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2004, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-BeanInfoCacheController_Job_WriteBeaninfoCache_Title=Write BeanInfo cache files
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeanDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeanDecoratorImpl.java
deleted file mode 100644
index e4ef73e..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeanDecoratorImpl.java
+++ /dev/null
@@ -1,1072 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: BeanDecoratorImpl.java,v $
- *  $Revision: 1.22 $  $Date: 2005/10/18 15:32:19 $ 
- */
-
-
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.Collection;
-import java.util.logging.Level;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.beaninfo.common.IBaseBeanInfoConstants;
-import org.eclipse.jem.internal.beaninfo.BeanDecorator;
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-
-import org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue;
-import org.eclipse.jem.internal.beaninfo.core.*;
-import org.eclipse.jem.java.JavaClass;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Bean Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isMergeSuperProperties <em>Merge Super Properties</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isMergeSuperMethods <em>Merge Super Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isMergeSuperEvents <em>Merge Super Events</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isIntrospectProperties <em>Introspect Properties</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isIntrospectMethods <em>Introspect Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isIntrospectEvents <em>Introspect Events</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#isDoBeaninfo <em>Do Beaninfo</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#getNotInheritedPropertyNames <em>Not Inherited Property Names</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#getNotInheritedMethodNames <em>Not Inherited Method Names</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#getNotInheritedEventNames <em>Not Inherited Event Names</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.BeanDecoratorImpl#getCustomizerClass <em>Customizer Class</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-
-public class BeanDecoratorImpl extends FeatureDecoratorImpl implements BeanDecorator{
-	
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 */
-	public static final long BEAN_CUSTOMIZER_IMPLICIT = 0x1L;
-	public static final long BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT = 0x2L;
-	public static final long BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT = 0x4L;
-	public static final long BEAN_MERGE_INHERITED_EVENTS_IMPLICIT = 0x8L;
-
-	/**
-	 * The default value of the '{@link #isMergeSuperProperties() <em>Merge Super Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeSuperProperties()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean MERGE_SUPER_PROPERTIES_EDEFAULT = true;
-	
-	/**
-	 * The flag representing the value of the '{@link #isMergeSuperProperties() <em>Merge Super Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeSuperProperties()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_SUPER_PROPERTIES_EFLAG = 1 << 18;
-
-	/**
-	 * The flag representing whether the Merge Super Properties attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_SUPER_PROPERTIES_ESETFLAG = 1 << 19;
-
-	/**
-	 * The default value of the '{@link #isMergeSuperMethods() <em>Merge Super Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeSuperMethods()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean MERGE_SUPER_METHODS_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isMergeSuperMethods() <em>Merge Super Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeSuperMethods()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_SUPER_METHODS_EFLAG = 1 << 20;
-
-	/**
-	 * The flag representing whether the Merge Super Methods attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_SUPER_METHODS_ESETFLAG = 1 << 21;
-
-	/**
-	 * The default value of the '{@link #isMergeSuperEvents() <em>Merge Super Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeSuperEvents()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean MERGE_SUPER_EVENTS_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isMergeSuperEvents() <em>Merge Super Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeSuperEvents()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_SUPER_EVENTS_EFLAG = 1 << 22;
-
-	/**
-	 * The flag representing whether the Merge Super Events attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_SUPER_EVENTS_ESETFLAG = 1 << 23;
-
-	/**
-	 * The default value of the '{@link #isIntrospectProperties() <em>Introspect Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIntrospectProperties()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean INTROSPECT_PROPERTIES_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isIntrospectProperties() <em>Introspect Properties</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIntrospectProperties()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int INTROSPECT_PROPERTIES_EFLAG = 1 << 24;
-
-	/**
-	 * The default value of the '{@link #isIntrospectMethods() <em>Introspect Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIntrospectMethods()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean INTROSPECT_METHODS_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isIntrospectMethods() <em>Introspect Methods</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIntrospectMethods()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int INTROSPECT_METHODS_EFLAG = 1 << 25;
-
-	/**
-	 * The default value of the '{@link #isIntrospectEvents() <em>Introspect Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIntrospectEvents()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean INTROSPECT_EVENTS_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isIntrospectEvents() <em>Introspect Events</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIntrospectEvents()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int INTROSPECT_EVENTS_EFLAG = 1 << 26;
-
-	/**
-	 * The default value of the '{@link #isDoBeaninfo() <em>Do Beaninfo</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isDoBeaninfo()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean DO_BEANINFO_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isDoBeaninfo() <em>Do Beaninfo</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isDoBeaninfo()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int DO_BEANINFO_EFLAG = 1 << 27;
-
-	/**
-	 * The cached value of the '{@link #getNotInheritedPropertyNames() <em>Not Inherited Property Names</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNotInheritedPropertyNames()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList notInheritedPropertyNames = null;
-
-	/**
-	 * The cached value of the '{@link #getNotInheritedMethodNames() <em>Not Inherited Method Names</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNotInheritedMethodNames()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList notInheritedMethodNames = null;
-
-	/**
-	 * The cached value of the '{@link #getNotInheritedEventNames() <em>Not Inherited Event Names</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNotInheritedEventNames()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList notInheritedEventNames = null;
-
-	/**
-	 * The cached value of the '{@link #getCustomizerClass() <em>Customizer Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getCustomizerClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected JavaClass customizerClass = null;
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	protected BeanDecoratorImpl() {
-		super();
-		eFlags |= MERGE_SUPER_PROPERTIES_EFLAG;
-		eFlags |= MERGE_SUPER_METHODS_EFLAG;
-		eFlags |= MERGE_SUPER_EVENTS_EFLAG;
-		eFlags |= INTROSPECT_PROPERTIES_EFLAG;
-		eFlags |= INTROSPECT_METHODS_EFLAG;
-		eFlags |= INTROSPECT_EVENTS_EFLAG;
-		eFlags |= DO_BEANINFO_EFLAG;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getBeanDecorator();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isMergeSuperProperties() {
-		return (eFlags & MERGE_SUPER_PROPERTIES_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMergeSuperProperties(boolean newMergeSuperProperties) {
-		boolean oldMergeSuperProperties = (eFlags & MERGE_SUPER_PROPERTIES_EFLAG) != 0;
-		if (newMergeSuperProperties) eFlags |= MERGE_SUPER_PROPERTIES_EFLAG; else eFlags &= ~MERGE_SUPER_PROPERTIES_EFLAG;
-		boolean oldMergeSuperPropertiesESet = (eFlags & MERGE_SUPER_PROPERTIES_ESETFLAG) != 0;
-		eFlags |= MERGE_SUPER_PROPERTIES_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_PROPERTIES, oldMergeSuperProperties, newMergeSuperProperties, !oldMergeSuperPropertiesESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetMergeSuperProperties() {
-		boolean oldMergeSuperProperties = (eFlags & MERGE_SUPER_PROPERTIES_EFLAG) != 0;
-		boolean oldMergeSuperPropertiesESet = (eFlags & MERGE_SUPER_PROPERTIES_ESETFLAG) != 0;
-		if (MERGE_SUPER_PROPERTIES_EDEFAULT) eFlags |= MERGE_SUPER_PROPERTIES_EFLAG; else eFlags &= ~MERGE_SUPER_PROPERTIES_EFLAG;
-		eFlags &= ~MERGE_SUPER_PROPERTIES_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_PROPERTIES, oldMergeSuperProperties, MERGE_SUPER_PROPERTIES_EDEFAULT, oldMergeSuperPropertiesESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetMergeSuperProperties() {
-		return (eFlags & MERGE_SUPER_PROPERTIES_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isMergeSuperMethods() {
-		return (eFlags & MERGE_SUPER_METHODS_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMergeSuperMethods(boolean newMergeSuperMethods) {
-		boolean oldMergeSuperMethods = (eFlags & MERGE_SUPER_METHODS_EFLAG) != 0;
-		if (newMergeSuperMethods) eFlags |= MERGE_SUPER_METHODS_EFLAG; else eFlags &= ~MERGE_SUPER_METHODS_EFLAG;
-		boolean oldMergeSuperMethodsESet = (eFlags & MERGE_SUPER_METHODS_ESETFLAG) != 0;
-		eFlags |= MERGE_SUPER_METHODS_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_METHODS, oldMergeSuperMethods, newMergeSuperMethods, !oldMergeSuperMethodsESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetMergeSuperMethods() {
-		boolean oldMergeSuperMethods = (eFlags & MERGE_SUPER_METHODS_EFLAG) != 0;
-		boolean oldMergeSuperMethodsESet = (eFlags & MERGE_SUPER_METHODS_ESETFLAG) != 0;
-		if (MERGE_SUPER_METHODS_EDEFAULT) eFlags |= MERGE_SUPER_METHODS_EFLAG; else eFlags &= ~MERGE_SUPER_METHODS_EFLAG;
-		eFlags &= ~MERGE_SUPER_METHODS_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_METHODS, oldMergeSuperMethods, MERGE_SUPER_METHODS_EDEFAULT, oldMergeSuperMethodsESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetMergeSuperMethods() {
-		return (eFlags & MERGE_SUPER_METHODS_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isMergeSuperEvents() {
-		return (eFlags & MERGE_SUPER_EVENTS_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMergeSuperEvents(boolean newMergeSuperEvents) {
-		boolean oldMergeSuperEvents = (eFlags & MERGE_SUPER_EVENTS_EFLAG) != 0;
-		if (newMergeSuperEvents) eFlags |= MERGE_SUPER_EVENTS_EFLAG; else eFlags &= ~MERGE_SUPER_EVENTS_EFLAG;
-		boolean oldMergeSuperEventsESet = (eFlags & MERGE_SUPER_EVENTS_ESETFLAG) != 0;
-		eFlags |= MERGE_SUPER_EVENTS_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_EVENTS, oldMergeSuperEvents, newMergeSuperEvents, !oldMergeSuperEventsESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetMergeSuperEvents() {
-		boolean oldMergeSuperEvents = (eFlags & MERGE_SUPER_EVENTS_EFLAG) != 0;
-		boolean oldMergeSuperEventsESet = (eFlags & MERGE_SUPER_EVENTS_ESETFLAG) != 0;
-		if (MERGE_SUPER_EVENTS_EDEFAULT) eFlags |= MERGE_SUPER_EVENTS_EFLAG; else eFlags &= ~MERGE_SUPER_EVENTS_EFLAG;
-		eFlags &= ~MERGE_SUPER_EVENTS_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_EVENTS, oldMergeSuperEvents, MERGE_SUPER_EVENTS_EDEFAULT, oldMergeSuperEventsESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetMergeSuperEvents() {
-		return (eFlags & MERGE_SUPER_EVENTS_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isIntrospectProperties() {
-		return (eFlags & INTROSPECT_PROPERTIES_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIntrospectProperties(boolean newIntrospectProperties) {
-		boolean oldIntrospectProperties = (eFlags & INTROSPECT_PROPERTIES_EFLAG) != 0;
-		if (newIntrospectProperties) eFlags |= INTROSPECT_PROPERTIES_EFLAG; else eFlags &= ~INTROSPECT_PROPERTIES_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_PROPERTIES, oldIntrospectProperties, newIntrospectProperties));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isIntrospectMethods() {
-		return (eFlags & INTROSPECT_METHODS_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIntrospectMethods(boolean newIntrospectMethods) {
-		boolean oldIntrospectMethods = (eFlags & INTROSPECT_METHODS_EFLAG) != 0;
-		if (newIntrospectMethods) eFlags |= INTROSPECT_METHODS_EFLAG; else eFlags &= ~INTROSPECT_METHODS_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_METHODS, oldIntrospectMethods, newIntrospectMethods));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isIntrospectEvents() {
-		return (eFlags & INTROSPECT_EVENTS_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIntrospectEvents(boolean newIntrospectEvents) {
-		boolean oldIntrospectEvents = (eFlags & INTROSPECT_EVENTS_EFLAG) != 0;
-		if (newIntrospectEvents) eFlags |= INTROSPECT_EVENTS_EFLAG; else eFlags &= ~INTROSPECT_EVENTS_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_EVENTS, oldIntrospectEvents, newIntrospectEvents));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setCustomizerClass(JavaClass newCustomizerClass) {
-		JavaClass oldCustomizerClass = customizerClass;
-		customizerClass = newCustomizerClass;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__CUSTOMIZER_CLASS, oldCustomizerClass, customizerClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.BEAN_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.BEAN_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.BEAN_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.BEAN_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.BEAN_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.BEAN_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.BEAN_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.BEAN_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.BEAN_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.BEAN_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.BEAN_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.BEAN_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_PROPERTIES:
-				return isMergeSuperProperties() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_METHODS:
-				return isMergeSuperMethods() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_EVENTS:
-				return isMergeSuperEvents() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_PROPERTIES:
-				return isIntrospectProperties() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_METHODS:
-				return isIntrospectMethods() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_EVENTS:
-				return isIntrospectEvents() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__DO_BEANINFO:
-				return isDoBeaninfo() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES:
-				return getNotInheritedPropertyNames();
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES:
-				return getNotInheritedMethodNames();
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES:
-				return getNotInheritedEventNames();
-			case BeaninfoPackage.BEAN_DECORATOR__CUSTOMIZER_CLASS:
-				if (resolve) return getCustomizerClass();
-				return basicGetCustomizerClass();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_PROPERTIES:
-				setMergeSuperProperties(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_METHODS:
-				setMergeSuperMethods(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_EVENTS:
-				setMergeSuperEvents(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_PROPERTIES:
-				setIntrospectProperties(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_METHODS:
-				setIntrospectMethods(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_EVENTS:
-				setIntrospectEvents(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__DO_BEANINFO:
-				setDoBeaninfo(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES:
-				getNotInheritedPropertyNames().clear();
-				getNotInheritedPropertyNames().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES:
-				getNotInheritedMethodNames().clear();
-				getNotInheritedMethodNames().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES:
-				getNotInheritedEventNames().clear();
-				getNotInheritedEventNames().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__CUSTOMIZER_CLASS:
-				setCustomizerClass((JavaClass)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_PROPERTIES:
-				unsetMergeSuperProperties();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_METHODS:
-				unsetMergeSuperMethods();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_EVENTS:
-				unsetMergeSuperEvents();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_PROPERTIES:
-				setIntrospectProperties(INTROSPECT_PROPERTIES_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_METHODS:
-				setIntrospectMethods(INTROSPECT_METHODS_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_EVENTS:
-				setIntrospectEvents(INTROSPECT_EVENTS_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__DO_BEANINFO:
-				setDoBeaninfo(DO_BEANINFO_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES:
-				getNotInheritedPropertyNames().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES:
-				getNotInheritedMethodNames().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES:
-				getNotInheritedEventNames().clear();
-				return;
-			case BeaninfoPackage.BEAN_DECORATOR__CUSTOMIZER_CLASS:
-				setCustomizerClass((JavaClass)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eIsSet(org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_DECORATOR__SOURCE:
-				return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			default:
-				return eIsSetGen(eFeature);
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.BEAN_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.BEAN_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.BEAN_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.BEAN_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.BEAN_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.BEAN_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.BEAN_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_PROPERTIES:
-				return isSetMergeSuperProperties();
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_METHODS:
-				return isSetMergeSuperMethods();
-			case BeaninfoPackage.BEAN_DECORATOR__MERGE_SUPER_EVENTS:
-				return isSetMergeSuperEvents();
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_PROPERTIES:
-				return ((eFlags & INTROSPECT_PROPERTIES_EFLAG) != 0) != INTROSPECT_PROPERTIES_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_METHODS:
-				return ((eFlags & INTROSPECT_METHODS_EFLAG) != 0) != INTROSPECT_METHODS_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__INTROSPECT_EVENTS:
-				return ((eFlags & INTROSPECT_EVENTS_EFLAG) != 0) != INTROSPECT_EVENTS_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__DO_BEANINFO:
-				return ((eFlags & DO_BEANINFO_EFLAG) != 0) != DO_BEANINFO_EDEFAULT;
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES:
-				return notInheritedPropertyNames != null && !notInheritedPropertyNames.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES:
-				return notInheritedMethodNames != null && !notInheritedMethodNames.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES:
-				return notInheritedEventNames != null && !notInheritedEventNames.isEmpty();
-			case BeaninfoPackage.BEAN_DECORATOR__CUSTOMIZER_CLASS:
-				return customizerClass != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (mergeSuperProperties: ");
-		if ((eFlags & MERGE_SUPER_PROPERTIES_ESETFLAG) != 0) result.append((eFlags & MERGE_SUPER_PROPERTIES_EFLAG) != 0); else result.append("<unset>");
-		result.append(", mergeSuperMethods: ");
-		if ((eFlags & MERGE_SUPER_METHODS_ESETFLAG) != 0) result.append((eFlags & MERGE_SUPER_METHODS_EFLAG) != 0); else result.append("<unset>");
-		result.append(", mergeSuperEvents: ");
-		if ((eFlags & MERGE_SUPER_EVENTS_ESETFLAG) != 0) result.append((eFlags & MERGE_SUPER_EVENTS_EFLAG) != 0); else result.append("<unset>");
-		result.append(", introspectProperties: ");
-		result.append((eFlags & INTROSPECT_PROPERTIES_EFLAG) != 0);
-		result.append(", introspectMethods: ");
-		result.append((eFlags & INTROSPECT_METHODS_EFLAG) != 0);
-		result.append(", introspectEvents: ");
-		result.append((eFlags & INTROSPECT_EVENTS_EFLAG) != 0);
-		result.append(", doBeaninfo: ");
-		result.append((eFlags & DO_BEANINFO_EFLAG) != 0);
-		result.append(", notInheritedPropertyNames: ");
-		result.append(notInheritedPropertyNames);
-		result.append(", notInheritedMethodNames: ");
-		result.append(notInheritedMethodNames);
-		result.append(", notInheritedEventNames: ");
-		result.append(notInheritedEventNames);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass basicGetCustomizerClass() {
-		return customizerClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isDoBeaninfo() {
-		return (eFlags & DO_BEANINFO_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDoBeaninfo(boolean newDoBeaninfo) {
-		boolean oldDoBeaninfo = (eFlags & DO_BEANINFO_EFLAG) != 0;
-		if (newDoBeaninfo) eFlags |= DO_BEANINFO_EFLAG; else eFlags &= ~DO_BEANINFO_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.BEAN_DECORATOR__DO_BEANINFO, oldDoBeaninfo, newDoBeaninfo));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNotInheritedPropertyNames() {
-		if (notInheritedPropertyNames == null) {
-			notInheritedPropertyNames = new EDataTypeUniqueEList(String.class, this, BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES);
-		}
-		return notInheritedPropertyNames;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNotInheritedMethodNames() {
-		if (notInheritedMethodNames == null) {
-			notInheritedMethodNames = new EDataTypeUniqueEList(String.class, this, BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES);
-		}
-		return notInheritedMethodNames;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNotInheritedEventNames() {
-		if (notInheritedEventNames == null) {
-			notInheritedEventNames = new EDataTypeUniqueEList(String.class, this, BeaninfoPackage.BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES);
-		}
-		return notInheritedEventNames;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass getCustomizerClass() {
-		if (customizerClass != null && customizerClass.eIsProxy()) {
-			JavaClass oldCustomizerClass = customizerClass;
-			customizerClass = (JavaClass)eResolveProxy((InternalEObject)customizerClass);
-			if (customizerClass != oldCustomizerClass) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.BEAN_DECORATOR__CUSTOMIZER_CLASS, oldCustomizerClass, customizerClass));
-			}
-		}
-		return customizerClass;
-	}
-
-	private URL iconURL;
-	private boolean hasQueriedIconURL;
-	
-	public URL getIconURL(){
-		if (!hasQueriedIconURL){
-			FeatureAttributeValue value = (FeatureAttributeValue) getAttributes().get(IBaseBeanInfoConstants.ICONCOLOR16X16URL);
-			if (value != null) { 
-				// Get the value
-				Object attr = value.getValue();
-				if (attr instanceof String) {
-					try {
-						hasQueriedIconURL = true;
-						iconURL = new URL((String) attr);
-					} catch ( MalformedURLException exc ) {
-						BeaninfoPlugin.getPlugin().getLogger().log(exc, Level.INFO);
-					}
-				}
-			}			
-		}
-		return iconURL;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeanEventImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeanEventImpl.java
deleted file mode 100644
index 7e74c4d..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeanEventImpl.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: BeanEventImpl.java,v $
- *  $Revision: 1.8 $  $Date: 2005/09/14 23:30:38 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeanEvent;
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.java.internal.impl.JavaEventImpl;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Bean Event</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-
-public class BeanEventImpl extends JavaEventImpl implements BeanEvent{
-
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BeanEventImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getBeanEvent();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.BEAN_EVENT__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.BEAN_EVENT__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS:
-					return eBasicSetContainer(null, BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS:
-					return eContainer.eInverseRemove(this, EcorePackage.ECLASS__ESTRUCTURAL_FEATURES, EClass.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_EVENT__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.BEAN_EVENT__NAME:
-				return getName();
-			case BeaninfoPackage.BEAN_EVENT__ORDERED:
-				return isOrdered() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__UNIQUE:
-				return isUnique() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__LOWER_BOUND:
-				return new Integer(getLowerBound());
-			case BeaninfoPackage.BEAN_EVENT__UPPER_BOUND:
-				return new Integer(getUpperBound());
-			case BeaninfoPackage.BEAN_EVENT__MANY:
-				return isMany() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__REQUIRED:
-				return isRequired() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__ETYPE:
-				if (resolve) return getEType();
-				return basicGetEType();
-			case BeaninfoPackage.BEAN_EVENT__CHANGEABLE:
-				return isChangeable() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__VOLATILE:
-				return isVolatile() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__TRANSIENT:
-				return isTransient() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__DEFAULT_VALUE_LITERAL:
-				return getDefaultValueLiteral();
-			case BeaninfoPackage.BEAN_EVENT__DEFAULT_VALUE:
-				return getDefaultValue();
-			case BeaninfoPackage.BEAN_EVENT__UNSETTABLE:
-				return isUnsettable() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__DERIVED:
-				return isDerived() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS:
-				return getEContainingClass();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_EVENT__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__NAME:
-				setName((String)newValue);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__ORDERED:
-				setOrdered(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__UNIQUE:
-				setUnique(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__LOWER_BOUND:
-				setLowerBound(((Integer)newValue).intValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__UPPER_BOUND:
-				setUpperBound(((Integer)newValue).intValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__ETYPE:
-				setEType((EClassifier)newValue);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__CHANGEABLE:
-				setChangeable(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__VOLATILE:
-				setVolatile(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__TRANSIENT:
-				setTransient(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__DEFAULT_VALUE_LITERAL:
-				setDefaultValueLiteral((String)newValue);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__UNSETTABLE:
-				setUnsettable(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.BEAN_EVENT__DERIVED:
-				setDerived(((Boolean)newValue).booleanValue());
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_EVENT__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.BEAN_EVENT__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__ORDERED:
-				setOrdered(ORDERED_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__UNIQUE:
-				setUnique(UNIQUE_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__LOWER_BOUND:
-				setLowerBound(LOWER_BOUND_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__UPPER_BOUND:
-				setUpperBound(UPPER_BOUND_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__ETYPE:
-				setEType((EClassifier)null);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__CHANGEABLE:
-				setChangeable(CHANGEABLE_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__VOLATILE:
-				setVolatile(VOLATILE_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__TRANSIENT:
-				setTransient(TRANSIENT_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__DEFAULT_VALUE_LITERAL:
-				setDefaultValueLiteral(DEFAULT_VALUE_LITERAL_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__UNSETTABLE:
-				setUnsettable(UNSETTABLE_EDEFAULT);
-				return;
-			case BeaninfoPackage.BEAN_EVENT__DERIVED:
-				setDerived(DERIVED_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.BEAN_EVENT__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.BEAN_EVENT__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case BeaninfoPackage.BEAN_EVENT__ORDERED:
-				return ((eFlags & ORDERED_EFLAG) != 0) != ORDERED_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__UNIQUE:
-				return ((eFlags & UNIQUE_EFLAG) != 0) != UNIQUE_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__LOWER_BOUND:
-				return lowerBound != LOWER_BOUND_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__UPPER_BOUND:
-				return upperBound != UPPER_BOUND_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__MANY:
-				return isMany() != MANY_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__REQUIRED:
-				return isRequired() != REQUIRED_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__ETYPE:
-				return eType != null;
-			case BeaninfoPackage.BEAN_EVENT__CHANGEABLE:
-				return ((eFlags & CHANGEABLE_EFLAG) != 0) != CHANGEABLE_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__VOLATILE:
-				return ((eFlags & VOLATILE_EFLAG) != 0) != VOLATILE_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__TRANSIENT:
-				return ((eFlags & TRANSIENT_EFLAG) != 0) != TRANSIENT_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__DEFAULT_VALUE_LITERAL:
-				return DEFAULT_VALUE_LITERAL_EDEFAULT == null ? defaultValueLiteral != null : !DEFAULT_VALUE_LITERAL_EDEFAULT.equals(defaultValueLiteral);
-			case BeaninfoPackage.BEAN_EVENT__DEFAULT_VALUE:
-				return DEFAULT_VALUE_EDEFAULT == null ? getDefaultValue() != null : !DEFAULT_VALUE_EDEFAULT.equals(getDefaultValue());
-			case BeaninfoPackage.BEAN_EVENT__UNSETTABLE:
-				return ((eFlags & UNSETTABLE_EFLAG) != 0) != UNSETTABLE_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__DERIVED:
-				return ((eFlags & DERIVED_EFLAG) != 0) != DERIVED_EDEFAULT;
-			case BeaninfoPackage.BEAN_EVENT__ECONTAINING_CLASS:
-				return getEContainingClass() != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeaninfoFactoryImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeaninfoFactoryImpl.java
deleted file mode 100644
index 91274c2..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeaninfoFactoryImpl.java
+++ /dev/null
@@ -1,239 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: BeaninfoFactoryImpl.java,v $
- *  $Revision: 1.10 $  $Date: 2005/10/11 21:26:28 $ 
- */
-
-import java.util.Map;
-
-import org.eclipse.jem.internal.beaninfo.*;
-import org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-
-
-public class BeaninfoFactoryImpl extends EFactoryImpl implements BeaninfoFactory{
-
-	/**
-	 * Creates an instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	public BeaninfoFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject create(EClass eClass) {
-		switch (eClass.getClassifierID()) {
-			case BeaninfoPackage.FEATURE_DECORATOR: return createFeatureDecorator();
-			case BeaninfoPackage.BEAN_DECORATOR: return createBeanDecorator();
-			case BeaninfoPackage.EVENT_SET_DECORATOR: return createEventSetDecorator();
-			case BeaninfoPackage.METHOD_DECORATOR: return createMethodDecorator();
-			case BeaninfoPackage.PARAMETER_DECORATOR: return createParameterDecorator();
-			case BeaninfoPackage.PROPERTY_DECORATOR: return createPropertyDecorator();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR: return createIndexedPropertyDecorator();
-			case BeaninfoPackage.METHOD_PROXY: return createMethodProxy();
-			case BeaninfoPackage.BEAN_EVENT: return createBeanEvent();
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY: return (EObject)createFeatureAttributeMapEntry();
-			default:
-				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object createFromString(EDataType eDataType, String initialValue) {
-		switch (eDataType.getClassifierID()) {
-			case BeaninfoPackage.IMPLICIT_ITEM: {
-				ImplicitItem result = ImplicitItem.get(initialValue);
-				if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
-				return result;
-			}
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_VALUE:
-				return createFeatureAttributeValueFromString(eDataType, initialValue);
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String convertToString(EDataType eDataType, Object instanceValue) {
-		switch (eDataType.getClassifierID()) {
-			case BeaninfoPackage.IMPLICIT_ITEM:
-				return instanceValue == null ? null : instanceValue.toString();
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_VALUE:
-				return convertFeatureAttributeValueToString(eDataType, instanceValue);
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public FeatureDecorator createFeatureDecorator() {
-		FeatureDecoratorImpl featureDecorator = new FeatureDecoratorImpl();
-		featureDecorator.setSource(FeatureDecorator.class.getName());
-		return featureDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public EventSetDecorator createEventSetDecorator() {
-		EventSetDecoratorImpl eventSetDecorator = new EventSetDecoratorImpl();
-		eventSetDecorator.setSource(EventSetDecorator.class.getName());
-		return eventSetDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MethodProxy createMethodProxy() {
-		MethodProxyImpl methodProxy = new MethodProxyImpl();
-		return methodProxy;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public PropertyDecorator createPropertyDecorator() {
-		PropertyDecoratorImpl propertyDecorator = new PropertyDecoratorImpl();
-		propertyDecorator.setSource(PropertyDecorator.class.getName());
-		return propertyDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public IndexedPropertyDecorator createIndexedPropertyDecorator() {
-		IndexedPropertyDecoratorImpl indexedPropertyDecorator = new IndexedPropertyDecoratorImpl();
-		indexedPropertyDecorator.setSource(IndexedPropertyDecorator.class.getName());
-		return indexedPropertyDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public BeanDecorator createBeanDecorator() {
-		BeanDecoratorImpl beanDecorator = new BeanDecoratorImpl();
-		beanDecorator.setSource(BeanDecorator.class.getName());
-		return beanDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public MethodDecorator createMethodDecorator() {
-		MethodDecoratorImpl methodDecorator = new MethodDecoratorImpl();
-		methodDecorator.setSource(MethodDecorator.class.getName());
-		return methodDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public ParameterDecorator createParameterDecorator() {
-		ParameterDecoratorImpl parameterDecorator = new ParameterDecoratorImpl();
-		parameterDecorator.setSource(ParameterDecorator.class.getName());
-		return parameterDecorator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BeaninfoPackage getBeaninfoPackage() {
-		return (BeaninfoPackage)getEPackage();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @deprecated
-	 * @generated
-	 */
-	public static BeaninfoPackage getPackage() {
-		return BeaninfoPackage.eINSTANCE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BeanEvent createBeanEvent() {
-		BeanEventImpl beanEvent = new BeanEventImpl();
-		return beanEvent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Map.Entry createFeatureAttributeMapEntry() {
-		FeatureAttributeMapEntryImpl featureAttributeMapEntry = new FeatureAttributeMapEntryImpl();
-		return featureAttributeMapEntry;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public FeatureAttributeValue createFeatureAttributeValueFromString(EDataType eDataType, String initialValue) {
-		return new FeatureAttributeValue(initialValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public String convertFeatureAttributeValueToString(EDataType eDataType, Object instanceValue) {
-		return instanceValue.toString();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeaninfoPackageImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeaninfoPackageImpl.java
deleted file mode 100644
index c1ebf36..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/BeaninfoPackageImpl.java
+++ /dev/null
@@ -1,1012 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: BeaninfoPackageImpl.java,v $
- *  $Revision: 1.10 $  $Date: 2005/09/15 20:09:51 $ 
- */
-
-import java.util.Map;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EOperation;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.emf.ecore.impl.EcorePackageImpl;
-
-import org.eclipse.jem.internal.beaninfo.BeanDecorator;
-import org.eclipse.jem.internal.beaninfo.BeanEvent;
-import org.eclipse.jem.internal.beaninfo.BeaninfoFactory;
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.EventSetDecorator;
-import org.eclipse.jem.internal.beaninfo.FeatureDecorator;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-import org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator;
-import org.eclipse.jem.internal.beaninfo.MethodDecorator;
-import org.eclipse.jem.internal.beaninfo.MethodProxy;
-import org.eclipse.jem.internal.beaninfo.ParameterDecorator;
-import org.eclipse.jem.internal.beaninfo.PropertyDecorator;
-import org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.internal.impl.JavaRefPackageImpl;
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-
-public class BeaninfoPackageImpl extends EPackageImpl implements BeaninfoPackage{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass featureDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass beanDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass eventSetDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass methodDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass parameterDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass propertyDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass indexedPropertyDecoratorEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass methodProxyEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass beanEventEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass featureAttributeMapEntryEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EEnum implicitItemEEnum = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EDataType featureAttributeValueEDataType = null;
-
-	/**
-	 * Creates an instance of the model <b>Package</b>, registered with
-	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-	 * package URI value.
-	 * <p>Note: the correct way to create the package is via the static
-	 * factory method {@link #init init()}, which also performs
-	 * initialization of the package, or returns the registered package,
-	 * if one already exists.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.emf.ecore.EPackage.Registry
-	 * @see org.eclipse.jem.internal.beaninfo.BeaninfoPackage#eNS_URI
-	 * @see #init()
-	 * @generated
-	 */
-	private BeaninfoPackageImpl() {
-		super(eNS_URI, BeaninfoFactory.eINSTANCE);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static boolean isInited = false;
-
-	/**
-	 * Creates, registers, and initializes the <b>Package</b> for this
-	 * model, and for any others upon which it depends.  Simple
-	 * dependencies are satisfied by calling this method on all
-	 * dependent packages before doing anything else.  This method drives
-	 * initialization for interdependent packages directly, in parallel
-	 * with this package, itself.
-	 * <p>Of this package and its interdependencies, all packages which
-	 * have not yet been registered by their URI values are first created
-	 * and registered.  The packages are then initialized in two steps:
-	 * meta-model objects for all of the packages are created before any
-	 * are initialized, since one package's meta-model objects may refer to
-	 * those of another.
-	 * <p>Invocation of this method will not affect any packages that have
-	 * already been initialized.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #eNS_URI
-	 * @see #createPackageContents()
-	 * @see #initializePackageContents()
-	 * @generated
-	 */
-	public static BeaninfoPackage init() {
-		if (isInited) return (BeaninfoPackage)EPackage.Registry.INSTANCE.getEPackage(BeaninfoPackage.eNS_URI);
-
-		// Obtain or create and register package
-		BeaninfoPackageImpl theBeaninfoPackage = (BeaninfoPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof BeaninfoPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new BeaninfoPackageImpl());
-
-		isInited = true;
-
-		// Initialize simple dependencies
-		EcorePackageImpl.init();
-		JavaRefPackageImpl.init();
-
-		// Create package meta-data objects
-		theBeaninfoPackage.createPackageContents();
-
-		// Initialize created meta-data
-		theBeaninfoPackage.initializePackageContents();
-
-		// Mark meta-data to indicate it can't be changed
-		theBeaninfoPackage.freeze();
-
-		return theBeaninfoPackage;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFeatureDecorator() {
-		return featureDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_DisplayName() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_ShortDescription() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_Category() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_Expert() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_Hidden() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_Preferred() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_MergeIntrospection() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_AttributesExplicitEmpty() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(7);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_ImplicitlySetBits() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(8);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureDecorator_ImplicitDecoratorFlag() {
-		return (EAttribute)featureDecoratorEClass.getEStructuralFeatures().get(9);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFeatureDecorator_Attributes() {
-		return (EReference)featureDecoratorEClass.getEStructuralFeatures().get(10);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getEventSetDecorator() {
-		return eventSetDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getEventSetDecorator_InDefaultEventSet() {
-		return (EAttribute)eventSetDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getEventSetDecorator_Unicast() {
-		return (EAttribute)eventSetDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getEventSetDecorator_ListenerMethodsExplicitEmpty() {
-		return (EAttribute)eventSetDecoratorEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getEventSetDecorator_AddListenerMethod() {
-		return (EReference)eventSetDecoratorEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getEventSetDecorator_ListenerMethods() {
-		return (EReference)eventSetDecoratorEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getEventSetDecorator_ListenerType() {
-		return (EReference)eventSetDecoratorEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getEventSetDecorator_RemoveListenerMethod() {
-		return (EReference)eventSetDecoratorEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getEventSetDecorator_EventAdapterClass() {
-		return (EReference)eventSetDecoratorEClass.getEStructuralFeatures().get(7);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getEventSetDecorator_SerListMthd() {
-		return (EReference)eventSetDecoratorEClass.getEStructuralFeatures().get(8);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getMethodProxy() {
-		return methodProxyEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMethodProxy_Method() {
-		return (EReference)methodProxyEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPropertyDecorator() {
-		return propertyDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyDecorator_Bound() {
-		return (EAttribute)propertyDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyDecorator_Constrained() {
-		return (EAttribute)propertyDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyDecorator_DesignTime() {
-		return (EAttribute)propertyDecoratorEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyDecorator_AlwaysIncompatible() {
-		return (EAttribute)propertyDecoratorEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyDecorator_FilterFlags() {
-		return (EAttribute)propertyDecoratorEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyDecorator_FieldReadOnly() {
-		return (EAttribute)propertyDecoratorEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyDecorator_PropertyEditorClass() {
-		return (EReference)propertyDecoratorEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyDecorator_ReadMethod() {
-		return (EReference)propertyDecoratorEClass.getEStructuralFeatures().get(7);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyDecorator_WriteMethod() {
-		return (EReference)propertyDecoratorEClass.getEStructuralFeatures().get(8);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyDecorator_Field() {
-		return (EReference)propertyDecoratorEClass.getEStructuralFeatures().get(9);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIndexedPropertyDecorator() {
-		return indexedPropertyDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getIndexedPropertyDecorator_IndexedReadMethod() {
-		return (EReference)indexedPropertyDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getIndexedPropertyDecorator_IndexedWriteMethod() {
-		return (EReference)indexedPropertyDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getBeanDecorator() {
-		return beanDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_MergeSuperProperties() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_MergeSuperMethods() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_MergeSuperEvents() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_IntrospectProperties() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_IntrospectMethods() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_IntrospectEvents() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBeanDecorator_CustomizerClass() {
-		return (EReference)beanDecoratorEClass.getEStructuralFeatures().get(10);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getMethodDecorator() {
-		return methodDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethodDecorator_ParmsExplicitEmpty() {
-		return (EAttribute)methodDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMethodDecorator_ParameterDescriptors() {
-		return (EReference)methodDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMethodDecorator_SerParmDesc() {
-		return (EReference)methodDecoratorEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getParameterDecorator() {
-		return parameterDecoratorEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getParameterDecorator_Name() {
-		return (EAttribute)parameterDecoratorEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EDataType getFeatureAttributeValue() {
-		return featureAttributeValueEDataType;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BeaninfoFactory getBeaninfoFactory() {
-		return (BeaninfoFactory)getEFactoryInstance();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isCreated = false;
-
-	/**
-	 * Creates the meta-model objects for the package.  This method is
-	 * guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void createPackageContents() {
-		if (isCreated) return;
-		isCreated = true;
-
-		// Create classes and their features
-		featureDecoratorEClass = createEClass(FEATURE_DECORATOR);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__DISPLAY_NAME);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__SHORT_DESCRIPTION);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__CATEGORY);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__EXPERT);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__HIDDEN);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__PREFERRED);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__MERGE_INTROSPECTION);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__IMPLICITLY_SET_BITS);
-		createEAttribute(featureDecoratorEClass, FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG);
-		createEReference(featureDecoratorEClass, FEATURE_DECORATOR__ATTRIBUTES);
-
-		beanDecoratorEClass = createEClass(BEAN_DECORATOR);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__MERGE_SUPER_PROPERTIES);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__MERGE_SUPER_METHODS);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__MERGE_SUPER_EVENTS);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__INTROSPECT_PROPERTIES);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__INTROSPECT_METHODS);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__INTROSPECT_EVENTS);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__DO_BEANINFO);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__NOT_INHERITED_PROPERTY_NAMES);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__NOT_INHERITED_METHOD_NAMES);
-		createEAttribute(beanDecoratorEClass, BEAN_DECORATOR__NOT_INHERITED_EVENT_NAMES);
-		createEReference(beanDecoratorEClass, BEAN_DECORATOR__CUSTOMIZER_CLASS);
-
-		eventSetDecoratorEClass = createEClass(EVENT_SET_DECORATOR);
-		createEAttribute(eventSetDecoratorEClass, EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET);
-		createEAttribute(eventSetDecoratorEClass, EVENT_SET_DECORATOR__UNICAST);
-		createEAttribute(eventSetDecoratorEClass, EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY);
-		createEReference(eventSetDecoratorEClass, EVENT_SET_DECORATOR__ADD_LISTENER_METHOD);
-		createEReference(eventSetDecoratorEClass, EVENT_SET_DECORATOR__LISTENER_METHODS);
-		createEReference(eventSetDecoratorEClass, EVENT_SET_DECORATOR__LISTENER_TYPE);
-		createEReference(eventSetDecoratorEClass, EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD);
-		createEReference(eventSetDecoratorEClass, EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS);
-		createEReference(eventSetDecoratorEClass, EVENT_SET_DECORATOR__SER_LIST_MTHD);
-
-		methodDecoratorEClass = createEClass(METHOD_DECORATOR);
-		createEAttribute(methodDecoratorEClass, METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY);
-		createEReference(methodDecoratorEClass, METHOD_DECORATOR__PARAMETER_DESCRIPTORS);
-		createEReference(methodDecoratorEClass, METHOD_DECORATOR__SER_PARM_DESC);
-
-		parameterDecoratorEClass = createEClass(PARAMETER_DECORATOR);
-		createEAttribute(parameterDecoratorEClass, PARAMETER_DECORATOR__NAME);
-		createEReference(parameterDecoratorEClass, PARAMETER_DECORATOR__PARAMETER);
-
-		propertyDecoratorEClass = createEClass(PROPERTY_DECORATOR);
-		createEAttribute(propertyDecoratorEClass, PROPERTY_DECORATOR__BOUND);
-		createEAttribute(propertyDecoratorEClass, PROPERTY_DECORATOR__CONSTRAINED);
-		createEAttribute(propertyDecoratorEClass, PROPERTY_DECORATOR__DESIGN_TIME);
-		createEAttribute(propertyDecoratorEClass, PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE);
-		createEAttribute(propertyDecoratorEClass, PROPERTY_DECORATOR__FILTER_FLAGS);
-		createEAttribute(propertyDecoratorEClass, PROPERTY_DECORATOR__FIELD_READ_ONLY);
-		createEReference(propertyDecoratorEClass, PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS);
-		createEReference(propertyDecoratorEClass, PROPERTY_DECORATOR__READ_METHOD);
-		createEReference(propertyDecoratorEClass, PROPERTY_DECORATOR__WRITE_METHOD);
-		createEReference(propertyDecoratorEClass, PROPERTY_DECORATOR__FIELD);
-
-		indexedPropertyDecoratorEClass = createEClass(INDEXED_PROPERTY_DECORATOR);
-		createEReference(indexedPropertyDecoratorEClass, INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD);
-		createEReference(indexedPropertyDecoratorEClass, INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD);
-
-		methodProxyEClass = createEClass(METHOD_PROXY);
-		createEReference(methodProxyEClass, METHOD_PROXY__METHOD);
-
-		beanEventEClass = createEClass(BEAN_EVENT);
-
-		featureAttributeMapEntryEClass = createEClass(FEATURE_ATTRIBUTE_MAP_ENTRY);
-		createEAttribute(featureAttributeMapEntryEClass, FEATURE_ATTRIBUTE_MAP_ENTRY__KEY);
-		createEAttribute(featureAttributeMapEntryEClass, FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE);
-
-		// Create enums
-		implicitItemEEnum = createEEnum(IMPLICIT_ITEM);
-
-		// Create data types
-		featureAttributeValueEDataType = createEDataType(FEATURE_ATTRIBUTE_VALUE);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isInitialized = false;
-
-	/**
-	 * Complete the initialization of the package and its meta-model.  This
-	 * method is guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void initializePackageContents() {
-		if (isInitialized) return;
-		isInitialized = true;
-
-		// Initialize package
-		setName(eNAME);
-		setNsPrefix(eNS_PREFIX);
-		setNsURI(eNS_URI);
-
-		// Obtain other dependent packages
-		EcorePackageImpl theEcorePackage = (EcorePackageImpl)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
-		JavaRefPackageImpl theJavaRefPackage = (JavaRefPackageImpl)EPackage.Registry.INSTANCE.getEPackage(JavaRefPackage.eNS_URI);
-
-		// Add supertypes to classes
-		featureDecoratorEClass.getESuperTypes().add(theEcorePackage.getEAnnotation());
-		beanDecoratorEClass.getESuperTypes().add(this.getFeatureDecorator());
-		eventSetDecoratorEClass.getESuperTypes().add(this.getFeatureDecorator());
-		methodDecoratorEClass.getESuperTypes().add(this.getFeatureDecorator());
-		parameterDecoratorEClass.getESuperTypes().add(this.getFeatureDecorator());
-		propertyDecoratorEClass.getESuperTypes().add(this.getFeatureDecorator());
-		indexedPropertyDecoratorEClass.getESuperTypes().add(this.getPropertyDecorator());
-		methodProxyEClass.getESuperTypes().add(theEcorePackage.getEOperation());
-		beanEventEClass.getESuperTypes().add(theJavaRefPackage.getJavaEvent());
-
-		// Initialize classes and features; add operations and parameters
-		initEClass(featureDecoratorEClass, FeatureDecorator.class, "FeatureDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFeatureDecorator_DisplayName(), ecorePackage.getEString(), "displayName", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_ShortDescription(), ecorePackage.getEString(), "shortDescription", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_Category(), ecorePackage.getEString(), "category", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_Expert(), ecorePackage.getEBoolean(), "expert", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_Hidden(), ecorePackage.getEBoolean(), "hidden", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_Preferred(), ecorePackage.getEBoolean(), "preferred", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_MergeIntrospection(), ecorePackage.getEBoolean(), "mergeIntrospection", "true", 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_AttributesExplicitEmpty(), ecorePackage.getEBoolean(), "attributesExplicitEmpty", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_ImplicitlySetBits(), ecorePackage.getELong(), "implicitlySetBits", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureDecorator_ImplicitDecoratorFlag(), this.getImplicitItem(), "implicitDecoratorFlag", null, 0, 1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFeatureDecorator_Attributes(), this.getFeatureAttributeMapEntry(), null, "attributes", null, 0, -1, FeatureDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(featureDecoratorEClass, ecorePackage.getEString(), "getName");
-
-		initEClass(beanDecoratorEClass, BeanDecorator.class, "BeanDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getBeanDecorator_MergeSuperProperties(), ecorePackage.getEBoolean(), "mergeSuperProperties", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_MergeSuperMethods(), ecorePackage.getEBoolean(), "mergeSuperMethods", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_MergeSuperEvents(), ecorePackage.getEBoolean(), "mergeSuperEvents", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_IntrospectProperties(), ecorePackage.getEBoolean(), "introspectProperties", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_IntrospectMethods(), ecorePackage.getEBoolean(), "introspectMethods", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_IntrospectEvents(), ecorePackage.getEBoolean(), "introspectEvents", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_DoBeaninfo(), ecorePackage.getEBoolean(), "doBeaninfo", "true", 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_NotInheritedPropertyNames(), ecorePackage.getEString(), "notInheritedPropertyNames", null, 0, -1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_NotInheritedMethodNames(), ecorePackage.getEString(), "notInheritedMethodNames", null, 0, -1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBeanDecorator_NotInheritedEventNames(), ecorePackage.getEString(), "notInheritedEventNames", null, 0, -1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBeanDecorator_CustomizerClass(), theJavaRefPackage.getJavaClass(), null, "customizerClass", null, 0, 1, BeanDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(eventSetDecoratorEClass, EventSetDecorator.class, "EventSetDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getEventSetDecorator_InDefaultEventSet(), ecorePackage.getEBoolean(), "inDefaultEventSet", null, 0, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getEventSetDecorator_Unicast(), ecorePackage.getEBoolean(), "unicast", null, 0, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getEventSetDecorator_ListenerMethodsExplicitEmpty(), ecorePackage.getEBoolean(), "listenerMethodsExplicitEmpty", null, 0, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getEventSetDecorator_AddListenerMethod(), theJavaRefPackage.getMethod(), null, "addListenerMethod", null, 1, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getEventSetDecorator_ListenerMethods(), this.getMethodProxy(), null, "listenerMethods", null, 1, -1, EventSetDecorator.class, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getEventSetDecorator_ListenerType(), theJavaRefPackage.getJavaClass(), null, "listenerType", null, 1, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getEventSetDecorator_RemoveListenerMethod(), theJavaRefPackage.getMethod(), null, "removeListenerMethod", null, 1, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getEventSetDecorator_EventAdapterClass(), theJavaRefPackage.getJavaClass(), null, "eventAdapterClass", null, 0, 1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getEventSetDecorator_SerListMthd(), this.getMethodProxy(), null, "serListMthd", null, 1, -1, EventSetDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(methodDecoratorEClass, MethodDecorator.class, "MethodDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getMethodDecorator_ParmsExplicitEmpty(), ecorePackage.getEBoolean(), "parmsExplicitEmpty", null, 0, 1, MethodDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMethodDecorator_ParameterDescriptors(), this.getParameterDecorator(), null, "parameterDescriptors", null, 0, -1, MethodDecorator.class, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getMethodDecorator_SerParmDesc(), this.getParameterDecorator(), null, "serParmDesc", null, 0, -1, MethodDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(parameterDecoratorEClass, ParameterDecorator.class, "ParameterDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getParameterDecorator_Name(), ecorePackage.getEString(), "name", null, 0, 1, ParameterDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getParameterDecorator_Parameter(), theJavaRefPackage.getJavaParameter(), null, "parameter", null, 0, 1, ParameterDecorator.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(propertyDecoratorEClass, PropertyDecorator.class, "PropertyDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPropertyDecorator_Bound(), ecorePackage.getEBoolean(), "bound", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyDecorator_Constrained(), ecorePackage.getEBoolean(), "constrained", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyDecorator_DesignTime(), ecorePackage.getEBoolean(), "designTime", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyDecorator_AlwaysIncompatible(), ecorePackage.getEBoolean(), "alwaysIncompatible", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyDecorator_FilterFlags(), ecorePackage.getEString(), "filterFlags", null, 0, -1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyDecorator_FieldReadOnly(), ecorePackage.getEBoolean(), "fieldReadOnly", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyDecorator_PropertyEditorClass(), theJavaRefPackage.getJavaClass(), null, "propertyEditorClass", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyDecorator_ReadMethod(), theJavaRefPackage.getMethod(), null, "readMethod", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyDecorator_WriteMethod(), theJavaRefPackage.getMethod(), null, "writeMethod", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyDecorator_Field(), theJavaRefPackage.getField(), null, "field", null, 0, 1, PropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(propertyDecoratorEClass, theEcorePackage.getEClassifier(), "getPropertyType");
-
-		EOperation op = addEOperation(propertyDecoratorEClass, null, "setPropertyType");
-		addEParameter(op, theEcorePackage.getEClassifier(), "propertyType");
-
-		initEClass(indexedPropertyDecoratorEClass, IndexedPropertyDecorator.class, "IndexedPropertyDecorator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getIndexedPropertyDecorator_IndexedReadMethod(), theJavaRefPackage.getMethod(), null, "indexedReadMethod", null, 0, 1, IndexedPropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getIndexedPropertyDecorator_IndexedWriteMethod(), theJavaRefPackage.getMethod(), null, "indexedWriteMethod", null, 0, 1, IndexedPropertyDecorator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(methodProxyEClass, MethodProxy.class, "MethodProxy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getMethodProxy_Method(), theJavaRefPackage.getMethod(), null, "method", null, 1, 1, MethodProxy.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(beanEventEClass, BeanEvent.class, "BeanEvent", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(featureAttributeMapEntryEClass, Map.Entry.class, "FeatureAttributeMapEntry", !IS_ABSTRACT, !IS_INTERFACE, !IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFeatureAttributeMapEntry_Key(), ecorePackage.getEString(), "key", null, 0, 1, Map.Entry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFeatureAttributeMapEntry_Value(), this.getFeatureAttributeValue(), "value", null, 0, 1, Map.Entry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		// Initialize enums and add enum literals
-		initEEnum(implicitItemEEnum, ImplicitItem.class, "ImplicitItem");
-		addEEnumLiteral(implicitItemEEnum, ImplicitItem.NOT_IMPLICIT_LITERAL);
-		addEEnumLiteral(implicitItemEEnum, ImplicitItem.IMPLICIT_DECORATOR_LITERAL);
-		addEEnumLiteral(implicitItemEEnum, ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL);
-
-		// Initialize data types
-		initEDataType(featureAttributeValueEDataType, FeatureAttributeValue.class, "FeatureAttributeValue", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS);
-
-		// Create resource
-		createResource(eNS_URI);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_DoBeaninfo() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_NotInheritedPropertyNames() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(7);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_NotInheritedMethodNames() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(8);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBeanDecorator_NotInheritedEventNames() {
-		return (EAttribute)beanDecoratorEClass.getEStructuralFeatures().get(9);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getParameterDecorator_Parameter() {
-		return (EReference)parameterDecoratorEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getBeanEvent() {
-		return beanEventEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFeatureAttributeMapEntry() {
-		return featureAttributeMapEntryEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureAttributeMapEntry_Key() {
-		return (EAttribute)featureAttributeMapEntryEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFeatureAttributeMapEntry_Value() {
-		return (EAttribute)featureAttributeMapEntryEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EEnum getImplicitItem() {
-		return implicitItemEEnum;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/EventSetDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/EventSetDecoratorImpl.java
deleted file mode 100644
index 83f3426..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/EventSetDecoratorImpl.java
+++ /dev/null
@@ -1,991 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: EventSetDecoratorImpl.java,v $
- *  $Revision: 1.15 $  $Date: 2005/09/19 15:43:02 $ 
- */
-
-
-import java.util.Collection;
-import java.util.List;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.EventSetDecorator;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-import org.eclipse.jem.internal.beaninfo.MethodProxy;
-
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.Method;
-
-import org.eclipse.jem.internal.beaninfo.*;
-import org.eclipse.jem.java.*;
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Event Set Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#isInDefaultEventSet <em>In Default Event Set</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#isUnicast <em>Unicast</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#isListenerMethodsExplicitEmpty <em>Listener Methods Explicit Empty</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#getAddListenerMethod <em>Add Listener Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#getListenerMethods <em>Listener Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#getListenerType <em>Listener Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#getRemoveListenerMethod <em>Remove Listener Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#getEventAdapterClass <em>Event Adapter Class</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.EventSetDecoratorImpl#getSerListMthd <em>Ser List Mthd</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-
-public class EventSetDecoratorImpl extends FeatureDecoratorImpl implements EventSetDecorator{
-	
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 */
-	public static final long EVENT_ADDLISTENERMETHOD_IMPLICIT = 0x1L;
-	public static final long EVENT_ADAPTERCLASS_IMPLICIT = 0x2L;
-	public static final long EVENT_LISTENERMETHODS_IMPLICIT = 0x4L;
-	public static final long EVENT_LISTENERTYPE_IMPLICIT = 0x8L;
-	public static final long EVENT_REMOVELISTENERMETHOD_IMPLICIT = 0x10L;
-	public static final long EVENT_DEFAULTEVENTSET_IMPLICIT = 0x20L;
-	public static final long EVENT_UNICAST_IMPLICIT = 0x40L;
-	public static final long EVENT_LISTENERMETHODS_DEFAULT = 0x80L;
-
-
-	/**
-	 * The default value of the '{@link #isInDefaultEventSet() <em>In Default Event Set</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isInDefaultEventSet()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean IN_DEFAULT_EVENT_SET_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isInDefaultEventSet() <em>In Default Event Set</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isInDefaultEventSet()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int IN_DEFAULT_EVENT_SET_EFLAG = 1 << 18;
-
-	/**
-	 * The flag representing whether the In Default Event Set attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int IN_DEFAULT_EVENT_SET_ESETFLAG = 1 << 19;
-
-	/**
-	 * The default value of the '{@link #isUnicast() <em>Unicast</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isUnicast()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean UNICAST_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isUnicast() <em>Unicast</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isUnicast()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int UNICAST_EFLAG = 1 << 20;
-
-	/**
-	 * The flag representing whether the Unicast attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int UNICAST_ESETFLAG = 1 << 21;
-
-	/**
-	 * The default value of the '{@link #isListenerMethodsExplicitEmpty() <em>Listener Methods Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isListenerMethodsExplicitEmpty()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean LISTENER_METHODS_EXPLICIT_EMPTY_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isListenerMethodsExplicitEmpty() <em>Listener Methods Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isListenerMethodsExplicitEmpty()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG = 1 << 22;
-
-	/**
-	 * The cached value of the '{@link #getAddListenerMethod() <em>Add Listener Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAddListenerMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method addListenerMethod = null;
-	
-	/**
-	 * The cached value of the '{@link #getListenerType() <em>Listener Type</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getListenerType()
-	 * @generated
-	 * @ordered
-	 */
-	protected JavaClass listenerType = null;
-	/**
-	 * The cached value of the '{@link #getRemoveListenerMethod() <em>Remove Listener Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRemoveListenerMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method removeListenerMethod = null;
-	
-	/**
-	 * The cached value of the '{@link #getEventAdapterClass() <em>Event Adapter Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getEventAdapterClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected JavaClass eventAdapterClass = null;
-
-	/**
-	 * The cached value of the '{@link #getSerListMthd() <em>Ser List Mthd</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSerListMthd()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList serListMthd = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	protected EventSetDecoratorImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getEventSetDecorator();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isInDefaultEventSet() {
-		return (eFlags & IN_DEFAULT_EVENT_SET_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInDefaultEventSet(boolean newInDefaultEventSet) {
-		boolean oldInDefaultEventSet = (eFlags & IN_DEFAULT_EVENT_SET_EFLAG) != 0;
-		if (newInDefaultEventSet) eFlags |= IN_DEFAULT_EVENT_SET_EFLAG; else eFlags &= ~IN_DEFAULT_EVENT_SET_EFLAG;
-		boolean oldInDefaultEventSetESet = (eFlags & IN_DEFAULT_EVENT_SET_ESETFLAG) != 0;
-		eFlags |= IN_DEFAULT_EVENT_SET_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET, oldInDefaultEventSet, newInDefaultEventSet, !oldInDefaultEventSetESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetInDefaultEventSet() {
-		boolean oldInDefaultEventSet = (eFlags & IN_DEFAULT_EVENT_SET_EFLAG) != 0;
-		boolean oldInDefaultEventSetESet = (eFlags & IN_DEFAULT_EVENT_SET_ESETFLAG) != 0;
-		if (IN_DEFAULT_EVENT_SET_EDEFAULT) eFlags |= IN_DEFAULT_EVENT_SET_EFLAG; else eFlags &= ~IN_DEFAULT_EVENT_SET_EFLAG;
-		eFlags &= ~IN_DEFAULT_EVENT_SET_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET, oldInDefaultEventSet, IN_DEFAULT_EVENT_SET_EDEFAULT, oldInDefaultEventSetESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetInDefaultEventSet() {
-		return (eFlags & IN_DEFAULT_EVENT_SET_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isUnicast() {
-		return (eFlags & UNICAST_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setUnicast(boolean newUnicast) {
-		boolean oldUnicast = (eFlags & UNICAST_EFLAG) != 0;
-		if (newUnicast) eFlags |= UNICAST_EFLAG; else eFlags &= ~UNICAST_EFLAG;
-		boolean oldUnicastESet = (eFlags & UNICAST_ESETFLAG) != 0;
-		eFlags |= UNICAST_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__UNICAST, oldUnicast, newUnicast, !oldUnicastESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetUnicast() {
-		boolean oldUnicast = (eFlags & UNICAST_EFLAG) != 0;
-		boolean oldUnicastESet = (eFlags & UNICAST_ESETFLAG) != 0;
-		if (UNICAST_EDEFAULT) eFlags |= UNICAST_EFLAG; else eFlags &= ~UNICAST_EFLAG;
-		eFlags &= ~UNICAST_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.EVENT_SET_DECORATOR__UNICAST, oldUnicast, UNICAST_EDEFAULT, oldUnicastESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetUnicast() {
-		return (eFlags & UNICAST_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isListenerMethodsExplicitEmpty() {
-		return (eFlags & LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setListenerMethodsExplicitEmpty(boolean newListenerMethodsExplicitEmpty) {
-		boolean oldListenerMethodsExplicitEmpty = (eFlags & LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG) != 0;
-		if (newListenerMethodsExplicitEmpty) eFlags |= LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG; else eFlags &= ~LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY, oldListenerMethodsExplicitEmpty, newListenerMethodsExplicitEmpty));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getAddListenerMethod() {
-		if (addListenerMethod != null && addListenerMethod.eIsProxy()) {
-			Method oldAddListenerMethod = addListenerMethod;
-			addListenerMethod = (Method)eResolveProxy((InternalEObject)addListenerMethod);
-			if (addListenerMethod != oldAddListenerMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.EVENT_SET_DECORATOR__ADD_LISTENER_METHOD, oldAddListenerMethod, addListenerMethod));
-			}
-		}
-		return addListenerMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetAddListenerMethod() {
-		return addListenerMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAddListenerMethod(Method newAddListenerMethod) {
-		Method oldAddListenerMethod = addListenerMethod;
-		addListenerMethod = newAddListenerMethod;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__ADD_LISTENER_METHOD, oldAddListenerMethod, addListenerMethod));
-	}
-
-	public EList getListenerMethods() {
-		if (!isListenerMethodsExplicitEmpty() && getSerListMthd().isEmpty() && (getImplicitlySetBits()&(EVENT_LISTENERMETHODS_IMPLICIT | EVENT_LISTENERMETHODS_DEFAULT)) == 0) {
-			// Not explicitly empty, it is empty, and we have not implicitly or by defaults made it empty, then create the defaults.
-			createDefaultListenerMethodsList();
-		}
-		return getSerListMthd();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getListenerMethodsGen() {
-		// TODO: implement this method to return the 'Listener Methods' reference list
-		// Ensure that you remove @generated or mark it @generated NOT
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass getListenerType() {
-		if (listenerType != null && listenerType.eIsProxy()) {
-			JavaClass oldListenerType = listenerType;
-			listenerType = (JavaClass)eResolveProxy((InternalEObject)listenerType);
-			if (listenerType != oldListenerType) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_TYPE, oldListenerType, listenerType));
-			}
-		}
-		return listenerType;
-	}
-
-	/**
-	 * This is called if method listeners list not explicitly set and there is no feature proxy or
-	 * there is a feature proxy and the proxy has nothing defined.
-	 * <p>
-	 * This is an internal method used by BeanInfo classes. It is not to be used by clients.
-	 */
-	public EList createDefaultListenerMethodsList() {
-		if (!eIsSet(EcorePackage.eINSTANCE.getEAnnotation_EModelElement()))
-			return this.getSerListMthd();	// We are not attached, can't determine the list yet.
-		EList mthdsList = this.getSerListMthd();		
-			
-		JavaClass eventObjectClass = (JavaClass) JavaRefFactory.eINSTANCE.reflectType("java.util.EventObject", getEModelElement().eResource().getResourceSet()); //$NON-NLS-1$
-		
-		mthdsList.clear();
-		
-		// This is a little tricky. Need to get the methods for the listener type, and
-		// then go through the methods and filter out the non-event ones.
-		JavaClass lt = getListenerType();
-		if (lt == null)
-			return mthdsList;	// Couldn't get the listener type for some reason, so leave as is.
-		setImplicitlySetBits(getImplicitlySetBits()|EVENT_LISTENERMETHODS_DEFAULT);	// Mark as we implicitly filled it in.
-		
-		BeaninfoFactory bfact = BeaninfoFactory.eINSTANCE;
-		List ms = lt.getPublicMethodsExtended();
-		int msize = ms.size();
-		for (int i=0; i<msize; i++) {
-			Method method = (Method) ms.get(i);
-			List parms = method.getParameters();
-			if (parms.size() != 1)
-				continue;	// Must have only one parm.
-			if (!eventObjectClass.isAssignableFrom(((JavaParameter) parms.get(0)).getEType()))
-				continue;	// Parm does not inherit from java.util.EventObject
-				
-			// We need a method proxy, and a method decorator.
-			MethodProxy mproxy = bfact.createMethodProxy();
-			mproxy.setMethod(method);
-			mproxy.setName(method.getName());			
-			MethodDecorator md = bfact.createMethodDecorator();
-			md.setImplicitDecoratorFlag(ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE_LITERAL);
-			md.setEModelElement(mproxy);			
-			mthdsList.add(mproxy);
-		}
-		return mthdsList;
-	}	
-	
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass basicGetListenerType() {
-		return listenerType;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setListenerType(JavaClass newListenerType) {
-		JavaClass oldListenerType = listenerType;
-		listenerType = newListenerType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_TYPE, oldListenerType, listenerType));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getRemoveListenerMethod() {
-		if (removeListenerMethod != null && removeListenerMethod.eIsProxy()) {
-			Method oldRemoveListenerMethod = removeListenerMethod;
-			removeListenerMethod = (Method)eResolveProxy((InternalEObject)removeListenerMethod);
-			if (removeListenerMethod != oldRemoveListenerMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD, oldRemoveListenerMethod, removeListenerMethod));
-			}
-		}
-		return removeListenerMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetRemoveListenerMethod() {
-		return removeListenerMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRemoveListenerMethod(Method newRemoveListenerMethod) {
-		Method oldRemoveListenerMethod = removeListenerMethod;
-		removeListenerMethod = newRemoveListenerMethod;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD, oldRemoveListenerMethod, removeListenerMethod));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass getEventAdapterClass() {
-		if (eventAdapterClass != null && eventAdapterClass.eIsProxy()) {
-			JavaClass oldEventAdapterClass = eventAdapterClass;
-			eventAdapterClass = (JavaClass)eResolveProxy((InternalEObject)eventAdapterClass);
-			if (eventAdapterClass != oldEventAdapterClass) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS, oldEventAdapterClass, eventAdapterClass));
-			}
-		}
-		return eventAdapterClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass basicGetEventAdapterClass() {
-		return eventAdapterClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setEventAdapterClass(JavaClass newEventAdapterClass) {
-		JavaClass oldEventAdapterClass = eventAdapterClass;
-		eventAdapterClass = newEventAdapterClass;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS, oldEventAdapterClass, eventAdapterClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getSerListMthd() {
-		if (serListMthd == null) {
-			serListMthd = new EObjectContainmentEList(MethodProxy.class, this, BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD);
-		}
-		return serListMthd;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.EVENT_SET_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.EVENT_SET_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.EVENT_SET_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.EVENT_SET_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD:
-					return ((InternalEList)getSerListMthd()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET:
-				return isInDefaultEventSet() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__UNICAST:
-				return isUnicast() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY:
-				return isListenerMethodsExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ADD_LISTENER_METHOD:
-				if (resolve) return getAddListenerMethod();
-				return basicGetAddListenerMethod();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS:
-				return getListenerMethods();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_TYPE:
-				if (resolve) return getListenerType();
-				return basicGetListenerType();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD:
-				if (resolve) return getRemoveListenerMethod();
-				return basicGetRemoveListenerMethod();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS:
-				if (resolve) return getEventAdapterClass();
-				return basicGetEventAdapterClass();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD:
-				return getSerListMthd();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET:
-				setInDefaultEventSet(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__UNICAST:
-				setUnicast(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY:
-				setListenerMethodsExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ADD_LISTENER_METHOD:
-				setAddListenerMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS:
-				getListenerMethods().clear();
-				getListenerMethods().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_TYPE:
-				setListenerType((JavaClass)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD:
-				setRemoveListenerMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS:
-				setEventAdapterClass((JavaClass)newValue);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD:
-				getSerListMthd().clear();
-				getSerListMthd().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET:
-				unsetInDefaultEventSet();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__UNICAST:
-				unsetUnicast();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY:
-				setListenerMethodsExplicitEmpty(LISTENER_METHODS_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ADD_LISTENER_METHOD:
-				setAddListenerMethod((Method)null);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS:
-				getListenerMethods().clear();
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_TYPE:
-				setListenerType((JavaClass)null);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD:
-				setRemoveListenerMethod((Method)null);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS:
-				setEventAdapterClass((JavaClass)null);
-				return;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD:
-				getSerListMthd().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/*
-	 * This is overridden so that we can do special is set tests:
-	 * 1) parameter descriptors: check if serParmDesc exists and not empty, since parameter descriptors is derived.
-	 * 2) serParmDesc: if flag set to default parm desc, then answer not set, else do normal isSet test. That way if set by default it won't serialize
-	 *    out the unneeded default parms. They can be reconstructed quickly when needed.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SOURCE:
-				return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS:
-				return eIsSetGen(BeaninfoPackage.eINSTANCE.getEventSetDecorator_SerListMthd());	// Let default serListMthd is set work.
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD:
-				if ((getImplicitlySetBits() & EVENT_LISTENERMETHODS_DEFAULT) != 0)
-					return false;	// Not considered set if initialized by default.
-				else
-					return eIsSetGen(eFeature);	// Not set by default, so check true setting.
-			default:
-				return eIsSetGen(eFeature);	// Everything else use the gen method.
-		}
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__IN_DEFAULT_EVENT_SET:
-				return isSetInDefaultEventSet();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__UNICAST:
-				return isSetUnicast();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS_EXPLICIT_EMPTY:
-				return ((eFlags & LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG) != 0) != LISTENER_METHODS_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__ADD_LISTENER_METHOD:
-				return addListenerMethod != null;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_METHODS:
-				return !getListenerMethods().isEmpty();
-			case BeaninfoPackage.EVENT_SET_DECORATOR__LISTENER_TYPE:
-				return listenerType != null;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__REMOVE_LISTENER_METHOD:
-				return removeListenerMethod != null;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__EVENT_ADAPTER_CLASS:
-				return eventAdapterClass != null;
-			case BeaninfoPackage.EVENT_SET_DECORATOR__SER_LIST_MTHD:
-				return serListMthd != null && !serListMthd.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (inDefaultEventSet: ");
-		if ((eFlags & IN_DEFAULT_EVENT_SET_ESETFLAG) != 0) result.append((eFlags & IN_DEFAULT_EVENT_SET_EFLAG) != 0); else result.append("<unset>");
-		result.append(", unicast: ");
-		if ((eFlags & UNICAST_ESETFLAG) != 0) result.append((eFlags & UNICAST_EFLAG) != 0); else result.append("<unset>");
-		result.append(", listenerMethodsExplicitEmpty: ");
-		result.append((eFlags & LISTENER_METHODS_EXPLICIT_EMPTY_EFLAG) != 0);
-		result.append(')');
-		return result.toString();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/FeatureAttributeMapEntryImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/FeatureAttributeMapEntryImpl.java
deleted file mode 100644
index 56c47fc..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/FeatureAttributeMapEntryImpl.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: FeatureAttributeMapEntryImpl.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-package org.eclipse.jem.internal.beaninfo.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.common.util.BasicEMap;
-import org.eclipse.emf.common.util.EMap;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-
-import org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Feature Attribute Map Entry</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureAttributeMapEntryImpl#getTypedKey <em>Key</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureAttributeMapEntryImpl#getTypedValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FeatureAttributeMapEntryImpl extends EObjectImpl implements BasicEMap.Entry {
-	/**
-	 * The default value of the '{@link #getTypedKey() <em>Key</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTypedKey()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String KEY_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTypedKey() <em>Key</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTypedKey()
-	 * @generated
-	 * @ordered
-	 */
-	protected String key = KEY_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getTypedValue() <em>Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTypedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final FeatureAttributeValue VALUE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTypedValue() <em>Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTypedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected FeatureAttributeValue value = VALUE_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FeatureAttributeMapEntryImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getFeatureAttributeMapEntry();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTypedKey() {
-		return key;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTypedKey(String newKey) {
-		String oldKey = key;
-		key = newKey;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__KEY, oldKey, key));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FeatureAttributeValue getTypedValue() {
-		return value;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTypedValue(FeatureAttributeValue newValue) {
-		FeatureAttributeValue oldValue = value;
-		value = newValue;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE, oldValue, value));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__KEY:
-				return getTypedKey();
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE:
-				return getTypedValue();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__KEY:
-				setTypedKey((String)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE:
-				setTypedValue((FeatureAttributeValue)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__KEY:
-				setTypedKey(KEY_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE:
-				setTypedValue(VALUE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__KEY:
-				return KEY_EDEFAULT == null ? key != null : !KEY_EDEFAULT.equals(key);
-			case BeaninfoPackage.FEATURE_ATTRIBUTE_MAP_ENTRY__VALUE:
-				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (key: ");
-		result.append(key);
-		result.append(", value: ");
-		result.append(value);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected int hash = -1;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public int getHash() {
-		if (hash == -1) {
-			Object theKey = getKey();
-			hash = (theKey == null ? 0 : theKey.hashCode());
-		}
-		return hash;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setHash(int hash) {
-		this.hash = hash;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getKey() {
-		return getTypedKey();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setKey(Object key) {
-		setTypedKey((String)key);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getValue() {
-		return getTypedValue();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object setValue(Object value) {
-		Object oldValue = getValue();
-		setTypedValue((FeatureAttributeValue)value);
-		return oldValue;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EMap getEMap() {
-		EObject container = eContainer();
-		return container == null ? null : (EMap)container.eGet(eContainmentFeature());
-	}
-
-} //FeatureAttributeMapEntryImpl
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/FeatureDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/FeatureDecoratorImpl.java
deleted file mode 100644
index 2f0d565..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/FeatureDecoratorImpl.java
+++ /dev/null
@@ -1,1058 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: FeatureDecoratorImpl.java,v $
- *  $Revision: 1.11 $  $Date: 2005/09/19 15:43:02 $ 
- */
-
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EMap;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.ENamedElement;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.EAnnotationImpl;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.EcoreEMap;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.FeatureDecorator;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Feature Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#getShortDescription <em>Short Description</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#getCategory <em>Category</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#isExpert <em>Expert</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#isHidden <em>Hidden</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#isPreferred <em>Preferred</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#isMergeIntrospection <em>Merge Introspection</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#isAttributesExplicitEmpty <em>Attributes Explicit Empty</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#getImplicitlySetBits <em>Implicitly Set Bits</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#getImplicitDecoratorFlag <em>Implicit Decorator Flag</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.FeatureDecoratorImpl#getAttributes <em>Attributes</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FeatureDecoratorImpl extends EAnnotationImpl implements FeatureDecorator{
-	
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 * Note: To make it easier to make changes Feature goes from high bits down, while the
-	 * subclasses go from low-bits up. That way if a change is made to add something of
-	 * interest to Feature, all of the subclasses don't need to have their bits re-ordered.
-	 * Since these are bits, it doesn't matter which ones to use.
-	 */
-	public static final long FEATURE_DISPLAYNAME_IMPLICIT = 0x8000000000000000L;
-	public static final long FEATURE_SHORTDESC_IMPLICIT = 0x4000000000000000L;
-	public static final long FEATURE_CATEGORY_IMPLICIT = 0x2000000000000000L;
-	public static final long FEATURE_EXPERT_IMPLICIT = 0x1000000000000000L;
-	public static final long FEATURE_HIDDEN_IMPLICIT = 0x800000000000000L;
-	public static final long FEATURE_PREFERRED_IMPLICIT = 0x400000000000000L;
-	public static final long FEATURE_ATTRIBUTES_IMPLICIT = 0x200000000000000L; 
-	
-	/**
-	 * The default value of the '{@link #getDisplayName() <em>Display Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String DISPLAY_NAME_EDEFAULT = null;
-
-	 
-	/**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected String displayName = DISPLAY_NAME_EDEFAULT;
-	/**
-	 * The flag representing whether the Display Name attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int DISPLAY_NAME_ESETFLAG = 1 << 8;
-
-	/**
-	 * The default value of the '{@link #getShortDescription() <em>Short Description</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getShortDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String SHORT_DESCRIPTION_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getShortDescription() <em>Short Description</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getShortDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected String shortDescription = SHORT_DESCRIPTION_EDEFAULT;
-	/**
-	 * The flag representing whether the Short Description attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int SHORT_DESCRIPTION_ESETFLAG = 1 << 9;
-
-	/**
-	 * The default value of the '{@link #getCategory() <em>Category</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getCategory()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String CATEGORY_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getCategory() <em>Category</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getCategory()
-	 * @generated
-	 * @ordered
-	 */
-	protected String category = CATEGORY_EDEFAULT;
-	/**
-	 * The default value of the '{@link #isExpert() <em>Expert</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isExpert()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean EXPERT_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isExpert() <em>Expert</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isExpert()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int EXPERT_EFLAG = 1 << 10;
-
-	/**
-	 * The flag representing whether the Expert attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int EXPERT_ESETFLAG = 1 << 11;
-
-	/**
-	 * The default value of the '{@link #isHidden() <em>Hidden</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isHidden()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean HIDDEN_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isHidden() <em>Hidden</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isHidden()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int HIDDEN_EFLAG = 1 << 12;
-
-	/**
-	 * The flag representing whether the Hidden attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int HIDDEN_ESETFLAG = 1 << 13;
-
-	/**
-	 * The default value of the '{@link #isPreferred() <em>Preferred</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isPreferred()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean PREFERRED_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isPreferred() <em>Preferred</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isPreferred()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int PREFERRED_EFLAG = 1 << 14;
-
-	/**
-	 * The flag representing whether the Preferred attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int PREFERRED_ESETFLAG = 1 << 15;
-
-	/**
-	 * The default value of the '{@link #isMergeIntrospection() <em>Merge Introspection</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeIntrospection()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean MERGE_INTROSPECTION_EDEFAULT = true;
-
-	/**
-	 * The flag representing the value of the '{@link #isMergeIntrospection() <em>Merge Introspection</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMergeIntrospection()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int MERGE_INTROSPECTION_EFLAG = 1 << 16;
-
-	/**
-	 * The default value of the '{@link #isAttributesExplicitEmpty() <em>Attributes Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isAttributesExplicitEmpty()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isAttributesExplicitEmpty() <em>Attributes Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isAttributesExplicitEmpty()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int ATTRIBUTES_EXPLICIT_EMPTY_EFLAG = 1 << 17;
-
-	/**
-	 * The default value of the '{@link #getImplicitlySetBits() <em>Implicitly Set Bits</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getImplicitlySetBits()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final long IMPLICITLY_SET_BITS_EDEFAULT = 0L;
-
-	/**
-	 * The cached value of the '{@link #getImplicitlySetBits() <em>Implicitly Set Bits</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getImplicitlySetBits()
-	 * @generated
-	 * @ordered
-	 */
-	protected long implicitlySetBits = IMPLICITLY_SET_BITS_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getImplicitDecoratorFlag() <em>Implicit Decorator Flag</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getImplicitDecoratorFlag()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final ImplicitItem IMPLICIT_DECORATOR_FLAG_EDEFAULT = ImplicitItem.NOT_IMPLICIT_LITERAL;
-
-	/**
-	 * The cached value of the '{@link #getImplicitDecoratorFlag() <em>Implicit Decorator Flag</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getImplicitDecoratorFlag()
-	 * @generated
-	 * @ordered
-	 */
-	protected ImplicitItem implicitDecoratorFlag = IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getAttributes() <em>Attributes</em>}' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttributes()
-	 * @generated
-	 * @ordered
-	 */
-	protected EMap attributes = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FeatureDecoratorImpl() {
-		super();
-		eFlags |= MERGE_INTROSPECTION_EFLAG;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getFeatureDecorator();
-	}
-
-	public String getDisplayName() {
-		return isSetDisplayName() ? getDisplayNameGen() : getName();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getDisplayNameGen() {
-		return displayName;
-	}
-
-	public String getName() {
-		ENamedElement ne = (ENamedElement) getEModelElement();
-		if (ne != null)
-			return ne.getName();	// The name from the owner of the feature has to be the name of feature.
-		else
-			return "?";	// Don't know what it is. //$NON-NLS-1$
-	}
-	
-
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDisplayName(String newDisplayName) {
-		String oldDisplayName = displayName;
-		displayName = newDisplayName;
-		boolean oldDisplayNameESet = (eFlags & DISPLAY_NAME_ESETFLAG) != 0;
-		eFlags |= DISPLAY_NAME_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__DISPLAY_NAME, oldDisplayName, displayName, !oldDisplayNameESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetDisplayName() {
-		String oldDisplayName = displayName;
-		boolean oldDisplayNameESet = (eFlags & DISPLAY_NAME_ESETFLAG) != 0;
-		displayName = DISPLAY_NAME_EDEFAULT;
-		eFlags &= ~DISPLAY_NAME_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.FEATURE_DECORATOR__DISPLAY_NAME, oldDisplayName, DISPLAY_NAME_EDEFAULT, oldDisplayNameESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetDisplayName() {
-		return (eFlags & DISPLAY_NAME_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getShortDescription() {
-		return shortDescription;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setShortDescription(String newShortDescription) {
-		String oldShortDescription = shortDescription;
-		shortDescription = newShortDescription;
-		boolean oldShortDescriptionESet = (eFlags & SHORT_DESCRIPTION_ESETFLAG) != 0;
-		eFlags |= SHORT_DESCRIPTION_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__SHORT_DESCRIPTION, oldShortDescription, shortDescription, !oldShortDescriptionESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetShortDescription() {
-		String oldShortDescription = shortDescription;
-		boolean oldShortDescriptionESet = (eFlags & SHORT_DESCRIPTION_ESETFLAG) != 0;
-		shortDescription = SHORT_DESCRIPTION_EDEFAULT;
-		eFlags &= ~SHORT_DESCRIPTION_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.FEATURE_DECORATOR__SHORT_DESCRIPTION, oldShortDescription, SHORT_DESCRIPTION_EDEFAULT, oldShortDescriptionESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetShortDescription() {
-		return (eFlags & SHORT_DESCRIPTION_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getCategory() {
-		return category;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setCategory(String newCategory) {
-		String oldCategory = category;
-		category = newCategory;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__CATEGORY, oldCategory, category));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isExpert() {
-		return (eFlags & EXPERT_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExpert(boolean newExpert) {
-		boolean oldExpert = (eFlags & EXPERT_EFLAG) != 0;
-		if (newExpert) eFlags |= EXPERT_EFLAG; else eFlags &= ~EXPERT_EFLAG;
-		boolean oldExpertESet = (eFlags & EXPERT_ESETFLAG) != 0;
-		eFlags |= EXPERT_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__EXPERT, oldExpert, newExpert, !oldExpertESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetExpert() {
-		boolean oldExpert = (eFlags & EXPERT_EFLAG) != 0;
-		boolean oldExpertESet = (eFlags & EXPERT_ESETFLAG) != 0;
-		if (EXPERT_EDEFAULT) eFlags |= EXPERT_EFLAG; else eFlags &= ~EXPERT_EFLAG;
-		eFlags &= ~EXPERT_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.FEATURE_DECORATOR__EXPERT, oldExpert, EXPERT_EDEFAULT, oldExpertESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetExpert() {
-		return (eFlags & EXPERT_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isHidden() {
-		return (eFlags & HIDDEN_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setHidden(boolean newHidden) {
-		boolean oldHidden = (eFlags & HIDDEN_EFLAG) != 0;
-		if (newHidden) eFlags |= HIDDEN_EFLAG; else eFlags &= ~HIDDEN_EFLAG;
-		boolean oldHiddenESet = (eFlags & HIDDEN_ESETFLAG) != 0;
-		eFlags |= HIDDEN_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__HIDDEN, oldHidden, newHidden, !oldHiddenESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetHidden() {
-		boolean oldHidden = (eFlags & HIDDEN_EFLAG) != 0;
-		boolean oldHiddenESet = (eFlags & HIDDEN_ESETFLAG) != 0;
-		if (HIDDEN_EDEFAULT) eFlags |= HIDDEN_EFLAG; else eFlags &= ~HIDDEN_EFLAG;
-		eFlags &= ~HIDDEN_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.FEATURE_DECORATOR__HIDDEN, oldHidden, HIDDEN_EDEFAULT, oldHiddenESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetHidden() {
-		return (eFlags & HIDDEN_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isPreferred() {
-		return (eFlags & PREFERRED_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPreferred(boolean newPreferred) {
-		boolean oldPreferred = (eFlags & PREFERRED_EFLAG) != 0;
-		if (newPreferred) eFlags |= PREFERRED_EFLAG; else eFlags &= ~PREFERRED_EFLAG;
-		boolean oldPreferredESet = (eFlags & PREFERRED_ESETFLAG) != 0;
-		eFlags |= PREFERRED_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__PREFERRED, oldPreferred, newPreferred, !oldPreferredESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetPreferred() {
-		boolean oldPreferred = (eFlags & PREFERRED_EFLAG) != 0;
-		boolean oldPreferredESet = (eFlags & PREFERRED_ESETFLAG) != 0;
-		if (PREFERRED_EDEFAULT) eFlags |= PREFERRED_EFLAG; else eFlags &= ~PREFERRED_EFLAG;
-		eFlags &= ~PREFERRED_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.FEATURE_DECORATOR__PREFERRED, oldPreferred, PREFERRED_EDEFAULT, oldPreferredESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetPreferred() {
-		return (eFlags & PREFERRED_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isMergeIntrospection() {
-		return (eFlags & MERGE_INTROSPECTION_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMergeIntrospection(boolean newMergeIntrospection) {
-		boolean oldMergeIntrospection = (eFlags & MERGE_INTROSPECTION_EFLAG) != 0;
-		if (newMergeIntrospection) eFlags |= MERGE_INTROSPECTION_EFLAG; else eFlags &= ~MERGE_INTROSPECTION_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__MERGE_INTROSPECTION, oldMergeIntrospection, newMergeIntrospection));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isAttributesExplicitEmpty() {
-		return (eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttributesExplicitEmpty(boolean newAttributesExplicitEmpty) {
-		boolean oldAttributesExplicitEmpty = (eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0;
-		if (newAttributesExplicitEmpty) eFlags |= ATTRIBUTES_EXPLICIT_EMPTY_EFLAG; else eFlags &= ~ATTRIBUTES_EXPLICIT_EMPTY_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY, oldAttributesExplicitEmpty, newAttributesExplicitEmpty));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public long getImplicitlySetBits() {
-		return implicitlySetBits;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setImplicitlySetBits(long newImplicitlySetBits) {
-		long oldImplicitlySetBits = implicitlySetBits;
-		implicitlySetBits = newImplicitlySetBits;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__IMPLICITLY_SET_BITS, oldImplicitlySetBits, implicitlySetBits));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ImplicitItem getImplicitDecoratorFlag() {
-		return implicitDecoratorFlag;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setImplicitDecoratorFlag(ImplicitItem newImplicitDecoratorFlag) {
-		ImplicitItem oldImplicitDecoratorFlag = implicitDecoratorFlag;
-		implicitDecoratorFlag = newImplicitDecoratorFlag == null ? IMPLICIT_DECORATOR_FLAG_EDEFAULT : newImplicitDecoratorFlag;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG, oldImplicitDecoratorFlag, implicitDecoratorFlag));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EMap getAttributes() {
-		if (attributes == null) {
-			attributes = new EcoreEMap(BeaninfoPackage.eINSTANCE.getFeatureAttributeMapEntry(), FeatureAttributeMapEntryImpl.class, this, BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES);
-		}
-		return attributes;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (displayName: ");
-		if ((eFlags & DISPLAY_NAME_ESETFLAG) != 0) result.append(displayName); else result.append("<unset>");
-		result.append(", shortDescription: ");
-		if ((eFlags & SHORT_DESCRIPTION_ESETFLAG) != 0) result.append(shortDescription); else result.append("<unset>");
-		result.append(", category: ");
-		result.append(category);
-		result.append(", expert: ");
-		if ((eFlags & EXPERT_ESETFLAG) != 0) result.append((eFlags & EXPERT_EFLAG) != 0); else result.append("<unset>");
-		result.append(", hidden: ");
-		if ((eFlags & HIDDEN_ESETFLAG) != 0) result.append((eFlags & HIDDEN_EFLAG) != 0); else result.append("<unset>");
-		result.append(", preferred: ");
-		if ((eFlags & PREFERRED_ESETFLAG) != 0) result.append((eFlags & PREFERRED_EFLAG) != 0); else result.append("<unset>");
-		result.append(", mergeIntrospection: ");
-		result.append((eFlags & MERGE_INTROSPECTION_EFLAG) != 0);
-		result.append(", attributesExplicitEmpty: ");
-		result.append((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0);
-		result.append(", implicitlySetBits: ");
-		result.append(implicitlySetBits);
-		result.append(", implicitDecoratorFlag: ");
-		result.append(implicitDecoratorFlag);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.FEATURE_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.FEATURE_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.FEATURE_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.FEATURE_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.FEATURE_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.FEATURE_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.FEATURE_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.FEATURE_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.FEATURE_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.FEATURE_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.FEATURE_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.FEATURE_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.FEATURE_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.FEATURE_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.FEATURE_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * Called by overrides to eIsSet to test if source is set. This is because for the 
-	 * FeatureDecorator and subclasses, setting source to the classname is considered
-	 * to be not set since that is the new default for each class level. By doing this
-	 * when serializing it won't waste space and time adding a copy of the source string
-	 * to the serialized output and then creating a NEW copy on each decorator loaded
-	 * from an XMI file. 
-	 * 
-	 * @return <code>true</code> if source is not null and not equal to class name.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected boolean isSourceSet() {
-		return source != null && !getClass().getName().equals(source);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eIsSet(org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_DECORATOR__SOURCE:
-				return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			default:
-				return eIsSetGen(eFeature);
-		}
-	}
-
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.FEATURE_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.FEATURE_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.FEATURE_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.FEATURE_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.FEATURE_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.FEATURE_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.FEATURE_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.FEATURE_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.FEATURE_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.FEATURE_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.FEATURE_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.FEATURE_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.FEATURE_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.FEATURE_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.FEATURE_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/IndexedPropertyDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/IndexedPropertyDecoratorImpl.java
deleted file mode 100644
index bcd72a9..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/IndexedPropertyDecoratorImpl.java
+++ /dev/null
@@ -1,664 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: IndexedPropertyDecoratorImpl.java,v $
- *  $Revision: 1.12 $  $Date: 2005/09/19 15:43:02 $ 
- */
-
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-import org.eclipse.jem.internal.beaninfo.IndexedPropertyDecorator;
-import org.eclipse.jem.java.Field;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.Method;
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Indexed Property Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.IndexedPropertyDecoratorImpl#getIndexedReadMethod <em>Indexed Read Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.IndexedPropertyDecoratorImpl#getIndexedWriteMethod <em>Indexed Write Method</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-
-public class IndexedPropertyDecoratorImpl extends PropertyDecoratorImpl implements IndexedPropertyDecorator{
-	
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 */
-	public static final long INDEXED_READMETHOD_IMPLICIT = 0x100000L;	// Start kind of high so as to allow PropertyDecorator to increase without conflig.
-	public static final long INDEXED_WRITEMETHOD_IMPLICIT = 0x200000L;
-	
-	/**
-	 * The cached value of the '{@link #getIndexedReadMethod() <em>Indexed Read Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIndexedReadMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method indexedReadMethod = null;
-	/**
-	 * The flag representing whether the Indexed Read Method reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int INDEXED_READ_METHOD_ESETFLAG = 1 << 29;
-
-	/**
-	 * The cached value of the '{@link #getIndexedWriteMethod() <em>Indexed Write Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIndexedWriteMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method indexedWriteMethod = null;
-	
-	/**
-	 * The flag representing whether the Indexed Write Method reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int INDEXED_WRITE_METHOD_ESETFLAG = 1 << 30;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	protected IndexedPropertyDecoratorImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getIndexedPropertyDecorator();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getIndexedReadMethod() {
-		if (indexedReadMethod != null && indexedReadMethod.eIsProxy()) {
-			Method oldIndexedReadMethod = indexedReadMethod;
-			indexedReadMethod = (Method)eResolveProxy((InternalEObject)indexedReadMethod);
-			if (indexedReadMethod != oldIndexedReadMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD, oldIndexedReadMethod, indexedReadMethod));
-			}
-		}
-		return indexedReadMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIndexedReadMethod(Method newIndexedReadMethod) {
-		Method oldIndexedReadMethod = indexedReadMethod;
-		indexedReadMethod = newIndexedReadMethod;
-		boolean oldIndexedReadMethodESet = (eFlags & INDEXED_READ_METHOD_ESETFLAG) != 0;
-		eFlags |= INDEXED_READ_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD, oldIndexedReadMethod, indexedReadMethod, !oldIndexedReadMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetIndexedReadMethod() {
-		Method oldIndexedReadMethod = indexedReadMethod;
-		boolean oldIndexedReadMethodESet = (eFlags & INDEXED_READ_METHOD_ESETFLAG) != 0;
-		indexedReadMethod = null;
-		eFlags &= ~INDEXED_READ_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD, oldIndexedReadMethod, null, oldIndexedReadMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetIndexedReadMethod() {
-		return (eFlags & INDEXED_READ_METHOD_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getIndexedWriteMethod() {
-		if (indexedWriteMethod != null && indexedWriteMethod.eIsProxy()) {
-			Method oldIndexedWriteMethod = indexedWriteMethod;
-			indexedWriteMethod = (Method)eResolveProxy((InternalEObject)indexedWriteMethod);
-			if (indexedWriteMethod != oldIndexedWriteMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD, oldIndexedWriteMethod, indexedWriteMethod));
-			}
-		}
-		return indexedWriteMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIndexedWriteMethod(Method newIndexedWriteMethod) {
-		Method oldIndexedWriteMethod = indexedWriteMethod;
-		indexedWriteMethod = newIndexedWriteMethod;
-		boolean oldIndexedWriteMethodESet = (eFlags & INDEXED_WRITE_METHOD_ESETFLAG) != 0;
-		eFlags |= INDEXED_WRITE_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD, oldIndexedWriteMethod, indexedWriteMethod, !oldIndexedWriteMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetIndexedWriteMethod() {
-		Method oldIndexedWriteMethod = indexedWriteMethod;
-		boolean oldIndexedWriteMethodESet = (eFlags & INDEXED_WRITE_METHOD_ESETFLAG) != 0;
-		indexedWriteMethod = null;
-		eFlags &= ~INDEXED_WRITE_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD, oldIndexedWriteMethod, null, oldIndexedWriteMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetIndexedWriteMethod() {
-		return (eFlags & INDEXED_WRITE_METHOD_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__BOUND:
-				return isBound() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONSTRAINED:
-				return isConstrained() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DESIGN_TIME:
-				return isDesignTime() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				return isAlwaysIncompatible() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FILTER_FLAGS:
-				return getFilterFlags();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				return isFieldReadOnly() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				if (resolve) return getPropertyEditorClass();
-				return basicGetPropertyEditorClass();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__READ_METHOD:
-				if (resolve) return getReadMethod();
-				return basicGetReadMethod();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__WRITE_METHOD:
-				if (resolve) return getWriteMethod();
-				return basicGetWriteMethod();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD:
-				if (resolve) return getField();
-				return basicGetField();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD:
-				if (resolve) return getIndexedReadMethod();
-				return basicGetIndexedReadMethod();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD:
-				if (resolve) return getIndexedWriteMethod();
-				return basicGetIndexedWriteMethod();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__BOUND:
-				setBound(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONSTRAINED:
-				setConstrained(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DESIGN_TIME:
-				setDesignTime(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				setAlwaysIncompatible(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FILTER_FLAGS:
-				getFilterFlags().clear();
-				getFilterFlags().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				setFieldReadOnly(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				setPropertyEditorClass((JavaClass)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__READ_METHOD:
-				setReadMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__WRITE_METHOD:
-				setWriteMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD:
-				setField((Field)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD:
-				setIndexedReadMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD:
-				setIndexedWriteMethod((Method)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__BOUND:
-				unsetBound();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONSTRAINED:
-				unsetConstrained();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DESIGN_TIME:
-				unsetDesignTime();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				setAlwaysIncompatible(ALWAYS_INCOMPATIBLE_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FILTER_FLAGS:
-				getFilterFlags().clear();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				setFieldReadOnly(FIELD_READ_ONLY_EDEFAULT);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				setPropertyEditorClass((JavaClass)null);
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__READ_METHOD:
-				unsetReadMethod();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__WRITE_METHOD:
-				unsetWriteMethod();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD:
-				unsetField();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD:
-				unsetIndexedReadMethod();
-				return;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD:
-				unsetIndexedWriteMethod();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eIsSet(org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SOURCE:
-				return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			default:
-				return eIsSetGen(eFeature);
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__BOUND:
-				return isSetBound();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__CONSTRAINED:
-				return isSetConstrained();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__DESIGN_TIME:
-				return isSetDesignTime();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				return ((eFlags & ALWAYS_INCOMPATIBLE_EFLAG) != 0) != ALWAYS_INCOMPATIBLE_EDEFAULT;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FILTER_FLAGS:
-				return filterFlags != null && !filterFlags.isEmpty();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				return ((eFlags & FIELD_READ_ONLY_EFLAG) != 0) != FIELD_READ_ONLY_EDEFAULT;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				return propertyEditorClass != null;
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__READ_METHOD:
-				return isSetReadMethod();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__WRITE_METHOD:
-				return isSetWriteMethod();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__FIELD:
-				return isSetField();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_READ_METHOD:
-				return isSetIndexedReadMethod();
-			case BeaninfoPackage.INDEXED_PROPERTY_DECORATOR__INDEXED_WRITE_METHOD:
-				return isSetIndexedWriteMethod();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetIndexedReadMethod() {
-		return indexedReadMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetIndexedWriteMethod() {
-		return indexedWriteMethod;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/MethodDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/MethodDecoratorImpl.java
deleted file mode 100644
index 80a2aeb..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/MethodDecoratorImpl.java
+++ /dev/null
@@ -1,592 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: MethodDecoratorImpl.java,v $
- *  $Revision: 1.11 $  $Date: 2005/09/19 15:43:02 $ 
- */
-
-
-import java.util.Collection;
-
-import java.util.*;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoFactory;
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-import org.eclipse.jem.internal.beaninfo.MethodDecorator;
-import org.eclipse.jem.internal.beaninfo.MethodProxy;
-import org.eclipse.jem.internal.beaninfo.ParameterDecorator;
-import org.eclipse.jem.java.JavaParameter;
-import org.eclipse.jem.java.Method;
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Method Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.MethodDecoratorImpl#isParmsExplicitEmpty <em>Parms Explicit Empty</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.MethodDecoratorImpl#getParameterDescriptors <em>Parameter Descriptors</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.MethodDecoratorImpl#getSerParmDesc <em>Ser Parm Desc</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-
-public class MethodDecoratorImpl extends FeatureDecoratorImpl implements MethodDecorator{
-	
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 */
-	public static final long METHOD_PARAMETERS_IMPLICIT = 0x1L;
-	public static final long METHOD_PARAMETERS_DEFAULT = 02L;	// Special, means were created by default and not by implicit (from beaninfo).
-
-	/**
-	 * The default value of the '{@link #isParmsExplicitEmpty() <em>Parms Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isParmsExplicitEmpty()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean PARMS_EXPLICIT_EMPTY_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isParmsExplicitEmpty() <em>Parms Explicit Empty</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isParmsExplicitEmpty()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int PARMS_EXPLICIT_EMPTY_EFLAG = 1 << 18;
-
-	/**
-	 * The cached value of the '{@link #getSerParmDesc() <em>Ser Parm Desc</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSerParmDesc()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList serParmDesc = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	protected MethodDecoratorImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getMethodDecorator();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isParmsExplicitEmpty() {
-		return (eFlags & PARMS_EXPLICIT_EMPTY_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setParmsExplicitEmpty(boolean newParmsExplicitEmpty) {
-		boolean oldParmsExplicitEmpty = (eFlags & PARMS_EXPLICIT_EMPTY_EFLAG) != 0;
-		if (newParmsExplicitEmpty) eFlags |= PARMS_EXPLICIT_EMPTY_EFLAG; else eFlags &= ~PARMS_EXPLICIT_EMPTY_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY, oldParmsExplicitEmpty, newParmsExplicitEmpty));
-	}
-
-	/*
-	 * This is called if parms list not explicitly set and it was empty from BeanInfo or
-	 * this is from reflection. This becomes the default list based upon the method
-	 * we are attached to.
-	 */
-	private EList createDefaultParmsList() {
-		EList parmsList = this.getSerParmDesc();
-		parmsList.clear();
-		
-		setImplicitlySetBits(getImplicitlySetBits()|METHOD_PARAMETERS_DEFAULT);	// Mark as we implicitly filled it in.
-		List p = getMethodParameters();
-		if (p == null)
-			return parmsList;	// Couldn't get the list for some reason, so leave as is.
-		int psize = p.size();
-		for (int i=0; i<psize; i++) {
-			ParameterDecorator pd = BeaninfoFactory.eINSTANCE.createParameterDecorator();
-			JavaParameter jp = (JavaParameter) p.get(i);
-			pd.setName(jp.getName());
-			pd.setImplicitlySetBits(ParameterDecoratorImpl.PARAMETER_NAME_IMPLICIT);
-			pd.setParameter(jp);
-			parmsList.add(pd);
-		}
-		return parmsList;
-	}
-	
-	/*
-	 * Initialize the ParameterDecorators to hook up the JavaParameter they are describing.
-	 * This is called from ParameterDecorator when it finds that its JavaParameter has not been set.
-	 * This means that it was explicitly added and we need to setup the parms.
-	 * <p>
-	 * Note this an internal method for BeanInfo. It is not meant to be called by clients.
-	 */
-	void initializeParameters() {
-		if (this.serParmDesc == null)
-			return;
-		List mp = getMethodParameters();
-		if (mp.isEmpty())
-			return;	// Nothing that can be described.
-		int psize = Math.min(this.serParmDesc.size(), mp.size());
-		for (int i=0; i < psize; i++)
-			((ParameterDecorator) this.serParmDesc.get(i)).setParameter((JavaParameter) mp.get(i));
-	}
-
-
-	/*
-	 * Get the jem parameters from the method (jem method)
-	 */
-	private List getMethodParameters() {
-		// Get the method
-		Method m = null;
-		Object d = getEModelElement();
-		if (d instanceof Method)
-			m = (Method) d;
-		else 
-			if (d instanceof MethodProxy)
-				m = ((MethodProxy) d).getMethod();
-			else
-				return Collections.EMPTY_LIST;	// Not decorating correct object.
-		if (m == null)
-			return Collections.EMPTY_LIST;	// Couldn't find the method.
-		List p = m.getParameters();
-		return p;
-	}
-			
-			
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (parmsExplicitEmpty: ");
-		result.append((eFlags & PARMS_EXPLICIT_EMPTY_EFLAG) != 0);
-		result.append(')');
-		return result.toString();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.beaninfo.MethodDecorator#getParameterDescriptors()
-	 */
-	public EList getParameterDescriptors() {
-		if (!isParmsExplicitEmpty() && getSerParmDesc().isEmpty() && (getImplicitlySetBits()&(METHOD_PARAMETERS_IMPLICIT | METHOD_PARAMETERS_DEFAULT)) == 0) {
-			// Not explicitly empty, it is empty, and we have not implicitly or by defaults made it empty, then create the defaults.
-			createDefaultParmsList();
-		}
-		return getSerParmDesc();
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getParameterDescriptorsGen() {
-		// TODO: implement this method to return the 'Parameter Descriptors' reference list
-		// Ensure that you remove @generated or mark it @generated NOT
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getSerParmDesc() {
-		if (serParmDesc == null) {
-			serParmDesc = new EObjectContainmentEList(ParameterDecorator.class, this, BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC);
-		}
-		return serParmDesc;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.METHOD_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.METHOD_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.METHOD_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC:
-					return ((InternalEList)getSerParmDesc()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.METHOD_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.METHOD_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.METHOD_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.METHOD_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.METHOD_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.METHOD_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.METHOD_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.METHOD_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-			case BeaninfoPackage.METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY:
-				return isParmsExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_DECORATOR__PARAMETER_DESCRIPTORS:
-				return getParameterDescriptors();
-			case BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC:
-				return getSerParmDesc();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY:
-				setParmsExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__PARAMETER_DESCRIPTORS:
-				getParameterDescriptors().clear();
-				getParameterDescriptors().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC:
-				getSerParmDesc().clear();
-				getSerParmDesc().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY:
-				setParmsExplicitEmpty(PARMS_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__PARAMETER_DESCRIPTORS:
-				getParameterDescriptors().clear();
-				return;
-			case BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC:
-				getSerParmDesc().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/*
-	 * This is overridden so that we can do special is set tests:
-	 * 1) parameter descriptors: check if serParmDesc exists and not empty, since parameter descriptors is derived.
-	 * 2) serParmDesc: if flag set to default parm desc, then answer not set, else do normal isSet test. That way if set by default it won't serialize
-	 *    out the unneeded default parms. They can be reconstructed quickly when needed.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_DECORATOR__SOURCE:
-					return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			case BeaninfoPackage.METHOD_DECORATOR__PARAMETER_DESCRIPTORS:
-				return eIsSetGen(BeaninfoPackage.eINSTANCE.getMethodDecorator_SerParmDesc());	// Let default serParmDesc is set work.
-			case BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC:
-				if ((getImplicitlySetBits() & METHOD_PARAMETERS_DEFAULT) != 0)
-					return false;	// Not considered set if initialized by default.
-				else
-					return eIsSetGen(eFeature);	// Not set by default, so check true setting.
-			default:
-				return eIsSetGen(eFeature);	// Everything else use the gen method.
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.METHOD_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.METHOD_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.METHOD_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.METHOD_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.METHOD_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.METHOD_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.METHOD_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.METHOD_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.METHOD_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.METHOD_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.METHOD_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.METHOD_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.METHOD_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.METHOD_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case BeaninfoPackage.METHOD_DECORATOR__PARMS_EXPLICIT_EMPTY:
-				return ((eFlags & PARMS_EXPLICIT_EMPTY_EFLAG) != 0) != PARMS_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.METHOD_DECORATOR__PARAMETER_DESCRIPTORS:
-				return !getParameterDescriptors().isEmpty();
-			case BeaninfoPackage.METHOD_DECORATOR__SER_PARM_DESC:
-				return serParmDesc != null && !serParmDesc.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/MethodProxyImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/MethodProxyImpl.java
deleted file mode 100644
index 48de782..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/MethodProxyImpl.java
+++ /dev/null
@@ -1,342 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: MethodProxyImpl.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EOperationImpl;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.MethodProxy;
-import org.eclipse.jem.java.Method;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Method Proxy</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.MethodProxyImpl#getMethod <em>Method</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-
-public class MethodProxyImpl extends EOperationImpl implements MethodProxy {
-	/**
-	 * The cached value of the '{@link #getMethod() <em>Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method method = null;
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	protected MethodProxyImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getMethodProxy();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getMethod() {
-		if (method != null && method.eIsProxy()) {
-			Method oldMethod = method;
-			method = (Method)eResolveProxy((InternalEObject)method);
-			if (method != oldMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.METHOD_PROXY__METHOD, oldMethod, method));
-			}
-		}
-		return method;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetMethod() {
-		return method;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMethod(Method newMethod) {
-		Method oldMethod = method;
-		method = newMethod;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.METHOD_PROXY__METHOD, oldMethod, method));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.METHOD_PROXY__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS, msgs);
-				case BeaninfoPackage.METHOD_PROXY__EPARAMETERS:
-					return ((InternalEList)getEParameters()).basicAdd(otherEnd, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.METHOD_PROXY__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS:
-					return eBasicSetContainer(null, BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS, msgs);
-				case BeaninfoPackage.METHOD_PROXY__EPARAMETERS:
-					return ((InternalEList)getEParameters()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS:
-					return eContainer.eInverseRemove(this, EcorePackage.ECLASS__EOPERATIONS, EClass.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_PROXY__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.METHOD_PROXY__NAME:
-				return getName();
-			case BeaninfoPackage.METHOD_PROXY__ORDERED:
-				return isOrdered() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_PROXY__UNIQUE:
-				return isUnique() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_PROXY__LOWER_BOUND:
-				return new Integer(getLowerBound());
-			case BeaninfoPackage.METHOD_PROXY__UPPER_BOUND:
-				return new Integer(getUpperBound());
-			case BeaninfoPackage.METHOD_PROXY__MANY:
-				return isMany() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_PROXY__REQUIRED:
-				return isRequired() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.METHOD_PROXY__ETYPE:
-				if (resolve) return getEType();
-				return basicGetEType();
-			case BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS:
-				return getEContainingClass();
-			case BeaninfoPackage.METHOD_PROXY__EPARAMETERS:
-				return getEParameters();
-			case BeaninfoPackage.METHOD_PROXY__EEXCEPTIONS:
-				return getEExceptions();
-			case BeaninfoPackage.METHOD_PROXY__METHOD:
-				if (resolve) return getMethod();
-				return basicGetMethod();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_PROXY__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__NAME:
-				setName((String)newValue);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__ORDERED:
-				setOrdered(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_PROXY__UNIQUE:
-				setUnique(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.METHOD_PROXY__LOWER_BOUND:
-				setLowerBound(((Integer)newValue).intValue());
-				return;
-			case BeaninfoPackage.METHOD_PROXY__UPPER_BOUND:
-				setUpperBound(((Integer)newValue).intValue());
-				return;
-			case BeaninfoPackage.METHOD_PROXY__ETYPE:
-				setEType((EClassifier)newValue);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__EPARAMETERS:
-				getEParameters().clear();
-				getEParameters().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__EEXCEPTIONS:
-				getEExceptions().clear();
-				getEExceptions().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__METHOD:
-				setMethod((Method)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_PROXY__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.METHOD_PROXY__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__ORDERED:
-				setOrdered(ORDERED_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__UNIQUE:
-				setUnique(UNIQUE_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__LOWER_BOUND:
-				setLowerBound(LOWER_BOUND_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__UPPER_BOUND:
-				setUpperBound(UPPER_BOUND_EDEFAULT);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__ETYPE:
-				setEType((EClassifier)null);
-				return;
-			case BeaninfoPackage.METHOD_PROXY__EPARAMETERS:
-				getEParameters().clear();
-				return;
-			case BeaninfoPackage.METHOD_PROXY__EEXCEPTIONS:
-				getEExceptions().clear();
-				return;
-			case BeaninfoPackage.METHOD_PROXY__METHOD:
-				setMethod((Method)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.METHOD_PROXY__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.METHOD_PROXY__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case BeaninfoPackage.METHOD_PROXY__ORDERED:
-				return ((eFlags & ORDERED_EFLAG) != 0) != ORDERED_EDEFAULT;
-			case BeaninfoPackage.METHOD_PROXY__UNIQUE:
-				return ((eFlags & UNIQUE_EFLAG) != 0) != UNIQUE_EDEFAULT;
-			case BeaninfoPackage.METHOD_PROXY__LOWER_BOUND:
-				return lowerBound != LOWER_BOUND_EDEFAULT;
-			case BeaninfoPackage.METHOD_PROXY__UPPER_BOUND:
-				return upperBound != UPPER_BOUND_EDEFAULT;
-			case BeaninfoPackage.METHOD_PROXY__MANY:
-				return isMany() != MANY_EDEFAULT;
-			case BeaninfoPackage.METHOD_PROXY__REQUIRED:
-				return isRequired() != REQUIRED_EDEFAULT;
-			case BeaninfoPackage.METHOD_PROXY__ETYPE:
-				return eType != null;
-			case BeaninfoPackage.METHOD_PROXY__ECONTAINING_CLASS:
-				return getEContainingClass() != null;
-			case BeaninfoPackage.METHOD_PROXY__EPARAMETERS:
-				return eParameters != null && !eParameters.isEmpty();
-			case BeaninfoPackage.METHOD_PROXY__EEXCEPTIONS:
-				return eExceptions != null && !eExceptions.isEmpty();
-			case BeaninfoPackage.METHOD_PROXY__METHOD:
-				return method != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/ParameterDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/ParameterDecoratorImpl.java
deleted file mode 100644
index 1033716..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/ParameterDecoratorImpl.java
+++ /dev/null
@@ -1,522 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ParameterDecoratorImpl.java,v $
- *  $Revision: 1.11 $  $Date: 2005/09/19 15:43:02 $ 
- */
-package org.eclipse.jem.internal.beaninfo.impl;
-
-
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-import org.eclipse.jem.internal.beaninfo.ParameterDecorator;
-import org.eclipse.jem.java.JavaParameter;
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Method Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.ParameterDecoratorImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.ParameterDecoratorImpl#getParameter <em>Parameter</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-public class ParameterDecoratorImpl extends FeatureDecoratorImpl implements ParameterDecorator{
-	
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 */
-	public static final long PARAMETER_NAME_IMPLICIT = 0x1L;
-
-	/**
-	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String NAME_EDEFAULT = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ParameterDecoratorImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getParameterDecorator();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getName() {
-		return name;
-	}
-
-	/**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected String name = NAME_EDEFAULT;
-	/**
-	 * The cached value of the '{@link #getParameter() <em>Parameter</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getParameter()
-	 * @generated
-	 * @ordered
-	 */
-	protected JavaParameter parameter = null;
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setName(String newName) {
-		String oldName = name;
-		name = newName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PARAMETER_DECORATOR__NAME, oldName, name));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (name: ");
-		result.append(name);
-		result.append(')');
-		return result.toString();
-	}
-
-	/*
-	 * Flag for if we tried to link up this parameter to java parm.
-	 */
-	private boolean triedOnce;
-	
-	/**
-	 * The JavaParameter that this ParameterDecorator is decorating.
-	 */
-	public JavaParameter getParameter() {
-		if (!eIsSet(BeaninfoPackage.eINSTANCE.getParameterDecorator_Parameter()) && !triedOnce) {
-			// Need to try to fill in the parameter setting.
-			triedOnce = true;
-			EObject container = eContainer();	// See if we are in a MethodDecorator.
-			if (container instanceof MethodDecoratorImpl)
-				((MethodDecoratorImpl) container).initializeParameters();
-		}
-		
-		return getParameterGen();
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaParameter getParameterGen() {
-		if (parameter != null && parameter.eIsProxy()) {
-			JavaParameter oldParameter = parameter;
-			parameter = (JavaParameter)eResolveProxy((InternalEObject)parameter);
-			if (parameter != oldParameter) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.PARAMETER_DECORATOR__PARAMETER, oldParameter, parameter));
-			}
-		}
-		return parameter;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaParameter basicGetParameter() {
-		return parameter;
-	}
-
-	public void setParameter(JavaParameter newParameter) {
-		if (newParameter == null)
-			triedOnce = false;
-		setParameterGen(newParameter);
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setParameterGen(JavaParameter newParameter) {
-		JavaParameter oldParameter = parameter;
-		parameter = newParameter;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PARAMETER_DECORATOR__PARAMETER, oldParameter, parameter));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.PARAMETER_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.PARAMETER_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.PARAMETER_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.PARAMETER_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PARAMETER_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.PARAMETER_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.PARAMETER_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.PARAMETER_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.PARAMETER_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.PARAMETER_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.PARAMETER_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.PARAMETER_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.PARAMETER_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PARAMETER_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PARAMETER_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PARAMETER_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-			case BeaninfoPackage.PARAMETER_DECORATOR__NAME:
-				return getName();
-			case BeaninfoPackage.PARAMETER_DECORATOR__PARAMETER:
-				if (resolve) return getParameter();
-				return basicGetParameter();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PARAMETER_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__NAME:
-				setName((String)newValue);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__PARAMETER:
-				setParameter((JavaParameter)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PARAMETER_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case BeaninfoPackage.PARAMETER_DECORATOR__PARAMETER:
-				setParameter((JavaParameter)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eIsSet(org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PARAMETER_DECORATOR__SOURCE:
-				return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			default:
-				return eIsSetGen(eFeature);
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PARAMETER_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.PARAMETER_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.PARAMETER_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.PARAMETER_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.PARAMETER_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.PARAMETER_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.PARAMETER_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.PARAMETER_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.PARAMETER_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.PARAMETER_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.PARAMETER_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.PARAMETER_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.PARAMETER_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.PARAMETER_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.PARAMETER_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case BeaninfoPackage.PARAMETER_DECORATOR__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case BeaninfoPackage.PARAMETER_DECORATOR__PARAMETER:
-				return parameter != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/PropertyDecoratorImpl.java b/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/PropertyDecoratorImpl.java
deleted file mode 100644
index 64530c2..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/impl/PropertyDecoratorImpl.java
+++ /dev/null
@@ -1,1184 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.impl;
-/*
- *  $RCSfile: PropertyDecoratorImpl.java,v $
- *  $Revision: 1.18 $  $Date: 2005/09/19 15:43:02 $ 
- */
-
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.beaninfo.BeaninfoPackage;
-import org.eclipse.jem.internal.beaninfo.ImplicitItem;
-import org.eclipse.jem.internal.beaninfo.PropertyDecorator;
-import org.eclipse.jem.java.Field;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.Method;
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property Decorator</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#isBound <em>Bound</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#isConstrained <em>Constrained</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#isDesignTime <em>Design Time</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#isAlwaysIncompatible <em>Always Incompatible</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#getFilterFlags <em>Filter Flags</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#isFieldReadOnly <em>Field Read Only</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#getPropertyEditorClass <em>Property Editor Class</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#getReadMethod <em>Read Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#getWriteMethod <em>Write Method</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.beaninfo.impl.PropertyDecoratorImpl#getField <em>Field</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-
-
-public class PropertyDecoratorImpl extends FeatureDecoratorImpl implements PropertyDecorator{
-
-	/**
-	 * Bits for implicitly set features. This is internal, not meant for clients.
-	 */
-	public static final long PROPERTY_EDITOR_CLASS_IMPLICIT = 0x1L;
-	public static final long PROPERTY_TYPE_IMPLICIT = 0x2L;
-	public static final long PROPERTY_READMETHOD_IMPLICIT = 0x4L;
-	public static final long PROPERTY_WRITEMETHOD_IMPLICIT = 0x8L;
-	public static final long PROPERTY_BOUND_IMPLICIT = 0x10L;
-	public static final long PROPERTY_CONSTRAINED_IMPLICIT = 0x20L;
-	public static final long PROPERTY_DESIGNTIME_IMPLICIT = 0x40L;
-	public static final long PROPERTY_FIELD_IMPLICIT = 0x80L;
-	
-	
-	/**
-	 * The default value of the '{@link #isBound() <em>Bound</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isBound()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean BOUND_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isBound() <em>Bound</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isBound()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int BOUND_EFLAG = 1 << 18;
-
-	/**
-	 * The flag representing whether the Bound attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int BOUND_ESETFLAG = 1 << 19;
-
-	/**
-	 * The default value of the '{@link #isConstrained() <em>Constrained</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isConstrained()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean CONSTRAINED_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isConstrained() <em>Constrained</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isConstrained()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int CONSTRAINED_EFLAG = 1 << 20;
-
-	/**
-	 * The flag representing whether the Constrained attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int CONSTRAINED_ESETFLAG = 1 << 21;
-
-	/**
-	 * The default value of the '{@link #isDesignTime() <em>Design Time</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isDesignTime()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean DESIGN_TIME_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isDesignTime() <em>Design Time</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isDesignTime()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int DESIGN_TIME_EFLAG = 1 << 22;
-
-	/**
-	 * The flag representing whether the Design Time attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int DESIGN_TIME_ESETFLAG = 1 << 23;
-
-	/**
-	 * The default value of the '{@link #isAlwaysIncompatible() <em>Always Incompatible</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isAlwaysIncompatible()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean ALWAYS_INCOMPATIBLE_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isAlwaysIncompatible() <em>Always Incompatible</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isAlwaysIncompatible()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int ALWAYS_INCOMPATIBLE_EFLAG = 1 << 24;
-
-	/**
-	 * The cached value of the '{@link #getFilterFlags() <em>Filter Flags</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFilterFlags()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList filterFlags = null;
-	/**
-	 * The default value of the '{@link #isFieldReadOnly() <em>Field Read Only</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFieldReadOnly()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean FIELD_READ_ONLY_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isFieldReadOnly() <em>Field Read Only</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFieldReadOnly()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int FIELD_READ_ONLY_EFLAG = 1 << 25;
-
-	/**
-	 * The cached value of the '{@link #getPropertyEditorClass() <em>Property Editor Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyEditorClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected JavaClass propertyEditorClass = null;
-	/**
-	 * The cached value of the '{@link #getReadMethod() <em>Read Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReadMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method readMethod = null;
-	/**
-	 * The flag representing whether the Read Method reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int READ_METHOD_ESETFLAG = 1 << 26;
-
-	/**
-	 * The cached value of the '{@link #getWriteMethod() <em>Write Method</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getWriteMethod()
-	 * @generated
-	 * @ordered
-	 */
-	protected Method writeMethod = null;
-	
-	/**
-	 * The flag representing whether the Write Method reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int WRITE_METHOD_ESETFLAG = 1 << 27;
-
-	/**
-	 * The cached value of the '{@link #getField() <em>Field</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getField()
-	 * @generated
-	 * @ordered
-	 */
-	protected Field field = null;
-
-	/**
-	 * The flag representing whether the Field reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int FIELD_ESETFLAG = 1 << 28;
-
-	/**
-	 * This it the property type. If null, then it will
-	 * query against model element owner.
-	 * 
-	 * @since 1.2.0
-	 */
-	protected EClassifier propertyType;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */	
-	protected PropertyDecoratorImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return BeaninfoPackage.eINSTANCE.getPropertyDecorator();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isBound() {
-		return (eFlags & BOUND_EFLAG) != 0;
-	}
-
-	public EClassifier getPropertyType() {
-		if (propertyType == null) {
-			EStructuralFeature feature = (EStructuralFeature) getEModelElement();
-			return (feature != null) ? feature.getEType() : null;
-		} else
-			return propertyType;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyType(EClassifier propertyType) {
-		// TODO: implement this method
-		// Ensure that you remove @generated or mark it @generated NOT
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBound(boolean newBound) {
-		boolean oldBound = (eFlags & BOUND_EFLAG) != 0;
-		if (newBound) eFlags |= BOUND_EFLAG; else eFlags &= ~BOUND_EFLAG;
-		boolean oldBoundESet = (eFlags & BOUND_ESETFLAG) != 0;
-		eFlags |= BOUND_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__BOUND, oldBound, newBound, !oldBoundESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetBound() {
-		boolean oldBound = (eFlags & BOUND_EFLAG) != 0;
-		boolean oldBoundESet = (eFlags & BOUND_ESETFLAG) != 0;
-		if (BOUND_EDEFAULT) eFlags |= BOUND_EFLAG; else eFlags &= ~BOUND_EFLAG;
-		eFlags &= ~BOUND_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.PROPERTY_DECORATOR__BOUND, oldBound, BOUND_EDEFAULT, oldBoundESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetBound() {
-		return (eFlags & BOUND_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isConstrained() {
-		return (eFlags & CONSTRAINED_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConstrained(boolean newConstrained) {
-		boolean oldConstrained = (eFlags & CONSTRAINED_EFLAG) != 0;
-		if (newConstrained) eFlags |= CONSTRAINED_EFLAG; else eFlags &= ~CONSTRAINED_EFLAG;
-		boolean oldConstrainedESet = (eFlags & CONSTRAINED_ESETFLAG) != 0;
-		eFlags |= CONSTRAINED_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__CONSTRAINED, oldConstrained, newConstrained, !oldConstrainedESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetConstrained() {
-		boolean oldConstrained = (eFlags & CONSTRAINED_EFLAG) != 0;
-		boolean oldConstrainedESet = (eFlags & CONSTRAINED_ESETFLAG) != 0;
-		if (CONSTRAINED_EDEFAULT) eFlags |= CONSTRAINED_EFLAG; else eFlags &= ~CONSTRAINED_EFLAG;
-		eFlags &= ~CONSTRAINED_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.PROPERTY_DECORATOR__CONSTRAINED, oldConstrained, CONSTRAINED_EDEFAULT, oldConstrainedESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetConstrained() {
-		return (eFlags & CONSTRAINED_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isDesignTime() {
-		return (eFlags & DESIGN_TIME_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDesignTime(boolean newDesignTime) {
-		boolean oldDesignTime = (eFlags & DESIGN_TIME_EFLAG) != 0;
-		if (newDesignTime) eFlags |= DESIGN_TIME_EFLAG; else eFlags &= ~DESIGN_TIME_EFLAG;
-		boolean oldDesignTimeESet = (eFlags & DESIGN_TIME_ESETFLAG) != 0;
-		eFlags |= DESIGN_TIME_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__DESIGN_TIME, oldDesignTime, newDesignTime, !oldDesignTimeESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetDesignTime() {
-		boolean oldDesignTime = (eFlags & DESIGN_TIME_EFLAG) != 0;
-		boolean oldDesignTimeESet = (eFlags & DESIGN_TIME_ESETFLAG) != 0;
-		if (DESIGN_TIME_EDEFAULT) eFlags |= DESIGN_TIME_EFLAG; else eFlags &= ~DESIGN_TIME_EFLAG;
-		eFlags &= ~DESIGN_TIME_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.PROPERTY_DECORATOR__DESIGN_TIME, oldDesignTime, DESIGN_TIME_EDEFAULT, oldDesignTimeESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetDesignTime() {
-		return (eFlags & DESIGN_TIME_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isAlwaysIncompatible() {
-		return (eFlags & ALWAYS_INCOMPATIBLE_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAlwaysIncompatible(boolean newAlwaysIncompatible) {
-		boolean oldAlwaysIncompatible = (eFlags & ALWAYS_INCOMPATIBLE_EFLAG) != 0;
-		if (newAlwaysIncompatible) eFlags |= ALWAYS_INCOMPATIBLE_EFLAG; else eFlags &= ~ALWAYS_INCOMPATIBLE_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE, oldAlwaysIncompatible, newAlwaysIncompatible));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFilterFlags() {
-		if (filterFlags == null) {
-			filterFlags = new EDataTypeUniqueEList(String.class, this, BeaninfoPackage.PROPERTY_DECORATOR__FILTER_FLAGS);
-		}
-		return filterFlags;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isFieldReadOnly() {
-		return (eFlags & FIELD_READ_ONLY_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFieldReadOnly(boolean newFieldReadOnly) {
-		boolean oldFieldReadOnly = (eFlags & FIELD_READ_ONLY_EFLAG) != 0;
-		if (newFieldReadOnly) eFlags |= FIELD_READ_ONLY_EFLAG; else eFlags &= ~FIELD_READ_ONLY_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__FIELD_READ_ONLY, oldFieldReadOnly, newFieldReadOnly));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass getPropertyEditorClass() {
-		if (propertyEditorClass != null && propertyEditorClass.eIsProxy()) {
-			JavaClass oldPropertyEditorClass = propertyEditorClass;
-			propertyEditorClass = (JavaClass)eResolveProxy((InternalEObject)propertyEditorClass);
-			if (propertyEditorClass != oldPropertyEditorClass) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS, oldPropertyEditorClass, propertyEditorClass));
-			}
-		}
-		return propertyEditorClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyEditorClass(JavaClass newPropertyEditorClass) {
-		JavaClass oldPropertyEditorClass = propertyEditorClass;
-		propertyEditorClass = newPropertyEditorClass;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS, oldPropertyEditorClass, propertyEditorClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getReadMethod() {
-		if (readMethod != null && readMethod.eIsProxy()) {
-			Method oldReadMethod = readMethod;
-			readMethod = (Method)eResolveProxy((InternalEObject)readMethod);
-			if (readMethod != oldReadMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD, oldReadMethod, readMethod));
-			}
-		}
-		return readMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReadMethod(Method newReadMethod) {
-		Method oldReadMethod = readMethod;
-		readMethod = newReadMethod;
-		boolean oldReadMethodESet = (eFlags & READ_METHOD_ESETFLAG) != 0;
-		eFlags |= READ_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD, oldReadMethod, readMethod, !oldReadMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetReadMethod() {
-		Method oldReadMethod = readMethod;
-		boolean oldReadMethodESet = (eFlags & READ_METHOD_ESETFLAG) != 0;
-		readMethod = null;
-		eFlags &= ~READ_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD, oldReadMethod, null, oldReadMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetReadMethod() {
-		return (eFlags & READ_METHOD_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method getWriteMethod() {
-		if (writeMethod != null && writeMethod.eIsProxy()) {
-			Method oldWriteMethod = writeMethod;
-			writeMethod = (Method)eResolveProxy((InternalEObject)writeMethod);
-			if (writeMethod != oldWriteMethod) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD, oldWriteMethod, writeMethod));
-			}
-		}
-		return writeMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setWriteMethod(Method newWriteMethod) {
-		Method oldWriteMethod = writeMethod;
-		writeMethod = newWriteMethod;
-		boolean oldWriteMethodESet = (eFlags & WRITE_METHOD_ESETFLAG) != 0;
-		eFlags |= WRITE_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD, oldWriteMethod, writeMethod, !oldWriteMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetWriteMethod() {
-		Method oldWriteMethod = writeMethod;
-		boolean oldWriteMethodESet = (eFlags & WRITE_METHOD_ESETFLAG) != 0;
-		writeMethod = null;
-		eFlags &= ~WRITE_METHOD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD, oldWriteMethod, null, oldWriteMethodESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetWriteMethod() {
-		return (eFlags & WRITE_METHOD_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Field getField() {
-		if (field != null && field.eIsProxy()) {
-			Field oldField = field;
-			field = (Field)eResolveProxy((InternalEObject)field);
-			if (field != oldField) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, BeaninfoPackage.PROPERTY_DECORATOR__FIELD, oldField, field));
-			}
-		}
-		return field;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Field basicGetField() {
-		return field;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setField(Field newField) {
-		Field oldField = field;
-		field = newField;
-		boolean oldFieldESet = (eFlags & FIELD_ESETFLAG) != 0;
-		eFlags |= FIELD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BeaninfoPackage.PROPERTY_DECORATOR__FIELD, oldField, field, !oldFieldESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetField() {
-		Field oldField = field;
-		boolean oldFieldESet = (eFlags & FIELD_ESETFLAG) != 0;
-		field = null;
-		eFlags &= ~FIELD_ESETFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, BeaninfoPackage.PROPERTY_DECORATOR__FIELD, oldField, null, oldFieldESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetField() {
-		return (eFlags & FIELD_ESETFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (bound: ");
-		if ((eFlags & BOUND_ESETFLAG) != 0) result.append((eFlags & BOUND_EFLAG) != 0); else result.append("<unset>");
-		result.append(", constrained: ");
-		if ((eFlags & CONSTRAINED_ESETFLAG) != 0) result.append((eFlags & CONSTRAINED_EFLAG) != 0); else result.append("<unset>");
-		result.append(", designTime: ");
-		if ((eFlags & DESIGN_TIME_ESETFLAG) != 0) result.append((eFlags & DESIGN_TIME_EFLAG) != 0); else result.append("<unset>");
-		result.append(", alwaysIncompatible: ");
-		result.append((eFlags & ALWAYS_INCOMPATIBLE_EFLAG) != 0);
-		result.append(", filterFlags: ");
-		result.append(filterFlags);
-		result.append(", fieldReadOnly: ");
-		result.append((eFlags & FIELD_READ_ONLY_EFLAG) != 0);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass basicGetPropertyEditorClass() {
-		return propertyEditorClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetReadMethod() {
-		return readMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Method basicGetWriteMethod() {
-		return writeMethod;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.PROPERTY_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case BeaninfoPackage.PROPERTY_DECORATOR__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.PROPERTY_DECORATOR__DETAILS:
-					return ((InternalEList)getDetails()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-					return eBasicSetContainer(null, BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT, msgs);
-				case BeaninfoPackage.PROPERTY_DECORATOR__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES:
-					return ((InternalEList)getAttributes()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-					return eContainer.eInverseRemove(this, EcorePackage.EMODEL_ELEMENT__EANNOTATIONS, EModelElement.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PROPERTY_DECORATOR__EANNOTATIONS:
-				return getEAnnotations();
-			case BeaninfoPackage.PROPERTY_DECORATOR__SOURCE:
-				return getSource();
-			case BeaninfoPackage.PROPERTY_DECORATOR__DETAILS:
-				return getDetails();
-			case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement();
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONTENTS:
-				return getContents();
-			case BeaninfoPackage.PROPERTY_DECORATOR__REFERENCES:
-				return getReferences();
-			case BeaninfoPackage.PROPERTY_DECORATOR__DISPLAY_NAME:
-				return getDisplayName();
-			case BeaninfoPackage.PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				return getShortDescription();
-			case BeaninfoPackage.PROPERTY_DECORATOR__CATEGORY:
-				return getCategory();
-			case BeaninfoPackage.PROPERTY_DECORATOR__EXPERT:
-				return isExpert() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__HIDDEN:
-				return isHidden() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PREFERRED:
-				return isPreferred() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				return isMergeIntrospection() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return isAttributesExplicitEmpty() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				return new Long(getImplicitlySetBits());
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return getImplicitDecoratorFlag();
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES:
-				return getAttributes();
-			case BeaninfoPackage.PROPERTY_DECORATOR__BOUND:
-				return isBound() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONSTRAINED:
-				return isConstrained() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DESIGN_TIME:
-				return isDesignTime() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				return isAlwaysIncompatible() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FILTER_FLAGS:
-				return getFilterFlags();
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				return isFieldReadOnly() ? Boolean.TRUE : Boolean.FALSE;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				if (resolve) return getPropertyEditorClass();
-				return basicGetPropertyEditorClass();
-			case BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD:
-				if (resolve) return getReadMethod();
-				return basicGetReadMethod();
-			case BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD:
-				if (resolve) return getWriteMethod();
-				return basicGetWriteMethod();
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD:
-				if (resolve) return getField();
-				return basicGetField();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PROPERTY_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__SOURCE:
-				setSource((String)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DETAILS:
-				getDetails().clear();
-				getDetails().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__REFERENCES:
-				getReferences().clear();
-				getReferences().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DISPLAY_NAME:
-				setDisplayName((String)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				setShortDescription((String)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CATEGORY:
-				setCategory((String)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__EXPERT:
-				setExpert(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__HIDDEN:
-				setHidden(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PREFERRED:
-				setPreferred(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(((Long)newValue).longValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag((ImplicitItem)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__BOUND:
-				setBound(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONSTRAINED:
-				setConstrained(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DESIGN_TIME:
-				setDesignTime(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				setAlwaysIncompatible(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FILTER_FLAGS:
-				getFilterFlags().clear();
-				getFilterFlags().addAll((Collection)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				setFieldReadOnly(((Boolean)newValue).booleanValue());
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				setPropertyEditorClass((JavaClass)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD:
-				setReadMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD:
-				setWriteMethod((Method)newValue);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD:
-				setField((Field)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PROPERTY_DECORATOR__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DETAILS:
-				getDetails().clear();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				setEModelElement((EModelElement)null);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONTENTS:
-				getContents().clear();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__REFERENCES:
-				getReferences().clear();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DISPLAY_NAME:
-				unsetDisplayName();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				unsetShortDescription();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CATEGORY:
-				setCategory(CATEGORY_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__EXPERT:
-				unsetExpert();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__HIDDEN:
-				unsetHidden();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PREFERRED:
-				unsetPreferred();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				setMergeIntrospection(MERGE_INTROSPECTION_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				setAttributesExplicitEmpty(ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				setImplicitlySetBits(IMPLICITLY_SET_BITS_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				setImplicitDecoratorFlag(IMPLICIT_DECORATOR_FLAG_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__BOUND:
-				unsetBound();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONSTRAINED:
-				unsetConstrained();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__DESIGN_TIME:
-				unsetDesignTime();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				setAlwaysIncompatible(ALWAYS_INCOMPATIBLE_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FILTER_FLAGS:
-				getFilterFlags().clear();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				setFieldReadOnly(FIELD_READ_ONLY_EDEFAULT);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				setPropertyEditorClass((JavaClass)null);
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD:
-				unsetReadMethod();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD:
-				unsetWriteMethod();
-				return;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD:
-				unsetField();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eIsSet(org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PROPERTY_DECORATOR__SOURCE:
-				return isSourceSet();	// Override so that if set to the same as classname, then it is considered not set.
-			default:
-				return eIsSetGen(eFeature);
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSetGen(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case BeaninfoPackage.PROPERTY_DECORATOR__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case BeaninfoPackage.PROPERTY_DECORATOR__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case BeaninfoPackage.PROPERTY_DECORATOR__DETAILS:
-				return details != null && !details.isEmpty();
-			case BeaninfoPackage.PROPERTY_DECORATOR__EMODEL_ELEMENT:
-				return getEModelElement() != null;
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONTENTS:
-				return contents != null && !contents.isEmpty();
-			case BeaninfoPackage.PROPERTY_DECORATOR__REFERENCES:
-				return references != null && !references.isEmpty();
-			case BeaninfoPackage.PROPERTY_DECORATOR__DISPLAY_NAME:
-				return isSetDisplayName();
-			case BeaninfoPackage.PROPERTY_DECORATOR__SHORT_DESCRIPTION:
-				return isSetShortDescription();
-			case BeaninfoPackage.PROPERTY_DECORATOR__CATEGORY:
-				return CATEGORY_EDEFAULT == null ? category != null : !CATEGORY_EDEFAULT.equals(category);
-			case BeaninfoPackage.PROPERTY_DECORATOR__EXPERT:
-				return isSetExpert();
-			case BeaninfoPackage.PROPERTY_DECORATOR__HIDDEN:
-				return isSetHidden();
-			case BeaninfoPackage.PROPERTY_DECORATOR__PREFERRED:
-				return isSetPreferred();
-			case BeaninfoPackage.PROPERTY_DECORATOR__MERGE_INTROSPECTION:
-				return ((eFlags & MERGE_INTROSPECTION_EFLAG) != 0) != MERGE_INTROSPECTION_EDEFAULT;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES_EXPLICIT_EMPTY:
-				return ((eFlags & ATTRIBUTES_EXPLICIT_EMPTY_EFLAG) != 0) != ATTRIBUTES_EXPLICIT_EMPTY_EDEFAULT;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICITLY_SET_BITS:
-				return implicitlySetBits != IMPLICITLY_SET_BITS_EDEFAULT;
-			case BeaninfoPackage.PROPERTY_DECORATOR__IMPLICIT_DECORATOR_FLAG:
-				return implicitDecoratorFlag != IMPLICIT_DECORATOR_FLAG_EDEFAULT;
-			case BeaninfoPackage.PROPERTY_DECORATOR__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case BeaninfoPackage.PROPERTY_DECORATOR__BOUND:
-				return isSetBound();
-			case BeaninfoPackage.PROPERTY_DECORATOR__CONSTRAINED:
-				return isSetConstrained();
-			case BeaninfoPackage.PROPERTY_DECORATOR__DESIGN_TIME:
-				return isSetDesignTime();
-			case BeaninfoPackage.PROPERTY_DECORATOR__ALWAYS_INCOMPATIBLE:
-				return ((eFlags & ALWAYS_INCOMPATIBLE_EFLAG) != 0) != ALWAYS_INCOMPATIBLE_EDEFAULT;
-			case BeaninfoPackage.PROPERTY_DECORATOR__FILTER_FLAGS:
-				return filterFlags != null && !filterFlags.isEmpty();
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD_READ_ONLY:
-				return ((eFlags & FIELD_READ_ONLY_EFLAG) != 0) != FIELD_READ_ONLY_EDEFAULT;
-			case BeaninfoPackage.PROPERTY_DECORATOR__PROPERTY_EDITOR_CLASS:
-				return propertyEditorClass != null;
-			case BeaninfoPackage.PROPERTY_DECORATOR__READ_METHOD:
-				return isSetReadMethod();
-			case BeaninfoPackage.PROPERTY_DECORATOR__WRITE_METHOD:
-				return isSetWriteMethod();
-			case BeaninfoPackage.PROPERTY_DECORATOR__FIELD:
-				return isSetField();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isWriteable()
-	 */
-	public boolean isWriteable() {
-		return getWriteMethod() != null || (getField() != null && !isFieldReadOnly()); 
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.beaninfo.PropertyDecorator#isReadable()
-	 */
-	public boolean isReadable() {
-		return getReadMethod() != null || getField() != null;
-	}
-	
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/beaninfo/common/IBaseBeanInfoConstants.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/beaninfo/common/IBaseBeanInfoConstants.java
deleted file mode 100644
index 2af047e..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/beaninfo/common/IBaseBeanInfoConstants.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IBaseBeanInfoConstants.java,v $
- *  $Revision: 1.1 $  $Date: 2005/10/18 15:32:19 $ 
- */
-package org.eclipse.jem.beaninfo.common;
-
- 
-
-/**
- * Constants for the BaseBeanInfo for arguments. This class is common between
- * the IDE and the remote vm so that these constants can be used on both sides.
- * <p>
- * These are constants used in FeatureAttributes as keys. The other special
- * constants that are not keys in FeatureAttributes are left in BaseBeanInfo
- * since they are not needed on both sides.
- * 
- * @since 1.2.0
- */
-public interface IBaseBeanInfoConstants {
-
-	/**
-	 * Indicator used to describe a factory instantiation pattern.  Not API as will change to become more extensible 
-	 * via .override mechanism in future
-	 * 
-	 * @since 1.1
-	 */	
-	public static final String FACTORY_CREATION = "FACTORY_CREATION";//$NON-NLS-1$
-	
-	/**
-	 * Category indicator for apply property arguments. Category is a pre-defined attribute name too. That is where the category is stored in a
-	 * descriptor.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String CATEGORY = "category"; //$NON-NLS-1$
-	
-	/**
-	 * Enumeration values indicator for apply property arguments. Enumeration values is a pre-defined attribute name too. That is where the
-	 * enumeration values are stored.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String ENUMERATIONVALUES = "enumerationValues";//$NON-NLS-1$
-	
-	// The keys for icon file names, NOT THE java.awt.icon key.
-	public static final String ICONCOLOR16X16URL = "ICON_COLOR_16x16_URL"; //$NON-NLS-1$	
-	public static final String ICONCOLOR32X32URL = "ICON_COLOR_32x32_URL"; //$NON-NLS-1$     	// Not used
-	public static final String ICONMONO16X16URL = "ICON_MONO_16x16_URL"; //$NON-NLS-1$        	// Not used
-	public static final String ICONMONO32X32URL = "ICON_MONO_32x32_URL"; //$NON-NLS-1$			// Not used
-
-
-	/**
-	 * FeatureAttribute key for explicit property changes. The value is a Boolean. <code>true</code>
-	 * indicates that the Customize Bean customizer supplied by the BeanInfo will indicate which
-	 * properties it has changed through firing {@link java.beans.PropertyChangeEvent} instead of the 
-	 * Visual Editor automatically trying to determine the set of changed properties.
-	 * <p>
-	 * The default if not set is <code>false</code>.
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public static final String EXPLICIT_PROPERTY_CHANGE = "EXPLICIT_PROPERTY_CHANGE"; //$NON-NLS-1$
-
-	/**
-	 * Used by Visual Editor as feature attribute key/value to indicate that it must create an implicit setting of a property(s).
-	 * For example {@link javax.swing.JFrame#getContentPane()}. There must be a content pane
-	 * set in the VE model so that users can drop the components on it. Setting this here
-	 * means that the default content pane from the JFrame will show up in the editor to use.
-	 * <p>
-	 * This should be used with care in that not all properties are required to always show up.
-	 * They can be queried when needed.
-	 * <p>
-	 * The value can be either a {@link String} for one property. Or it can be a {@link String[]} for more
-	 * than one property.
-	 * 
-	 * @since 1.2.0
-	 */
-	public static final String REQUIRED_IMPLICIT_PROPERTIES = "requiredImplicitProperties";	//$NON-NLS-1$
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/BeanRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/BeanRecord.java
deleted file mode 100644
index d2eb5c2..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/BeanRecord.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeanRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * This is the data structure for sending the BeanDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the BeanDescriptor. 
- * @since 1.1.0
- */
-public class BeanRecord extends FeatureRecord {
-
-	private static final long serialVersionUID = 1105979920664L;
-	
-	public String customizerClassName;
-	public boolean mergeInheritedProperties;
-	public boolean mergeInheritedOperations;
-	public boolean mergeInheritedEvents;
-	/**
-	 * Names of properties that are to not be inherited in getAllProperties(). It is set only
-	 * if the list is not the full list of inherited properties.
-	 * If all inherited or mergeInheritedProperties is false, then the field will be <code>null</code>. Save space that way.
-	 */
-	public String[] notInheritedPropertyNames;
-	/**
-	 * Names of operations that are to not be inherited in getEAllOperations(). It is set only
-	 * if the list is not the full list of inherited operations. 
-	 * If all are inherited or if mergeInheritedOperations is false, then the field will be <code>null</code>. Save space that way.
-	 */
-	public String[] notInheritedOperationNames;
-	/**
-	 * Names of events that are to not be inherited in getAllEvents(). It is set only
-	 * if the list is not the full list of inherited events.
-	 * If all are inherited or if mergeInheritedEvents is false, then the field will be <code>null</code>. Save space that way.
-	 */
-	public String[] notInheritedEventNames;
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/EventSetRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/EventSetRecord.java
deleted file mode 100644
index e0f47e7..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/EventSetRecord.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: EventSetRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * This is the data structure for sending the EventSetDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the EventSetDescriptor. 
- * @since 1.1.0
- */
-public class EventSetRecord extends FeatureRecord {
-	
-	private static final long serialVersionUID = 1105980773420L;
-	
-	public ReflectMethodRecord addListenerMethod;
-	public String eventAdapterClassName;
-	public MethodRecord[] listenerMethodDescriptors;
-	public String listenerTypeName;
-	public ReflectMethodRecord removeListenerMethod;
-	public boolean inDefaultEventSet;
-	public boolean unicast;
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/FeatureAttributeValue.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/FeatureAttributeValue.java
deleted file mode 100644
index 3a0e30c..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/FeatureAttributeValue.java
+++ /dev/null
@@ -1,750 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: FeatureAttributeValue.java,v $
- *  $Revision: 1.8 $  $Date: 2005/06/30 13:47:26 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
-
-import java.io.*;
-import java.lang.reflect.*;
-import java.util.Arrays;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
-
-import org.eclipse.jem.internal.proxy.common.MapTypes;
-
- 
-
-/**
- * This is the value for a FeatureAttribute. It wrappers the true java object.
- * Use the getObject method to get the java value.
- * <p>
- * We can only represent Strings, primitives, and arrays. (Primitives will converted
- * to their wrapper class (e.g. Long), and byte, short, and int will move up to Long,
- * and float will move up to Double).  And any kind of valid array on the java BeanInfo side
- * will be converted to an Object array on the IDE side. We don't have the capability to allow more complex objects 
- * because the IDE may not have the necessary classes available to it that 
- * the BeanInfo may of had available to it. Invalid objects will be represented
- * by the singleton instance of {@link org.eclipse.jem.internal.beaninfo.common.InvalidObject}.
- * <p>
- * <b>Note:</b>
- * Class objects that are values of Feature attributes on the java BeanInfo side will be
- * converted to simple strings containing the classname when moved to the client (IDE) side.
- * That is because the classes probably will not be available on the IDE side, but can be
- * used to reconstruct the class when used back on the java vm side. 
- * @since 1.1.0
- */
-public class FeatureAttributeValue implements Serializable {
-	
-	private transient Object value;
-	private transient Object internalValue;
-	private static final long serialVersionUID = 1105717634844L;
-	
-	/**
-	 * Create the value with the given init string.
-	 * <p>
-	 * This is not meant to be used by clients.
-	 * @param initString
-	 * 
-	 * @since 1.1.0
-	 */
-	public FeatureAttributeValue(String initString) {
-		// Use the init string to create the value. This is our
-		// own short-hand for this.
-		value = parseString(initString);
-	}
-	
-	/**
-	 * This is used when customer wants to fluff one up.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	public FeatureAttributeValue() {
-		
-	}
-
-	/**
-	 * @return Returns the value.
-	 * 
-	 * @since 1.1.0
-	 */
-	public Object getValue() {
-		return value;
-	}
-	
-	/**
-	 * Set a value.
-	 * @param value The value to set.
-	 * @since 1.1.0
-	 */
-	public void setValue(Object value) {
-		this.value = value;
-		this.setInternalValue(null);
-	}
-		
-	/**
-	 * Set the internal value.
-	 * @param internalValue The internalValue to set.
-	 * 
-	 * @since 1.1.0
-	 */
-	public void setInternalValue(Object internalValue) {
-		this.internalValue = internalValue;
-	}
-
-	/**
-	 * This is the internal value. It is the <code>value</code> massaged into an easier to use form
-	 * in the IDE. It will not be serialized out. It will not be reconstructed from an init string.
-	 * <p> 
-	 * It does not need to be used. It will be cleared if
-	 * a new value is set. For example, if the value is a complicated array (because you can't have
-	 * special classes in the attribute value on the BeanInfo side) the first usage of this value can
-	 * be translated into an easier form to use, such as a map.
-	 * 
-	 * @return Returns the internalValue.
-	 * 
-	 * @since 1.1.0
-	 */
-	public Object getInternalValue() {
-		return internalValue;
-	}
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		if (value == null)
-			return super.toString();
-		return makeString(value);
-	}
-	
-
-	/**
-	 * Helper method to take the object and turn it into the
-	 * string form that is required for EMF serialization.
-	 * <p>
-	 * This is used internally. It can be used for development 
-	 * purposes by clients, but they would not have any real
-	 * runtime need for this.
-	 * <p>
-	 * Output format would be (there won't be any newlines in the actual string)
-	 * <pre>
-	 *   String: "zxvzxv"
-	 *   Number: number
-	 *   Boolean: true or false
-	 *   Character: 'c'
-	 *   null: null
-	 * 
-	 *   Array: (all arrays will be turned into Object[])
-	 *     [dim]{e1, e2}
-	 *     [dim1][dim2]{[dim1a]{e1, e2}, [dim2a]{e3, e4}}
-	 *   where en are objects that follow the pattern for single output above.
-	 * 
-	 *   Any invalid object (i.e. not one of the ones we handle) will be:
-	 *     INV
-	 * 
-	 *   Arrays of invalid types (not Object, String, Number, Boolean, Character,
-	 *     or primitives) will be marked as INV.
-	 * </pre>
-	 * @param value
-	 * @return serialized form as a string.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String makeString(Object value) {
-		StringBuffer out = new StringBuffer(100);
-		makeString(value, out);
-		return out.toString();
-	}
-	
-	private static final Pattern QUOTE = Pattern.compile("\"");	// Pattern for searching for double-quote. Make it static so don't waste time compiling each time. //$NON-NLS-1$
-	private static final String NULL = "null";	// Output string for null //$NON-NLS-1$
-	private static final String INVALID = "INV";	// Invalid object flag. //$NON-NLS-1$
-	
-	/*
-	 * Used for recursive building of the string.
-	 */
-	private static void makeString(Object value, StringBuffer out) {
-		if (value == null)
-			out.append(NULL);
-		else if (value instanceof String || value instanceof Class) {
-			// String: "string" or "string\"stringend" if str included a double-quote.
-			out.append('"');
-			// If class, turn value into the classname.
-			String str = value instanceof String ? (String) value : ((Class) value).getName();
-			if (str.indexOf('"') != -1) {
-				// Replace double-quote with escape double-quote so we can distinquish it from the terminating double-quote.
-				out.append(QUOTE.matcher(str).replaceAll("\\\\\""));	// Don't know why we need the back-slash to be doubled for replaceall, but it doesn't work otherwise. //$NON-NLS-1$
-			} else
-				out.append(str);
-			out.append('\"');
-		} else if (value instanceof Number) {
-			// Will go out as either a integer number or a floating point number. 
-			// When read back in it will be either a Long or a Double.
-			out.append(value);
-		} else if (value instanceof Boolean) {
-			// It will go out as either true or false.
-			out.append(value);
-		} else if (value instanceof Character) {
-			// Character: 'c' or '\'' if char was a quote.
-			out.append('\'');
-			Character c = (Character) value;
-			if (c.charValue() != '\'')
-				out.append(c.charValue());
-			else
-				out.append("\\'"); //$NON-NLS-1$
-			out.append('\'');
-		} else if (value.getClass().isArray()) {
-			// Handle array format.
-			Class type = value.getClass();
-			// See if final type is a valid type.
-			Class ft = type.getComponentType();
-			int dims = 1;
-			while (ft.isArray()) {
-				dims++;
-				ft = ft.getComponentType();
-			}
-			if (ft == Object.class || ft == String.class || ft == Boolean.class || ft == Character.class || ft.isPrimitive() || Number.class.isAssignableFrom(ft)) {
-				// [length][][] {....}
-				out.append('[');
-				int length = Array.getLength(value); 
-				out.append(length);
-				out.append(']');
-				while(--dims > 0) {
-					out.append("[]"); //$NON-NLS-1$
-				}
-				out.append('{');
-				for (int i=0; i < length; i++) {
-					if (i != 0)
-						out.append(',');
-					makeString(Array.get(value, i), out);
-				}
-				out.append('}');
-			} else
-				out.append(INVALID);	// Any other kind of array is invalid.
-		} else {
-			out.append(INVALID);
-		}
-	}
-	
-	
-	/**
-	 * Helper method to take the string input from EMF serialization and turn it
-	 * into an Object.
-	 * <p>
-	 * This is used internally. It can be used for development 
-	 * purposes by clients, but they would not have any real
-	 * runtime need for this.
-	 * <p>
-	 * The object will be an object, null, or an Object array. Any value
-	 * that is invalid will be set to the {@link InvalidObject#INSTANCE} static
-	 * instance.
-	 * 
-	 * @param input
-	 * @return object decoded from the input.
-	 * 
-	 * @see #makeString(Object)
-	 * @since 1.1.0
-	 */
-	public static Object parseString(String input) {
-		return parseString(new StringParser(input));
-	}
-	
-	private static class StringParser {
-		private int next=0;
-		private int length;
-		private String input;
-		
-		public StringParser(String input) {
-			this.input = input;
-			this.length = input.length();
-		}
-		
-		public String toString() {
-			return "StringParser: \""+input+'"';
-		}
-		
-		public void skipWhitespace() {
-			while(next < length) {
-				if (!Character.isWhitespace(input.charAt(next++))) {
-					next--;	// Put it back as not yet read since it is not whitespace.
-					break;
-				}
-			}
-		}
-		
-		/**
-		 * Return the next index
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public int nextIndex() {
-			return next;
-		}
-		
-		/**
-		 * Get the length of the input
-		 * @return input length
-		 * 
-		 * @since 1.1.0
-		 */
-		public int getLength() {
-			return length;
-		}
-		
-		
-		/**
-		 * Read the current character and go to next.
-		 * @return current character
-		 * 
-		 * @since 1.1.0
-		 */
-		public char read() {
-			return next<length ? input.charAt(next++) : 0;
-		}
-		
-		/**
-		 * Backup the parser one character.
-		 * 
-		 * 
-		 * @since 1.1.0
-		 */
-		public void backup() {
-			if (--next < 0)
-				next = 0;
-		}
-		
-		/**
-		 * Peek at the char at the next index, but don't increment afterwards.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public char peek() {
-			return next<length ? input.charAt(next) : 0;
-		}
-		
-		/**
-		 * Have we read the last char.
-		 * @return <code>true</code> if read last char.
-		 * 
-		 * @since 1.1.0
-		 */
-		public boolean atEnd() {
-			return next>=length;
-		}
-		
-		/**
-		 * Reset to the given next index.
-		 * @param nextIndex the next index to do a read at.
-		 * 
-		 * @since 1.1.0
-		 */
-		public void reset(int nextIndex) {
-			if (nextIndex<=length)
-				next = nextIndex;
-			else
-				next = length;
-		}
-		
-		/**
-		 * Skip the next number of chars.
-		 * @param skip number of chars to skip.
-		 * 
-		 * @since 1.1.0
-		 */
-		public void skip(int skip) {
-			if ((next+=skip) > length)
-				next = length;
-		}
-		
-		/**
-		 * Return the string input.
-		 * @return the string input
-		 * 
-		 * @since 1.1.0
-		 */
-		public String getInput() {
-			return input;
-		}
-				
-	}
-	
-	/*
-	 * Starting a parse for an object at the given index.
-	 * Return the parsed object or InvalidObject if no
-	 * object or if there was an error parsing.
-	 */
-	private static Object parseString(StringParser parser) {
-		parser.skipWhitespace();
-		if (!parser.atEnd()) {
-			char c = parser.read();
-			switch (c) {
-				case '"':
-					// Start of a quoted string. Scan for closing quote, ignoring escaped quotes.
-					int start = parser.nextIndex();	// Index of first char after '"'
-					char[] dequoted = null;	// Used if there is an escaped quote. That is the only thing we support escape on, quotes.
-					int dequoteIndex = 0;
-					while (!parser.atEnd()) {
-						char cc = parser.read();
-						if (cc == '"') {
-							// If we didn't dequote, then just do substring.
-							if (dequoted == null)
-								return parser.getInput().substring(start, parser.nextIndex()-1);	// next is char after '"', so end of string index is index of '"'
-							else {
-								// We have a dequoted string. So turn into a string.
-								// Gather the last group
-								int endNdx = parser.nextIndex()-1;
-								parser.getInput().getChars(start, endNdx, dequoted, dequoteIndex);
-								dequoteIndex+= (endNdx-start);
-								return new String(dequoted, 0, dequoteIndex);
-							}
-						} else if (cc == '\\') {
-							// We had an escape, see if next is a quote. If it is we need to strip out the '\'.
-							if (parser.peek() == '"') {
-								if (dequoted == null) {
-									dequoted = new char[parser.getLength()];
-								}
-								int endNdx = parser.nextIndex()-1;
-								parser.getInput().getChars(start, endNdx, dequoted, dequoteIndex);	// Get up to, but not including '\'
-								dequoteIndex+= (endNdx-start);
-								// Now also add in the escaped quote.
-								dequoted[dequoteIndex++] = parser.read();
-								start = parser.nextIndex();	// Next group is from next index.
-							}
-						}
-					}
-					break;	// If we got here, it is invalid.
-					
-				case '-':
-				case '0':
-				case '1':
-				case '2':
-				case '3':
-				case '4':
-				case '5':
-				case '6':
-				case '7':
-				case '8':
-				case '9':
-					// Possible number.
-					// Scan to next non-digit, or not part of valid number.
-					boolean numberComplete = false;
-					boolean floatType = false;
-					boolean foundE = false;
-					boolean foundESign = false;
-					start = parser.nextIndex()-1;	// We want to include the sign or first digit in the number.
-					while (!parser.atEnd() && !numberComplete) {
-						char cc = parser.read();
-						switch (cc) {
-							case '0':
-							case '1':
-							case '2':
-							case '3':
-							case '4':
-							case '5':
-							case '6':
-							case '7':
-							case '8':
-							case '9':
-								break;	// This is good, go on.
-							case '.':
-								if (floatType)
-									return InvalidObject.INSTANCE;	// We already found a '.', two are invalid.
-								floatType = true;
-								break;
-							case 'e':
-							case 'E':
-								if (foundE)
-									return InvalidObject.INSTANCE;	// We already found a 'e', two are invalid.
-								foundE = true;
-								floatType = true;	// An 'e' makes it a float, if not already.
-								break;
-							case '+':
-							case '-':
-								if (!foundE || foundESign) 
-									return InvalidObject.INSTANCE;	// A +/- with no 'e' first is invalid. Or more than one sign.
-								foundESign = true;
-								break;
-							default:
-								// Anything else is end of number.
-								parser.backup();	// Back it up so that next parse will start with this char.
-								numberComplete = true;	// So we stop scanning
-								break;
-						}
-					}
-					try {
-						if (!floatType)
-							return Long.valueOf(parser.getInput().substring(start, parser.nextIndex()));
-						else
-							return Double.valueOf(parser.getInput().substring(start, parser.nextIndex()));
-					} catch (NumberFormatException e) {
-					}
-					break; // If we got here, it is invalid.
-					
-				case 't':
-				case 'T':
-				case 'f':
-				case 'F':
-					// Possible boolean.
-					if (parser.getInput().regionMatches(true, parser.nextIndex()-1, "true", 0, 4)) { //$NON-NLS-1$
-						parser.skip(3);	// Skip over rest of string.
-						return Boolean.TRUE;
-					} else if (parser.getInput().regionMatches(true, parser.nextIndex()-1, "false", 0, 5)) { //$NON-NLS-1$
-						parser.skip(4);	// Skip over rest of string.
-						return Boolean.FALSE;						
-					}
-					break; // If we got here, it is invalid.
-					
-				case '\'':
-					// Possible character
-					char cc = parser.read();
-					// We really only support '\\' and '\'' anything else will be treated as ignore '\' because we don't know handle full escapes.
-					if (cc == '\\')
-						cc = parser.read();	// Get what's after it.
-					else if (cc == '\'')
-						break;	// '' is invalid.
-					if (parser.peek() == '\'') {
-						// So next char after "character" is is a quote. This is good.
-						parser.read();	// Now consume the quote
-						return new Character(cc);
-					}
-					break; // If we got here, it is invalid.
-					
-				case 'n':
-					// Possible null.
-					if (parser.getInput().regionMatches(parser.nextIndex()-1, "null", 0, 4)) { //$NON-NLS-1$
-						parser.skip(3);	// Skip over rest of string.
-						return null;
-					}
-					break; // If we got here, it is invalid.
-					
-				case 'I':
-					// Possible invalid value.
-					if (parser.getInput().regionMatches(parser.nextIndex()-1, INVALID, 0, INVALID.length())) {
-						parser.skip(INVALID.length()-1);	// Skip over rest of string.
-						return InvalidObject.INSTANCE;
-					}
-					break; // If we got here, it is invalid.
-					
-				case '[':
-					// Possible array.
-					// The next field should be a number, so we'll use parseString to get the number. 
-					Object size = parseString(parser);
-					if (size instanceof Long) {
-						parser.skipWhitespace();
-						cc = parser.read();	// Se if next is ']'
-						if (cc == ']') {
-							// Good, well-formed first dimension
-							int dim = 1;
-							boolean valid = true;
-							// See if there are more of just "[]". the number of them is the dim.
-							while (true) {
-								parser.skipWhitespace();
-								cc = parser.read();
-								if (cc == '[') {
-									parser.skipWhitespace();
-									cc = parser.read();
-									if (cc == ']')
-										dim++;
-									else {
-										// This is invalid.
-										valid = false;
-										parser.backup();
-										break;	// No more dims.
-									}
-								} else {
-									parser.backup();
-									break;	// No more dims.
-								}
-							}
-							if (valid) {
-								parser.skipWhitespace();
-								cc = parser.read();
-								if (cc == '{') {
-									// Good, we're at the start of the initialization code.
-									int[] dims = new int[dim];
-									int len = ((Long) size).intValue();
-									dims[0] = len;
-									Object array = Array.newInstance(Object.class, dims);
-									Arrays.fill((Object[]) array, null);	// Because newInstance used above fills the array created with empty arrays when a dim>1.
-									
-									// Now we start filling it in.
-									Object invSetting = null;	// What we will use for the invalid setting. If this is a multidim, this needs to be an array. Will not create it until needed.
-									Object entry = parseString(parser);	// Get the first entry
-									Class compType = array.getClass().getComponentType();
-									int i = -1;
-									while (true) {
-										if (++i < len) {
-											if (compType.isInstance(entry)) {
-												// Good, it can be assigned.
-												Array.set(array, i, entry);
-											} else {
-												// Bad. Need to set invalid.
-												if (invSetting == null) {
-													// We haven't created it yet.
-													if (dim == 1)
-														invSetting = InvalidObject.INSTANCE; // Great, one dimensional, we can use invalid directly
-													else {
-														// Multi-dim. Need to create a valid array that we can set.
-														int[] invDims = new int[dim - 1];
-														Arrays.fill(invDims, 1); // Length one all of the way so that the final component can be invalid object
-														invSetting = Array.newInstance(Object.class, invDims);
-														Object finalEntry = invSetting; // Final array (with component type of just Object). Start with the full array and work down.
-														for (int j = invDims.length - 1; j > 0; j--) {
-															finalEntry = Array.get(finalEntry, 0);
-														}
-														Array.set(finalEntry, 0, InvalidObject.INSTANCE);
-													}
-												}
-												Array.set(array, i, invSetting);
-											}
-										}
-										
-										parser.skipWhitespace();
-										cc = parser.read();
-										if (cc == ',') {
-											// Good, get next
-											entry = parseString(parser);
-										} else if (cc == '}') {
-											// Good, reached the end.
-											break;
-										} else {
-											if (!parser.atEnd()) {
-												parser.backup();
-												entry = parseString(parser); // Technically this should be invalid, but we'll let a whitespace also denote next entry.
-											} else {
-												// It's really screwed up. The string just ended. Log it.
-												Exception e = new IllegalStateException(parser.toString());
-												try {
-													// See if Beaninfo plugin is available (we are running under eclipse). If so, use it, else just print to error.
-													// We may be in the remote vm and so it won't be available.
-													Class biPluginClass = Class.forName("org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin");
-													Method getPlugin = biPluginClass.getMethod("getPlugin", null);
-													Method getLogger = biPluginClass.getMethod("getLogger", null);
-													Method log = getLogger.getReturnType().getMethod("log", new Class[] {Throwable.class, Level.class});
-													Object biPlugin = getPlugin.invoke(null, null);
-													Object logger = getLogger.invoke(biPlugin, null);
-													log.invoke(logger, new Object[] {e, Level.WARNING});
-													return InvalidObject.INSTANCE;
-												} catch (SecurityException e1) {
-												} catch (IllegalArgumentException e1) {
-												} catch (ClassNotFoundException e1) {
-												} catch (NoSuchMethodException e1) {
-												} catch (IllegalAccessException e1) {
-												} catch (InvocationTargetException e1) {
-												} catch (NullPointerException e1) {
-												}
-												e.printStackTrace();	// Not in eclipse, so just print stack trace.
-												return InvalidObject.INSTANCE;
-											}
-										}
-									}
-									
-									return array;
-								}
-							}							
-						}
-					}
-					break; // If we got here, it is invalid.
-			}
-		}
-		return InvalidObject.INSTANCE;
-	}
-	
-	private void writeObject(ObjectOutputStream out) throws IOException {
-		// Write out any hidden stuff
-		out.defaultWriteObject();
-		writeObject(value, out);
-	}
-	
-	private void writeObject(Object value, ObjectOutputStream out) throws IOException {
-		if (value == null)
-			out.writeObject(value);
-		else {
-			if (value instanceof Class)
-				out.writeObject(((Class) value).getName());
-			else if (!value.getClass().isArray()) {
-				if (value instanceof String || value instanceof Number || value instanceof Boolean || value instanceof Character)
-					out.writeObject(value);
-				else
-					out.writeObject(InvalidObject.INSTANCE);
-			} else {
-				// Array is tricky. See if it is one we can handle, if not then invalid. 
-				// To indicate array, we will first write out the Class of the Component type of the array (it will
-				// be converted to be Object or Object[]...).
-				// This will be the clue that an array is coming. Class values will never
-				// be returned, so that is how we can tell it is an array.
-				// Note: The reason we are using the component type (converted to Object) is because to reconstruct on the other side we need
-				// to use the component type plus length of the array's first dimension.
-				// 
-				// We can not just serialize the array in the normal way because it may contain invalid values, and we need to 
-				// handle that. Also, if it wasn't an Object array, we need to turn it into an object array. We need consistency
-				// in that it should always be an Object array.
-				// So output format will be:
-				// Class(component type)
-				// int(size of first dimension)
-				// Object(value of first entry) - Actually use out writeObject() format to allow nesting of arrays.
-				// Object(value of second entry)
-				// ... up to size of dimension.
-				Class type = value.getClass();
-				// See if final type is a valid type.
-				Class ft = type.getComponentType();
-				int dims = 1;
-				while (ft.isArray()) {
-					dims++;
-					ft = ft.getComponentType();
-				}
-				if (ft == Object.class || ft == String.class || ft == Boolean.class || ft == Character.class || ft.isPrimitive() || ft == Class.class || Number.class.isAssignableFrom(ft)) {
-					String jniType = dims == 1 ? "java.lang.Object" : MapTypes.getJNITypeName("java.lang.Object", dims-1); //$NON-NLS-1$ //$NON-NLS-2$
-					try {
-						Class componentType = Class.forName(jniType);
-						out.writeObject(componentType);
-						int length = Array.getLength(value);
-						out.writeInt(length);
-						for (int i = 0; i < length; i++) {
-							writeObject(Array.get(value, i), out);
-						}
-					} catch (ClassNotFoundException e) {
-						// This should never happen. Object arrays are always available.
-					}
-				} else
-					out.writeObject(InvalidObject.INSTANCE);
-			}
-		}
-	}
-	
-	
-	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
-		// Read in any hidden stuff
-		in.defaultReadObject();
-		
-		value = readActualObject(in);
-	}
-	
-	private Object readActualObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
-		Object val = in.readObject();
-		if (val instanceof Class) {
-			// It must be an array. Only Class objects that come in are Arrays of Object.
-			int length = in.readInt();
-			Object array = Array.newInstance((Class) val, length);
-			for (int i = 0; i < length; i++) {
-				Array.set(array, i, readActualObject(in));
-			}
-			return array;
-		} else
-			return val;	// It is the value itself.
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/FeatureRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/FeatureRecord.java
deleted file mode 100644
index f973f29..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/FeatureRecord.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: FeatureRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
-
-import java.io.Serializable;
- 
-
-/**
- * This is the data structure for sending the FeatureDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the FeatureDescriptor. 
- * @since 1.1.0
- */
-public class FeatureRecord implements Serializable {
-
-	private static final long serialVersionUID = 1105979276648L;
-	
-	public String name;	// Some decorators use this and others don't. Each decorator type will decide whether this is of importance.
-	public String displayName;
-	public String shortDescription;
-	public String category;
-	public boolean expert;
-	public boolean hidden;
-	public boolean preferred;
-	public String[] attributeNames;
-	public FeatureAttributeValue[] attributeValues;
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/IBeanInfoIntrospectionConstants.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/IBeanInfoIntrospectionConstants.java
deleted file mode 100644
index 209873e..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/IBeanInfoIntrospectionConstants.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IBeanInfoIntrospectionConstants.java,v $
- *  $Revision: 1.3 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * These are constants needed for transferring BeanInfo results from the BeanInfo VM.
- * @since 1.1.0
- */
-public interface IBeanInfoIntrospectionConstants {
-	
-	/**
-	 * Introspection bit flag indicating do the BeanDecorator. Sent to ModelingBeanInfo.introspect method.
-	 * @since 1.1.0
-	 */
-	public static final int DO_BEAN_DECOR = 0x1;
-	
-	/**
-	 * Introspection bit flag indicating do the Properties. Sent to ModelingBeanInfo.introspect method.
-	 * @since 1.1.0
-	 */
-	public static final int DO_PROPERTIES = 0x2;
-
-	/**
-	 * Introspection bit flag indicating do the Methods. Sent to ModelingBeanInfo.introspect method.
-	 * @since 1.1.0
-	 */
-	public static final int DO_METHODS = 0x4;
-
-	/**
-	 * Introspection bit flag indicating do the Events. Sent to ModelingBeanInfo.introspect method.
-	 * @since 1.1.0
-	 */
-	public static final int DO_EVENTS = 0x8;
-
-	/**
-	 * BeanDecorator was sent command id. 
-	 * <p>
-	 * This will be sent to callBack(int id, InputStream is). The InputStream will be Objects (use ObjectInputStream). 
-	 * The stream will be broken into sections.
-	 * Each section will be headed by the command id of that section (e.g. BEAN_DECORATOR_SENT or PROPERTY_DECORATORS_SENT).
-	 * Following the command id will be the type of input specific data. 
-	 * <p>
-	 * The data following the command id will be a BeanRecord from the ObjectInputStream.
-	 * 
-	 * @see BeanRecord
-	 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, InputStream)
-	 * @since 1.1.0
-	 */
-	public static final int BEAN_DECORATOR_SENT = 1;
-
-	/**
-	 * PropertyDecorators send command id.
-	 * <p>
-	 * This will be sent to callBack(int id, InputStream is). The InputStream will be Objects (use ObjectInputStream). 
-	 * The stream will be broken into sections.
-	 * Each section will be headed by the command id of that section (e.g. BEAN_DECORATOR_SENT or PROPERTY_DECORATORS_SENT).
-	 * Following the command id will be the type of input specific data. 
-	 * <p>
-	 * The first object will be  an int and will be the number of properties and each object after that
-	 * will be a PropertyRecord/IndexedPropertyRecord. 
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, InputStream)
-	 * @see PropertyRecord
-	 * @see IndexedPropertyRecord
-	 */
-	public static final int PROPERTY_DECORATORS_SENT = 2;
-
-	/**
-	 * MethodDecorators send command id.
-	 * <p>
-	 * This will be sent to callBack(int id, InputStream is). The InputStream will be Objects (use ObjectInputStream). 
-	 * The stream will be broken into sections.
-	 * Each section will be headed by the command id of that section (e.g. BEAN_DECORATOR_SENT or PROPERTY_DECORATORS_SENT).
-	 * Following the command id will be the type of input specific data. 
-	 * <p>
-	 * The InputStream will be Objects (use ObjectInputStream).
-	 * The first object will be  an int and will be the number of methods and each object after that
-	 * will be a MethodRecord. 
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, InputStream)
-	 * @see MethodRecord
-	 */
-	public static final int METHOD_DECORATORS_SENT = 3;
-	
-	/**
-	 * EventSetDecorators send command id.
-	 * <p>
-	 * This will be sent to callBack(int id, InputStream is). The InputStream will be Objects (use ObjectInputStream). 
-	 * The stream will be broken into sections.
-	 * Each section will be headed by the command id of that section (e.g. BEAN_DECORATOR_SENT or PROPERTY_DECORATORS_SENT).
-	 * Following the command id will be the type of input specific data. 
-	 * <p>
-	 * The first object will be  an int and will be the number of events and each object after that
-	 * will be a EventSetRecord. 
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, InputStream)
-	 * @see MethodRecord
-	 */
-	public static final int EVENT_DECORATORS_SENT = 4;
-
-	/**
-	 * Done send command id.
-	 * <p>
-	 * This will be sent to callBack(int id, InputStream is). The InputStream will be Objects (use ObjectInputStream). 
-	 * The stream will be broken into sections.
-	 * Each section will be headed by the command id of that section (e.g. BEAN_DECORATOR_SENT or PROPERTY_DECORATORS_SENT).
-	 * Following the command id will be the type of input specific data. 
-	 * <p>
-	 * This command id means there is no more data and it should return.
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, InputStream)
-	 * @see MethodRecord
-	 */
-	public static final int DONE = 5;
-	
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/IndexedPropertyRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/IndexedPropertyRecord.java
deleted file mode 100644
index 5da6399..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/IndexedPropertyRecord.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IndexedPropertyRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * This is the data structure for sending the IndexedPropertyDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the IndexedPropertyDescriptor. 
- * @since 1.1.0
- */
-public class IndexedPropertyRecord extends PropertyRecord {
-	private static final long serialVersionUID = 1105983227990L;
-	
-	public ReflectMethodRecord indexedReadMethod;
-	public ReflectMethodRecord indexedWriteMethod;
-	public String indexedPropertyTypeName;
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/InvalidObject.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/InvalidObject.java
deleted file mode 100644
index 989c7ea..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/InvalidObject.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InvalidObject.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
-
-import java.io.ObjectStreamException;
-import java.io.Serializable;
- 
-
-/**
- * An indicator object for invalid object type. This is used with feature attribute
- * values from the BeanInfo classes. We can only handle certain types when we
- * bring them over from the BeanInfo VM. That is because the classes instantiated
- * in the BeanInfo class may not be available in the IDE.  So any invalid value
- * will be replaced by this class instance.
- * <p>
- * This is a singleton class.
- * There will be one instance (InvalidObject.INSTANCE) in the system. That way
- * "==" can be used to test for it.
- * 
- * @since 1.1.0
- */
-public class InvalidObject implements Serializable {
-	
-	/**
-	 * Singleton instance of InvalidObject.
-	 * @since 1.1.0
-	 */
-	public static final InvalidObject INSTANCE = new InvalidObject();
-	
-	private static final long serialVersionUID = 1105643804370L;
-	
-	/*
-	 * Nobody else should create one of these.
-	 */
-	private InvalidObject() {
-	}
-
-	private Object readResolve() throws ObjectStreamException {
-		return INSTANCE;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/MethodRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/MethodRecord.java
deleted file mode 100644
index 375a69e..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/MethodRecord.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: MethodRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * This is the data structure for sending the MethodDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the MethodDescriptor. 
- * @since 1.1.0
- */
-public class MethodRecord extends FeatureRecord {
-	
-	private static final long serialVersionUID = 1105982213110L;
-	
-	/**
-	 * Method signature for the method this record describes.
-	 */
-	public ReflectMethodRecord methodForDescriptor;
-	/**
-	 * Parameter records array. It may be <code>null</code> if there aren't any.
-	 */
-	public ParameterRecord[] parameters;
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ParameterRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ParameterRecord.java
deleted file mode 100644
index 4aac601..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ParameterRecord.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ParameterRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * This is the data structure for sending the ParameterDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the ParameterDescriptor.
- * <p>
- * The only field of importance is the name, and that comes from FeatureRecord. 
- * @since 1.1.0
- */
-public class ParameterRecord extends FeatureRecord {
-
-	private static final long serialVersionUID = 1105982438955L;
-	
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/PropertyRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/PropertyRecord.java
deleted file mode 100644
index cb564dd..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/PropertyRecord.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PropertyRecord.java,v $
- *  $Revision: 1.3 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
- 
-
-/**
- * This is the data structure for sending the PropertyDescriptor info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the PropertyDescriptor. 
- * @since 1.1.0
- */
-public class PropertyRecord extends FeatureRecord {
-	private static final long serialVersionUID = 1105979276648L;
-	
-	public String propertyEditorClassName;
-	public String propertyTypeName;
-	public ReflectMethodRecord readMethod;
-	public ReflectMethodRecord writeMethod;
-	public ReflectFieldRecord field;
-	public boolean bound;
-	public boolean constrained;
-	public Boolean designTime;
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ReflectFieldRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ReflectFieldRecord.java
deleted file mode 100644
index a495709..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ReflectFieldRecord.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ReflectFieldRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
-
-import java.io.Serializable;
- 
-
-/**
- * This is the data structure for sending the java.lang.reflect.Field info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the java.lang.reflect.Field. 
- * @since 1.1.0
- */
-public class ReflectFieldRecord implements Serializable {
-	
-	private static final long serialVersionUID = 1105981512453L;
-	
-	public String className;
-	public String fieldName;
-	public boolean readOnly;
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ReflectMethodRecord.java b/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ReflectMethodRecord.java
deleted file mode 100644
index 01ff2be..0000000
--- a/plugins/org.eclipse.jem.beaninfo/beaninfoCommon/org/eclipse/jem/internal/beaninfo/common/ReflectMethodRecord.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ReflectMethodRecord.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:44:52 $ 
- */
-package org.eclipse.jem.internal.beaninfo.common;
-
-import java.io.Serializable;
- 
-
-/**
- * This is the data structure for sending the java.lang.reflect.Method info from
- * the BeanInfo vm to the IDE vm. It is serializable so that it can
- * be serialized for transmission.
- * <p>
- * It contains the properties of the java.lang.reflect.Method. 
- * @since 1.1.0
- */
-public class ReflectMethodRecord implements Serializable {
-	
-	private static final long serialVersionUID = 1105981512773L;
-	
-	public String className;
-	public String methodName;
-	public String[] parameterTypeNames;	// Maybe null if no parameters.
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/build.properties b/plugins/org.eclipse.jem.beaninfo/build.properties
deleted file mode 100644
index 8b8cac3..0000000
--- a/plugins/org.eclipse.jem.beaninfo/build.properties
+++ /dev/null
@@ -1,29 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-src.excludes = **/.cvsignore
-bin.includes = plugin.xml,\
-               plugin.properties,\
-               about.html,\
-               .options,\
-               META-INF/,\
-               .
-jars.compile.order = .,\
-                     vm/beaninfovm.jar
-src.includes = about.html,\
-               model/,\
-               rose/,\
-               proxy.jars,\
-               schema/
-source.. = beaninfoCommon/,beaninfo/
-source.vm/beaninfovm.jar = vm_beaninfovm/
-output.vm/beaninfovm.jar = bin_vm_beaninfovm/
-output.. = bin/
-
diff --git a/plugins/org.eclipse.jem.beaninfo/model/beaninfo.ecore b/plugins/org.eclipse.jem.beaninfo/model/beaninfo.ecore
deleted file mode 100644
index cc92576..0000000
--- a/plugins/org.eclipse.jem.beaninfo/model/beaninfo.ecore
+++ /dev/null
@@ -1,290 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ecore:EPackage xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="beaninfo"
-    nsURI="http:///org/eclipse/jem/internal/beaninfo/beaninfo.ecore" nsPrefix="org.eclipse.jem.internal.beaninfo.beaninfo">
-  <eClassifiers xsi:type="ecore:EClass" name="FeatureDecorator" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EAnnotation">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Equivalent to FeatureDescriptor in java.&#xD;&#xA;&lt;p>&#xD;&#xA;Note: If any attribute is explicitly set then the BeanInfo/Reflection will not be merged into the decorator. This provides a way of overriding the BeanInfos. Also for any many-valued attribute, if it is desired to have it explicitly empty and not have BeanInfo fill it in, there will be another attribute named of the form &quot;attibutueExplicitEmpty&quot; If this is true then the BeanInfo will not merge in and will leave it empty.&#xD;&#xA;&lt;p>&#xD;&#xA;These comments about merging apply to all subclasses of this decorator too. "/>
-    </eAnnotations>
-    <eOperations name="getName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="displayName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="shortDescription" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="category" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="expert" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="hidden" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="preferred" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mergeIntrospection" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the introspection results be merged into this decorator. If this is set to false, then the introspection results are ignored for this particular decorator. This is an internal feature simply to allow desired override capabilities. Customers would use it to prevent ANY introspection/reflection from occurring."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="attributesExplicitEmpty"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The attributes are explicitly set as empty and not retrieved from the beaninfo/reflection. Customers should set this if they want the list of attributes to be empty and not merged with the BeanInfo results. "/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="implicitlySetBits" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//ELong">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="A bitflag for which attributes have been set by BeanInfo/Reflection.&#xD;&#xA;&lt;p>&#xD;&#xA;This is an internal attribute that is used by the BeanInfo maintanance. It is not meant to be used by customers."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="implicitDecoratorFlag"
-        eType="#//ImplicitItem">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this decorator/feature implicit. This means created by Introspection/Reflection and not by customer.&#xD;&#xA;&lt;p>&#xD;&#xA;This is an internal attribute that is used by the BeanInfo maintanance. It is not meant to be used by customers."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributes" upperBound="-1"
-        eType="#//FeatureAttributeMapEntry" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Feature attributes. Key/value pairs. If it is desired that the feature attributes is explicitly empty and not have BeanInfo/reflection set it, set attributesExplicitEmpty to true."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BeanDecorator" eSuperTypes="#//FeatureDecorator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Equivalent to BeanDecorator in java."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mergeSuperProperties" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true" unsettable="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the properties of super types be merged when asking for eAllAttributes/eAllReferences."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mergeSuperMethods" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true" unsettable="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the methods of super types be merged when asking for eAllBehaviors."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mergeSuperEvents" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true" unsettable="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the events of super types be merged when asking for eAllEvents."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="introspectProperties" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the properties from the introspection be added to the class. This allows properties to not be introspected and to use only what is defined explicitly in the JavaClass xmi file."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="introspectMethods" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the methods from the introspection be added to the class. This allows methods to not be introspected and to use only what is defined explicitly in the JavaClass xmi file."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="introspectEvents" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Should the events from the introspection be added to the class. This allows events to not be introspected and to use only what is defined explicitly in the JavaClass xmi file."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="doBeaninfo" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        defaultValueLiteral="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This means do we go and get the beaninfo from the remote vm. If false, then it will not try to get the beaninfo. This doesn't prevent introspection through reflection. That is controled by the separate introspect... attributes."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="notInheritedPropertyNames"
-        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the list of inherited property names to not use in getAllProperties(). These names are properties that should not be inherited and should not show through. If the inherited property is not on the list then it will show in getAllProperties().&#xD;&#xA;&lt;p>&#xD;&#xA;This list will be empty if all properties are inherited or if the mergeSuperProperties flag is false.&#xD;&#xA;&lt;p>&#xD;&#xA;Note: This attribute is not meant to be changed by clients. It is an internal attribute."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="notInheritedMethodNames"
-        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the list of inherited method names to not use in eAllOperations(). These names are operations that should not be inherited and should not show through. If the inherited operation is not on the list then it will show in getAllOperations().&#xD;&#xA;&lt;p>&#xD;&#xA;This list will be empty if all operations are inherited or if the mergeSuperBehaviors flag is false."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="notInheritedEventNames"
-        upperBound="-1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the list of inherited event names to not use in getAllEvents(). These names are events that should not be inherited and should not show through. If the inherited event is not on the list then it will show in getAllEvents().&#xD;&#xA;&lt;p>&#xD;&#xA;This list will be empty if all events are inherited or if the mergeSuperEvents flag is false."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="customizerClass" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//JavaClass"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="EventSetDecorator" eSuperTypes="#//FeatureDecorator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Equivalent to EventSetDecorator in java."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="inDefaultEventSet" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="unicast" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="listenerMethodsExplicitEmpty"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set true if the listenerMethods feature is explicitly set as empty and is not to have listener methods merged in from BeanInfo or reflection."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="addListenerMethod" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="listenerMethods" lowerBound="1"
-        upperBound="-1" eType="#//MethodProxy" volatile="true" transient="true" derived="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="listener methods. If it is desired that the list be explicitly empty and not have BeanInfo set it, then set listenerMethodsExplicitEmpty to true.&#xD;&#xA;&lt;p>&#xD;&#xA;ListenerMethods will be decorated with MethodDecorators.&#xD;&#xA;&lt;p>&#xD;&#xA;Note: This is a derived setting, which means it will not notify out changes to it. To here changes to it, listen on &quot;serListMthd&quot; notifications instead."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="listenerType" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//JavaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="removeListenerMethod" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="eventAdapterClass" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//JavaClass">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="For some listener interfaces an adapter class is provided that implements default no-op methods, e.g. java.awt.event.FocusEvent which has java.awt.event.FocusAdapter. The Adapter class is provided in a key/value pair on the java.beans.EventSetDescriptor with a key defined in a static final constants EVENTADAPTERCLASS = &quot;eventAdapterClass&quot;."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="serListMthd" lowerBound="1"
-        upperBound="-1" eType="#//MethodProxy" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is a private feature. It is used internally only. "/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="MethodDecorator" eSuperTypes="#//FeatureDecorator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Equivalent to MethodDecorator in java."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="parmsExplicitEmpty" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set true if the parms feature is explicitly set as empty and is not to have parameters merged in from BeanInfo or reflection."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="parameterDescriptors" upperBound="-1"
-        eType="#//ParameterDecorator" volatile="true" transient="true" derived="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the parameter descriptors list.&#xD;&#xA;&lt;p>&#xD;&#xA;Note: This is a derived setting, which means it will not notify out changes to it. To here changes to it, listen on &quot;serParmDesc&quot; notifications instead."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="serParmDesc" upperBound="-1"
-        eType="#//ParameterDecorator" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is a private feature. It is used internally only. "/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ParameterDecorator" eSuperTypes="#//FeatureDecorator">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The name is explicit here because unlike the other feature decorators, the name does not come from the object being decorated."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="parameter" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//JavaParameter"
-        transient="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The JavaParameter that this ParameterDecorator is decorating. Can't use eDecorates in this."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PropertyDecorator" eSuperTypes="#//FeatureDecorator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Equivalent to PropertyDecorator in java."/>
-    </eAnnotations>
-    <eOperations name="getPropertyType" eType="ecore:EClass ../../org.eclipse.emf.ecore/model/Ecore.ecore#//EClassifier">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the property type."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="setPropertyType">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set the property type."/>
-      </eAnnotations>
-      <eParameters name="propertyType" eType="ecore:EClass ../../org.eclipse.emf.ecore/model/Ecore.ecore#//EClassifier"/>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="bound" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="constrained" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="designTime" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"
-        unsettable="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="If not set, then normal default processing.&#xD;&#xA;&#xD;&#xA;If set true, then this property is a design time property. This means it will show up in the property sheet, but it won't be able to be connected to at runtime. It may not even be a true bean property but instead the builder will know how to handle it.&#xD;&#xA;&#xD;&#xA;If set false, then this property will not show up on the property sheet, but will be able to be connected to for runtime."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="alwaysIncompatible" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="If set true, then when multiple objects are selected, this property is always incompatible with each other. So in this case the property will not show up on the property sheet if more than one object has been selected."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="filterFlags" upperBound="-1"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="fieldReadOnly" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this field read-only (i.e. is a &quot;final&quot; field). This is only referenced if the field reference is set."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyEditorClass" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//JavaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="readMethod" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="writeMethod" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="field" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Field"
-        unsettable="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="If this is set, then this property is a field and not a getter/setter property. This is an extension that the Visual Editor uses to the BeanInfo model."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="IndexedPropertyDecorator" eSuperTypes="#//PropertyDecorator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Equivalent to IndexedPropertyDecorator"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="indexedReadMethod" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"
-        unsettable="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="indexedWriteMethod" eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"
-        unsettable="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="MethodProxy" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EOperation">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This is just a wrapper of a java Method. It allows access to the method but doesn't duplicate the interface for it.&#xD;&#xA;&lt;p>&#xD;&#xA;MethodProxies will be in the eBehaviors setting for any methods that are in the JavaClass methods setting so that they are not duplicated.&#xD;&#xA;&lt;p>&#xD;&#xA;MethodProxies would also have MethodDecorators."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="method" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.jem/model/java.ecore#//Method"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BeanEvent" eSuperTypes="../../org.eclipse.jem/model/java.ecore#//JavaEvent">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Event from Introspection/Reflection.&#xD;&#xA;&lt;p>&#xD;&#xA;The BeanEvent will be under the JavaClass' events and allEvents feature. Each BeanEvent will be decorated by an EventSetDecorator."/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FeatureAttributeMapEntry" instanceClassName="java.util.Map$Entry">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="key" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="#//FeatureAttributeValue"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EDataType" name="FeatureAttributeValue" instanceClassName="org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This is the attribute value for feature attribute. It can only represent the following:&#xD;&#xA;&#xD;&#xA;- String&#xD;&#xA;- primitives&#xD;&#xA;- array (type Object) containing mixture of Strings and primitives (as the object types)&#xD;&#xA;- array (type String)&#xD;&#xA;- array (type primitive)&#xD;&#xA;&#xD;&#xA;Anything else cannot be represented."/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EEnum" name="ImplicitItem">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This enum is an internal enum. It is used by BeanInfo for cache maintenance.&#xD;&#xA;&lt;p>&#xD;&#xA;This enum is not meant to be used by clients."/>
-    </eAnnotations>
-    <eLiterals name="NOT_IMPLICIT">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Means this decorator is not implicit. That is it was created by customer."/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="IMPLICIT_DECORATOR" value="1">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This means that the decorator is implicit. That is it was not created by the customer."/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="IMPLICIT_DECORATOR_AND_FEATURE" value="2">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This means the decorator and the feature where implicit. That is they were not created by the customer."/>
-      </eAnnotations>
-    </eLiterals>
-  </eClassifiers>
-</ecore:EPackage>
diff --git a/plugins/org.eclipse.jem.beaninfo/model/introspect.genmodel b/plugins/org.eclipse.jem.beaninfo/model/introspect.genmodel
deleted file mode 100644
index 52616c4..0000000
--- a/plugins/org.eclipse.jem.beaninfo/model/introspect.genmodel
+++ /dev/null
@@ -1,97 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<genmodel:GenModel xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.jem.beaninfo/beaninfo"
-    editDirectory="/org.eclipse.jem.beaninfo.edit/src" editorDirectory="/org.eclipse.jem.beaninfo.editor/src"
-    modelPluginID="" modelName="Beaninfo" editPluginClass="org.eclipse.jem.internal.beaninfo.provider.BeaninfoEditPlugin"
-    editorPluginClass="org.eclipse.jem.internal.beaninfo.presentation.BeaninfoEditorPlugin"
-    updateClasspath="false" booleanFlagsField="eFlags" booleanFlagsReservedBits="8"
-    importerID="org.eclipse.emf.importer.rose" usedGenPackages="../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.jem/model/javaModel.genmodel#//java">
-  <foreignModel>..\rose\introspect.mdl</foreignModel>
-  <foreignModel>WorkspaceRoot</foreignModel>
-  <foreignModel>../..</foreignModel>
-  <genPackages prefix="Beaninfo" basePackage="org.eclipse.jem.internal" adapterFactory="false"
-      ecorePackage="beaninfo.ecore#/">
-    <genEnums ecoreEnum="beaninfo.ecore#//ImplicitItem">
-      <genEnumLiterals ecoreEnumLiteral="beaninfo.ecore#//ImplicitItem/NOT_IMPLICIT"/>
-      <genEnumLiterals ecoreEnumLiteral="beaninfo.ecore#//ImplicitItem/IMPLICIT_DECORATOR"/>
-      <genEnumLiterals ecoreEnumLiteral="beaninfo.ecore#//ImplicitItem/IMPLICIT_DECORATOR_AND_FEATURE"/>
-    </genEnums>
-    <genDataTypes ecoreDataType="beaninfo.ecore#//FeatureAttributeValue"/>
-    <genClasses ecoreClass="beaninfo.ecore#//FeatureDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/displayName"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/shortDescription"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/category"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/expert"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/hidden"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/preferred"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/mergeIntrospection"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/attributesExplicitEmpty"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/implicitlySetBits"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureDecorator/implicitDecoratorFlag"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference beaninfo.ecore#//FeatureDecorator/attributes"/>
-      <genOperations ecoreOperation="beaninfo.ecore#//FeatureDecorator/getName"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//BeanDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/mergeSuperProperties"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/mergeSuperMethods"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/mergeSuperEvents"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/introspectProperties"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/introspectMethods"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/introspectEvents"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/doBeaninfo"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/notInheritedPropertyNames"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/notInheritedMethodNames"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//BeanDecorator/notInheritedEventNames"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//BeanDecorator/customizerClass"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//EventSetDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//EventSetDecorator/inDefaultEventSet"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//EventSetDecorator/unicast"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//EventSetDecorator/listenerMethodsExplicitEmpty"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//EventSetDecorator/addListenerMethod"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference beaninfo.ecore#//EventSetDecorator/listenerMethods"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//EventSetDecorator/listenerType"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//EventSetDecorator/removeListenerMethod"/>
-      <genFeatures notify="false" createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//EventSetDecorator/eventAdapterClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference beaninfo.ecore#//EventSetDecorator/serListMthd"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//MethodDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//MethodDecorator/parmsExplicitEmpty"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference beaninfo.ecore#//MethodDecorator/parameterDescriptors"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference beaninfo.ecore#//MethodDecorator/serParmDesc"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//ParameterDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//ParameterDecorator/name"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//ParameterDecorator/parameter"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//PropertyDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//PropertyDecorator/bound"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//PropertyDecorator/constrained"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//PropertyDecorator/designTime"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//PropertyDecorator/alwaysIncompatible"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//PropertyDecorator/filterFlags"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//PropertyDecorator/fieldReadOnly"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//PropertyDecorator/propertyEditorClass"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//PropertyDecorator/readMethod"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//PropertyDecorator/writeMethod"/>
-      <genFeatures notify="false" createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//PropertyDecorator/field"/>
-      <genOperations ecoreOperation="beaninfo.ecore#//PropertyDecorator/getPropertyType"/>
-      <genOperations ecoreOperation="beaninfo.ecore#//PropertyDecorator/setPropertyType">
-        <genParameters ecoreParameter="beaninfo.ecore#//PropertyDecorator/setPropertyType/propertyType"/>
-      </genOperations>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//IndexedPropertyDecorator">
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//IndexedPropertyDecorator/indexedReadMethod"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//IndexedPropertyDecorator/indexedWriteMethod"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//MethodProxy">
-      <genFeatures createChild="false" ecoreFeature="ecore:EReference beaninfo.ecore#//MethodProxy/method"/>
-    </genClasses>
-    <genClasses ecoreClass="beaninfo.ecore#//BeanEvent"/>
-    <genClasses ecoreClass="beaninfo.ecore#//FeatureAttributeMapEntry">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureAttributeMapEntry/key"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EAttribute beaninfo.ecore#//FeatureAttributeMapEntry/value"/>
-    </genClasses>
-  </genPackages>
-</genmodel:GenModel>
diff --git a/plugins/org.eclipse.jem.beaninfo/plugin.properties b/plugins/org.eclipse.jem.beaninfo/plugin.properties
deleted file mode 100644
index f7f55ad..0000000
--- a/plugins/org.eclipse.jem.beaninfo/plugin.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.beaninfo/plugin.properties,v $
-# $Revision: 1.7 $  $Date: 2005/08/24 20:31:29 $
-#
-
-
-pluginName=Java EMF Model BeanInfo (Introspection) Support
-providerName = Eclipse.org
-beaninfoNatureName=Java Model BeanInfo Nature
-registrations.extensionpoint.name=BeanInfo extension registrations
diff --git a/plugins/org.eclipse.jem.beaninfo/plugin.xml b/plugins/org.eclipse.jem.beaninfo/plugin.xml
deleted file mode 100644
index 901dcf3..0000000
--- a/plugins/org.eclipse.jem.beaninfo/plugin.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-
-     <extension-point id="registrations" name="%registrations.extensionpoint.name" schema="schema/registrations.exsd"/>
-
-   <extension
-         id="BeanInfoNature"
-         name="%beaninfoNatureName"
-         point="org.eclipse.core.resources.natures">
-      <runtime>
-         <run
-               class="org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature">
-         </run>
-      </runtime>
-   </extension>
-   <extension
-         point="org.eclipse.emf.ecore.generated_package">
-      <package
-            uri="http:///org/eclipse/jem/internal/beaninfo.ecore"
-            class="org.eclipse.jem.internal.beaninfo.BeaninfoPackage">
-      </package>
-   </extension>
-   <extension
-         point="org.eclipse.team.core.fileTypes">
-      <fileTypes
-            type="text"
-            extension="beaninfoConfig">
-      </fileTypes>
-      <fileTypes
-            type="text"
-            extension="override">
-      </fileTypes>
-   </extension>
-
-</plugin>
diff --git a/plugins/org.eclipse.jem.beaninfo/proxy.jars b/plugins/org.eclipse.jem.beaninfo/proxy.jars
deleted file mode 100644
index 176820a..0000000
--- a/plugins/org.eclipse.jem.beaninfo/proxy.jars
+++ /dev/null
@@ -1,2 +0,0 @@
-vm/beaninfovm.jar=/org.eclipse.jem.beaninfo/bin_vm_beaninfovm/
-beaninfocommon.jar=/org.eclipse.jem.beaninfo/bin_beaninfocommon/
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/rose/.cvsignore b/plugins/org.eclipse.jem.beaninfo/rose/.cvsignore
deleted file mode 100644
index 1be3a37..0000000
--- a/plugins/org.eclipse.jem.beaninfo/rose/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*.md~
-*.ca~
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.beaninfo/rose/beaninfo.cat b/plugins/org.eclipse.jem.beaninfo/rose/beaninfo.cat
deleted file mode 100644
index dd227ce..0000000
--- a/plugins/org.eclipse.jem.beaninfo/rose/beaninfo.cat
+++ /dev/null
@@ -1,3301 +0,0 @@
-
-(object Petal
-    version    	47
-    _written   	"Rose 8.0.0303.1400"
-    charSet    	0)
-
-(object Class_Category "beaninfo"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    attributes 	(list Attribute_Set
-	(object Attribute
-	    tool       	"Ecore"
-	    name       	"basePackage"
-	    value      	(value Text "org.eclipse.jem.internal.beaninfo")))
-    quid       	"3A799ABB0353"
-    exportControl 	"Public"
-    logical_models 	(list unit_reference_list
-	(object Class "FeatureDecorator"
-	    quid       	"3A799B3E01E9"
-	    documentation 	
-|Equivalent to FeatureDescriptor in java.
-|<p>
-|Note: If any attribute is explicitly set then the BeanInfo/Reflection will not be merged into the decorator. This provides a way of overriding the BeanInfos. Also for any many-valued attribute, if it is desired to have it explicitly empty and not have BeanInfo fill it in, there will be another attribute named of the form "attibutueExplicitEmpty" If this is true then the BeanInfo will not merge in and will leave it empty.
-|<p>
-|These comments about merging apply to all subclasses of this decorator too. 
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3DFA185900DC"
-		    supplier   	"Logical View::ecore::EAnnotation"
-		    quidu      	"3D98A1C701AB"))
-	    operations 	(list Operations
-		(object Operation "getName"
-		    quid       	"3B867D0D0184"
-		    result     	"String"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "displayName"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79CFCC0131"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "shortDescription"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79CFD501E8"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "category"
-		    attributes 	(list Attribute_Set)
-		    quid       	"3BA2797102DC"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "expert"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79CFE700FE"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "hidden"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79D0050328"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "preferred"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79D0240318"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "mergeIntrospection"
-		    quid       	"3A82C0A60389"
-		    documentation 	"Should the introspection results be merged into this decorator. If this is set to false, then the introspection results are ignored for this particular decorator. This is an internal feature simply to allow desired override capabilities. Customers would use it to prevent ANY introspection/reflection from occurring."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "attributesExplicitEmpty"
-		    quid       	"3C9B49320265"
-		    documentation 	"The attributes are explicitly set as empty and not retrieved from the beaninfo/reflection. Customers should set this if they want the list of attributes to be empty and not merged with the BeanInfo results. "
-		    type       	"boolean"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "implicitlySetBits"
-		    quid       	"41E5815D02B9"
-		    documentation 	
-|A bitflag for which attributes have been set by BeanInfo/Reflection.
-|<p>
-|This is an internal attribute that is used by the BeanInfo maintanance. It is not meant to be used by customers.
-		    
-		    type       	"long")
-		(object ClassAttribute "implicitDecoratorFlag"
-		    quid       	"41E5A05D021A"
-		    documentation 	
-|Is this decorator/feature implicit. This means created by Introspection/Reflection and not by customer.
-|<p>
-|This is an internal attribute that is used by the BeanInfo maintanance. It is not meant to be used by customers.
-		    
-		    type       	"ImplicitItem"
-		    quidu      	"41E59E5D0296")))
-	(object Class "BeanDecorator"
-	    quid       	"3A79D0DF02D1"
-	    documentation 	"Equivalent to BeanDecorator in java."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A79DE8E007F"
-		    supplier   	"Logical View::beaninfo::FeatureDecorator"
-		    quidu      	"3A799B3E01E9"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "mergeSuperProperties"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A82B73E0200"
-		    documentation 	"Should the properties of super types be merged when asking for eAllAttributes/eAllReferences."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "mergeSuperMethods"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A82B9940015"
-		    documentation 	"Should the methods of super types be merged when asking for eAllBehaviors."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "mergeSuperEvents"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A82B99F0165"
-		    documentation 	"Should the events of super types be merged when asking for eAllEvents."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "introspectProperties"
-		    quid       	"3A8427EC00A6"
-		    documentation 	"Should the properties from the introspection be added to the class. This allows properties to not be introspected and to use only what is defined explicitly in the JavaClass xmi file."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "introspectMethods"
-		    quid       	"3A84287501B1"
-		    documentation 	"Should the methods from the introspection be added to the class. This allows methods to not be introspected and to use only what is defined explicitly in the JavaClass xmi file."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "introspectEvents"
-		    quid       	"3A842877000F"
-		    documentation 	"Should the events from the introspection be added to the class. This allows events to not be introspected and to use only what is defined explicitly in the JavaClass xmi file."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "doBeaninfo"
-		    quid       	"3C9A46FC027C"
-		    documentation 	"This means do we go and get the beaninfo from the remote vm. If false, then it will not try to get the beaninfo. This doesn't prevent introspection through reflection. That is controled by the separate introspect... attributes."
-		    type       	"boolean"
-		    initv      	"true"
-		    exportControl 	"Implementation")
-		(object ClassAttribute "notInheritedPropertyNames"
-		    quid       	"41EED50B0185"
-		    documentation 	
-|This is the list of inherited property names to not use in getAllProperties(). These names are properties that should not be inherited and should not show through. If the inherited property is not on the list then it will show in getAllProperties().
-|<p>
-|This list will be empty if all properties are inherited or if the mergeSuperProperties flag is false.
-|<p>
-|Note: This attribute is not meant to be changed by clients. It is an internal attribute.
-		    
-		    stereotype 	"0..*"
-		    type       	"String")
-		(object ClassAttribute "notInheritedMethodNames"
-		    quid       	"41F02C5F0399"
-		    documentation 	
-|This is the list of inherited method names to not use in eAllOperations(). These names are operations that should not be inherited and should not show through. If the inherited operation is not on the list then it will show in getAllOperations().
-|<p>
-|This list will be empty if all operations are inherited or if the mergeSuperBehaviors flag is false.
-		    
-		    stereotype 	"0..*"
-		    type       	"String")
-		(object ClassAttribute "notInheritedEventNames"
-		    quid       	"41F02D0A0312"
-		    documentation 	
-|This is the list of inherited event names to not use in getAllEvents(). These names are events that should not be inherited and should not show through. If the inherited event is not on the list then it will show in getAllEvents().
-|<p>
-|This list will be empty if all events are inherited or if the mergeSuperEvents flag is false.
-		    
-		    stereotype 	"0..*"
-		    type       	"String")))
-	(object Class "EventSetDecorator"
-	    quid       	"3A79D1D2004F"
-	    documentation 	"Equivalent to EventSetDecorator in java."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A79DEA200EC"
-		    supplier   	"Logical View::beaninfo::FeatureDecorator"
-		    quidu      	"3A799B3E01E9"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "inDefaultEventSet"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79D94F004C"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "unicast"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79D9580167"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "listenerMethodsExplicitEmpty"
-		    quid       	"3CB1AF7D0286"
-		    documentation 	"Set true if the listenerMethods feature is explicitly set as empty and is not to have listener methods merged in from BeanInfo or reflection."
-		    type       	"boolean"
-		    exportControl 	"Implementation")))
-	(object Class "MethodDecorator"
-	    quid       	"3A79D35E0027"
-	    documentation 	"Equivalent to MethodDecorator in java."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A79DEA603E1"
-		    supplier   	"Logical View::beaninfo::FeatureDecorator"
-		    quidu      	"3A799B3E01E9"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "parmsExplicitEmpty"
-		    quid       	"3B86ABE80092"
-		    documentation 	"Set true if the parms feature is explicitly set as empty and is not to have parameters merged in from BeanInfo or reflection."
-		    type       	"boolean"
-		    exportControl 	"Implementation")))
-	(object Class "ParameterDecorator"
-	    quid       	"3A79D9C20304"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A79DEBB01C4"
-		    supplier   	"Logical View::beaninfo::FeatureDecorator"
-		    quidu      	"3A799B3E01E9"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "name"
-		    quid       	"3B86A6700099"
-		    documentation 	"The name is explicit here because unlike the other feature decorators, the name does not come from the object being decorated."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PropertyDecorator"
-	    quid       	"3A79DA68010E"
-	    documentation 	"Equivalent to PropertyDecorator in java."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A79DE9702BD"
-		    supplier   	"Logical View::beaninfo::FeatureDecorator"
-		    quidu      	"3A799B3E01E9"))
-	    operations 	(list Operations
-		(object Operation "getPropertyType"
-		    quid       	"3B8CF526039D"
-		    documentation 	"Get the property type."
-		    result     	"EClassifier"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3ACE4FEE0371")
-		(object Operation "setPropertyType"
-		    quid       	"4329D1CE030E"
-		    documentation 	"Set the property type."
-		    parameters 	(list Parameters
-			(object Parameter "propertyType"
-			    quid       	"4329D1E20168"
-			    type       	"EClassifier"
-			    quidu      	"3ACE4FEE0371"))
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "bound"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79DC250303"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "constrained"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79DC2C00A0"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "designTime"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3BA27455019B"
-		    documentation 	
-|If not set, then normal default processing.
-|
-|If set true, then this property is a design time property. This means it will show up in the property sheet, but it won't be able to be connected to at runtime. It may not even be a true bean property but instead the builder will know how to handle it.
-|
-|If set false, then this property will not show up on the property sheet, but will be able to be connected to for runtime.
-		    
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "alwaysIncompatible"
-		    quid       	"3BA27A1700BE"
-		    documentation 	"If set true, then when multiple objects are selected, this property is always incompatible with each other. So in this case the property will not show up on the property sheet if more than one object has been selected."
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "filterFlags"
-		    quid       	"3BA3B18F0036"
-		    stereotype 	"0..*"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "fieldReadOnly"
-		    quid       	"4207E101018E"
-		    documentation 	
-|Is this field read-only (i.e. is a "final" field). This is only referenced if the field reference is set.
-		    
-		    type       	"boolean"
-		    exportControl 	"Public")))
-	(object Class "IndexedPropertyDecorator"
-	    quid       	"3A79DC450309"
-	    documentation 	"Equivalent to IndexedPropertyDecorator"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A79DE840388"
-		    supplier   	"Logical View::beaninfo::PropertyDecorator"
-		    quidu      	"3A79DA68010E")))
-	(object Class "MethodProxy"
-	    quid       	"3A8984C901C3"
-	    documentation 	
-|This is just a wrapper of a java Method. It allows access to the method but doesn't duplicate the interface for it.
-|<p>
-|MethodProxies will be in the eBehaviors setting for any methods that are in the JavaClass methods setting so that they are not duplicated.
-|<p>
-|MethodProxies would also have MethodDecorators.
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3DFA19B600DE"
-		    supplier   	"Logical View::ecore::EOperation"
-		    quidu      	"3904DAA200A0")))
-	(object Class "BeanEvent"
-	    quid       	"3CB09CA90212"
-	    documentation 	
-|Event from Introspection/Reflection.
-|<p>
-|The BeanEvent will be under the JavaClass' events and allEvents feature. Each BeanEvent will be decorated by an EventSetDecorator.
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3CB09CB6038D"
-		    supplier   	"Logical View::java::JavaEvent"
-		    quidu      	"3C62FAF103C8")))
-	(object Class "FeatureAttributeMapEntry"
-	    quid       	"404CC85501F5"
-	    stereotype 	"MapEntry"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "key"
-		    quid       	"404CC8B70304"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "value"
-		    attributes 	(list Attribute_Set)
-		    quid       	"41E58414010A"
-		    type       	"FeatureAttributeValue"
-		    quidu      	"41E582F800BB"
-		    exportControl 	"Public")))
-	(object Class "FeatureAttributeValue"
-	    quid       	"41E582F800BB"
-	    documentation 	
-|This is the attribute value for feature attribute. It can only represent the following:
-|
-|- String
-|- primitives
-|- array (type Object) containing mixture of Strings and primitives (as the object types)
-|- array (type String)
-|- array (type primitive)
-|
-|Anything else cannot be represented.
-	    
-	    stereotype 	"datatype"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "org.eclipse.jem.internal.beaninfo.common.FeatureAttributeValue"
-		    quid       	"41E583B503CA"
-		    stereotype 	"javaclass")))
-	(object Class "ImplicitItem"
-	    quid       	"41E59E5D0296"
-	    documentation 	
-|This enum is an internal enum. It is used by BeanInfo for cache maintenance.
-|<p>
-|This enum is not meant to be used by clients.
-	    
-	    stereotype 	"enumeration"
-	    exportControl 	"Protected"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "NOT_IMPLICIT"
-		    quid       	"41E59F2A00EC"
-		    documentation 	"Means this decorator is not implicit. That is it was created by customer.")
-		(object ClassAttribute "IMPLICIT_DECORATOR"
-		    quid       	"41E59F7200B4"
-		    documentation 	"This means that the decorator is implicit. That is it was not created by the customer.")
-		(object ClassAttribute "IMPLICIT_DECORATOR_AND_FEATURE"
-		    quid       	"41E59FA303B7"
-		    documentation 	"This means the decorator and the feature where implicit. That is they were not created by the customer.")))
-	(object Association "$UNNAMED$0"
-	    quid       	"3A79CF6C0378"
-	    roles      	(list role_list
-		(object Role "attributes"
-		    attributes 	(list Attribute_Set)
-		    quid       	"3A79CF6E00BE"
-		    documentation 	"Feature attributes. Key/value pairs. If it is desired that the feature attributes is explicitly empty and not have BeanInfo/reflection set it, set attributesExplicitEmpty to true."
-		    label      	"attributes"
-		    supplier   	"Logical View::beaninfo::FeatureAttributeMapEntry"
-		    quidu      	"404CC85501F5"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$1"
-		    quid       	"3A79CF6E00C8"
-		    supplier   	"Logical View::beaninfo::FeatureDecorator"
-		    quidu      	"3A799B3E01E9"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$2"
-	    quid       	"3A79D1350248"
-	    roles      	(list role_list
-		(object Role "customizerClass"
-		    attributes 	(list Attribute_Set)
-		    quid       	"3A79D13601D2"
-		    label      	"customizerClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$3"
-		    quid       	"3A79D13601E6"
-		    supplier   	"Logical View::beaninfo::BeanDecorator"
-		    quidu      	"3A79D0DF02D1")))
-	(object Association "$UNNAMED$4"
-	    quid       	"3A79D3080128"
-	    roles      	(list role_list
-		(object Role "addListenerMethod"
-		    quid       	"3A79D3090346"
-		    label      	"addListenerMethod"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$5"
-		    quid       	"3A79D309035A"
-		    supplier   	"Logical View::beaninfo::EventSetDecorator"
-		    quidu      	"3A79D1D2004F")))
-	(object Association "$UNNAMED$6"
-	    quid       	"3A79D3E10364"
-	    roles      	(list role_list
-		(object Role "listenerMethods"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isVolatile"
-			    value      	TRUE))
-		    quid       	"3A79D3E6007D"
-		    documentation 	
-|listener methods. If it is desired that the list be explicitly empty and not have BeanInfo set it, then set listenerMethodsExplicitEmpty to true.
-|<p>
-|ListenerMethods will be decorated with MethodDecorators.
-|<p>
-|Note: This is a derived setting, which means it will not notify out changes to it. To here changes to it, listen on "serListMthd" notifications instead.
-		    
-		    label      	"listenerMethods"
-		    supplier   	"Logical View::beaninfo::MethodProxy"
-		    quidu      	"3A8984C901C3"
-		    client_cardinality 	(value cardinality "1..n")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$7"
-		    quid       	"3A79D3E60091"
-		    supplier   	"Logical View::beaninfo::EventSetDecorator"
-		    quidu      	"3A79D1D2004F"))
-	    derived    	TRUE)
-	(object Association "$UNNAMED$8"
-	    quid       	"3A79D4A80158"
-	    roles      	(list role_list
-		(object Role "listenerType"
-		    quid       	"3A79D4AA038B"
-		    label      	"listenerType"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$9"
-		    quid       	"3A79D4AA03B4"
-		    supplier   	"Logical View::beaninfo::EventSetDecorator"
-		    quidu      	"3A79D1D2004F")))
-	(object Association "$UNNAMED$10"
-	    quid       	"3A79D4DF020B"
-	    roles      	(list role_list
-		(object Role "removeListenerMethod"
-		    quid       	"3A79D4E10395"
-		    label      	"removeListenerMethod"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$11"
-		    quid       	"3A79D4E103A9"
-		    supplier   	"Logical View::beaninfo::EventSetDecorator"
-		    quidu      	"3A79D1D2004F")))
-	(object Association "$UNNAMED$12"
-	    quid       	"3A79DA1A02F7"
-	    roles      	(list role_list
-		(object Role "parameterDescriptors"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isVolatile"
-			    value      	TRUE))
-		    quid       	"3A79DA1C0231"
-		    documentation 	
-|This is the parameter descriptors list.
-|<p>
-|Note: This is a derived setting, which means it will not notify out changes to it. To here changes to it, listen on "serParmDesc" notifications instead.
-		    
-		    label      	"parameterDescriptors"
-		    supplier   	"Logical View::beaninfo::ParameterDecorator"
-		    quidu      	"3A79D9C20304"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$13"
-		    quid       	"3A79DA1C0232"
-		    supplier   	"Logical View::beaninfo::MethodDecorator"
-		    quidu      	"3A79D35E0027"))
-	    derived    	TRUE)
-	(object Association "$UNNAMED$14"
-	    quid       	"3A79DB0B0339"
-	    roles      	(list role_list
-		(object Role "propertyEditorClass"
-		    quid       	"3A79DB0E013F"
-		    label      	"propertyEditorClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$15"
-		    quid       	"3A79DB0E0171"
-		    supplier   	"Logical View::beaninfo::PropertyDecorator"
-		    quidu      	"3A79DA68010E")))
-	(object Association "$UNNAMED$16"
-	    quid       	"3A79DBBD0000"
-	    roles      	(list role_list
-		(object Role "readMethod"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79DBBF0071"
-		    label      	"readMethod"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$17"
-		    quid       	"3A79DBBF0085"
-		    supplier   	"Logical View::beaninfo::PropertyDecorator"
-		    quidu      	"3A79DA68010E")))
-	(object Association "$UNNAMED$18"
-	    quid       	"3A79DBDF02D0"
-	    roles      	(list role_list
-		(object Role "writeMethod"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79DBE101F7"
-		    label      	"writeMethod"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$19"
-		    quid       	"3A79DBE1020B"
-		    supplier   	"Logical View::beaninfo::PropertyDecorator"
-		    quidu      	"3A79DA68010E")))
-	(object Association "$UNNAMED$20"
-	    quid       	"3A79DE34036F"
-	    roles      	(list role_list
-		(object Role "indexedReadMethod"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79DE3503CA"
-		    label      	"indexedReadMethod"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$21"
-		    quid       	"3A79DE3503DE"
-		    supplier   	"Logical View::beaninfo::IndexedPropertyDecorator"
-		    quidu      	"3A79DC450309")))
-	(object Association "$UNNAMED$22"
-	    quid       	"3A79DE540180"
-	    roles      	(list role_list
-		(object Role "indexedWriteMethod"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"3A79DE5503D0"
-		    label      	"indexedWriteMethod"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$23"
-		    quid       	"3A79DE5503E4"
-		    supplier   	"Logical View::beaninfo::IndexedPropertyDecorator"
-		    quidu      	"3A79DC450309")))
-	(object Association "$UNNAMED$24"
-	    quid       	"3A89865B01D5"
-	    roles      	(list role_list
-		(object Role "method"
-		    quid       	"3A89865C01AE"
-		    label      	"method"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$25"
-		    quid       	"3A89865C01CC"
-		    supplier   	"Logical View::beaninfo::MethodProxy"
-		    quidu      	"3A8984C901C3")))
-	(object Association "$UNNAMED$26"
-	    quid       	"3C9A6EDD02C2"
-	    roles      	(list role_list
-		(object Role "parameter"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE))
-		    quid       	"3C9A6EDE01FB"
-		    documentation 	"The JavaParameter that this ParameterDecorator is decorating. Can't use eDecorates in this."
-		    label      	"parameter"
-		    supplier   	"Logical View::java::JavaParameter"
-		    quidu      	"3654AD780280"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$27"
-		    quid       	"3C9A6EDE0205"
-		    supplier   	"Logical View::beaninfo::ParameterDecorator"
-		    quidu      	"3A79D9C20304")))
-	(object Association "$UNNAMED$28"
-	    quid       	"41F016E7002E"
-	    roles      	(list role_list
-		(object Role "serParmDesc"
-		    quid       	"41F016E802A7"
-		    documentation 	"This is a private feature. It is used internally only. "
-		    label      	"serParmDesc"
-		    supplier   	"Logical View::beaninfo::ParameterDecorator"
-		    quidu      	"3A79D9C20304"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    exportControl 	"Private"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$29"
-		    quid       	"41F016E802B1"
-		    supplier   	"Logical View::beaninfo::MethodDecorator"
-		    quidu      	"3A79D35E0027"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$30"
-	    quid       	"41F11E710387"
-	    roles      	(list role_list
-		(object Role "eventAdapterClass"
-		    quid       	"41F11E730249"
-		    documentation 	
-|For some listener interfaces an adapter class is provided that implements default no-op methods, e.g. java.awt.event.FocusEvent which has java.awt.event.FocusAdapter. The Adapter class is provided in a key/value pair on the java.beans.EventSetDescriptor with a key defined in a static final constants EVENTADAPTERCLASS = "eventAdapterClass".
-		    
-		    label      	"eventAdapterClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$31"
-		    quid       	"41F11E73025D"
-		    supplier   	"Logical View::beaninfo::EventSetDecorator"
-		    quidu      	"3A79D1D2004F")))
-	(object Association "$UNNAMED$32"
-	    quid       	"41F1278A01A5"
-	    roles      	(list role_list
-		(object Role "serListMthd"
-		    quid       	"41F1278B021F"
-		    documentation 	"This is a private feature. It is used internally only. "
-		    label      	"serListMthd"
-		    supplier   	"Logical View::beaninfo::MethodProxy"
-		    quidu      	"3A8984C901C3"
-		    client_cardinality 	(value cardinality "1..n")
-		    Containment 	"By Value"
-		    exportControl 	"Private"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$33"
-		    quid       	"41F1278B0229"
-		    supplier   	"Logical View::beaninfo::EventSetDecorator"
-		    quidu      	"3A79D1D2004F"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$34"
-	    quid       	"4207D83F01DA"
-	    roles      	(list role_list
-		(object Role "field"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isUnsettable"
-			    value      	TRUE))
-		    quid       	"4207D8400290"
-		    documentation 	"If this is set, then this property is a field and not a getter/setter property. This is an extension that the Visual Editor uses to the BeanInfo model."
-		    label      	"field"
-		    supplier   	"Logical View::java::Field"
-		    quidu      	"3654AF8F0280"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$35"
-		    quid       	"4207D8400292"
-		    supplier   	"Logical View::beaninfo::PropertyDecorator"
-		    quidu      	"3A79DA68010E"))))
-    logical_presentations 	(list unit_reference_list
-	(object ClassDiagram "Main"
-	    quid       	"3A799AC8038E"
-	    title      	"Main"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	94
-	    items      	(list diagram_item_list
-		(object NoteView @1
-		    location   	(3232, 1712)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@1
-			location   	(2950, 1624)
-			fill_color 	13434879
-			nlines     	3
-			max_width  	528
-			label      	"ListenerMethods will be decorated with MethodDecorators.")
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	588
-		    height     	188)
-		(object NoteView @2
-		    location   	(3392, 2784)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@2
-			location   	(3076, 2568)
-			fill_color 	13434879
-			nlines     	8
-			max_width  	596
-			label      	
-|MethodProxies will be in the eBehaviors setting for any methods that are in the JavaClass methods setting so that they are not duplicated.
-|
-|MethodProxies would also have MethodDecorators.
-			)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	656
-		    height     	444)
-		(object ClassView "Class" "Logical View::java::JavaEvent" @3
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1248, 2688)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@3
-			location   	(1114, 2614)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	268
-			justify    	0
-			label      	"JavaEvent")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777088
-		    quidu      	"3C62FAF103C8"
-		    width      	286
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::BeanEvent" @4
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1232, 2992)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@4
-			location   	(1096, 2941)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	272
-			justify    	0
-			label      	"BeanEvent")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3CB09CA90212"
-		    width      	290
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @5
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3CB09CB6038D"
-		    client     	@4
-		    supplier   	@3
-		    line_style 	0)
-		(object NoteView @6
-		    location   	(1856, 2944)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@6
-			location   	(1561, 2815)
-			fill_color 	13434879
-			nlines     	5
-			max_width  	555
-			label      	"The BeanEvent will be under the JavaClass' events and allEvents feature. Each BeanEvent will be decorated by an EventSetDecorator.")
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	615
-		    height     	270)
-		(object ClassView "Class" "Logical View::ecore::EAnnotation" @7
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(1056, 128)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@7
-			location   	(906, 54)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	300
-			justify    	0
-			label      	"EAnnotation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"3D98A1C701AB"
-		    width      	318
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::ecore::EOperation" @8
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2848, 2272)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@8
-			location   	(2702, 2198)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	292
-			justify    	0
-			label      	"EOperation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"3904DAA200A0"
-		    width      	310
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::FeatureAttributeMapEntry" @9
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2224, 176)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@9
-			location   	(1887, 92)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	674
-			justify    	0
-			label      	"FeatureAttributeMapEntry")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@9
-			location   	(1887, 42)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	674
-			justify    	0
-			label      	"<<MapEntry>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"404CC85501F5"
-		    compartment 	(object Compartment
-			Parent_View 	@9
-			location   	(1887, 153)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	3
-			max_width  	581)
-		    width      	692
-		    height     	292
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::FeatureDecorator" @10
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(1072, 656)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@10
-			location   	(665, 325)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	814
-			justify    	0
-			label      	"FeatureDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A799B3E01E9"
-		    compartment 	(object Compartment
-			Parent_View 	@10
-			location   	(665, 386)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	12
-			max_width  	700)
-		    width      	832
-		    height     	686
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @11
-		    location   	(1072, 1105)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@10
-		    vertices   	(list Points
-			(1072, 1105)
-			(1072, 999)))
-		(object InheritView "" @12
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3DFA185900DC"
-		    client     	@10
-		    supplier   	@7
-		    line_style 	0)
-		(object AssociationViewNew "$UNNAMED$0" @13
-		    location   	(1682, 401)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79CF6C0378"
-		    roleview_list 	(list RoleViews
-			(object RoleView "attributes" @14
-			    Parent_View 	@13
-			    location   	(626, -63)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @15
-				Parent_View 	@14
-				location   	(1747, 309)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	207
-				justify    	0
-				label      	"+attributes"
-				pctDist    	0.457012
-				height     	62
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79CF6E00BE"
-			    client     	@13
-			    supplier   	@9
-			    line_style 	0
-			    label      	(object SegLabel @16
-				Parent_View 	@14
-				location   	(1812, 396)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.584653
-				height     	45
-				orientation 	1))
-			(object RoleView "$UNNAMED$1" @17
-			    Parent_View 	@13
-			    location   	(626, -63)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79CF6E00C8"
-			    client     	@13
-			    supplier   	@10
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::beaninfo::FeatureAttributeValue" @18
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(3456, 176)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@18
-			location   	(2683, 117)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1546
-			justify    	0
-			label      	"FeatureAttributeValue")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@18
-			location   	(2683, 67)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	1546
-			justify    	0
-			label      	"<<datatype>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"41E582F800BB"
-		    compartment 	(object Compartment
-			Parent_View 	@18
-			location   	(2683, 178)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	1493)
-		    width      	1564
-		    height     	242
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::ImplicitItem" @19
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2288, 656)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@19
-			location   	(1815, 547)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	946
-			justify    	0
-			label      	"ImplicitItem")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@19
-			location   	(1815, 497)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	946
-			justify    	0
-			label      	"<<enumeration>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	12615935
-		    quidu      	"41E59E5D0296"
-		    compartment 	(object Compartment
-			Parent_View 	@19
-			location   	(1815, 608)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	4
-			max_width  	812)
-		    width      	964
-		    height     	342
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaParameter" @20
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(4304, 1792)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@20
-			location   	(4125, 1718)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	358
-			justify    	0
-			label      	"JavaParameter")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777088
-		    quidu      	"3654AD780280"
-		    width      	376
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::ParameterDecorator" @21
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(4864, 1360)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@21
-			location   	(4631, 1279)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	466
-			justify    	0
-			label      	"ParameterDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A79D9C20304"
-		    compartment 	(object Compartment
-			Parent_View 	@21
-			location   	(4631, 1340)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	294)
-		    width      	484
-		    height     	186
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "$UNNAMED$26" @22
-		    location   	(4578, 1579)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3C9A6EDD02C2"
-		    roleview_list 	(list RoleViews
-			(object RoleView "parameter" @23
-			    Parent_View 	@22
-			    location   	(1666, -21)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @24
-				Parent_View 	@23
-				location   	(4540, 1659)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	215
-				justify    	0
-				label      	"+parameter"
-				pctDist    	0.386598
-				height     	41
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3C9A6EDE01FB"
-			    client     	@22
-			    supplier   	@20
-			    line_style 	0
-			    label      	(object SegLabel @25
-				Parent_View 	@23
-				location   	(4480, 1588)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.412371
-				height     	54
-				orientation 	1))
-			(object RoleView "$UNNAMED$27" @26
-			    Parent_View 	@22
-			    location   	(1666, -21)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3C9A6EDE0205"
-			    client     	@22
-			    supplier   	@21
-			    line_style 	0)))
-		(object InheritView "" @27
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DEBB01C4"
-		    client     	@21
-		    supplier   	@10
-		    line_style 	3
-		    origin_attachment 	(4658, 1267)
-		    terminal_attachment 	(4658, 1105)
-		    drawSupplier 	@11)
-		(object ClassView "Class" "Logical View::beaninfo::MethodDecorator" @28
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(3712, 1360)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@28
-			location   	(3362, 1279)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	700
-			justify    	0
-			label      	"MethodDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A79D35E0027"
-		    compartment 	(object Compartment
-			Parent_View 	@28
-			location   	(3362, 1340)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	594)
-		    width      	718
-		    height     	186
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @29
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DEA603E1"
-		    client     	@28
-		    supplier   	@10
-		    line_style 	3
-		    origin_attachment 	(3694, 1267)
-		    terminal_attachment 	(3694, 1105)
-		    drawSupplier 	@11)
-		(object AssociationViewNew "$UNNAMED$12" @30
-		    location   	(4314, 1490)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DA1A02F7"
-		    roleview_list 	(list RoleViews
-			(object RoleView "parameterDescriptors" @31
-			    Parent_View 	@30
-			    location   	(2842, 594)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @32
-				Parent_View 	@31
-				location   	(4389, 1427)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	427
-				justify    	0
-				label      	"+parameterDescriptors"
-				pctDist    	0.308262
-				height     	69
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DA1C0231"
-			    client     	@30
-			    supplier   	@21
-			    vertices   	(list Points
-				(4314, 1490)
-				(4373, 1503)
-				(4621, 1429))
-			    line_style 	0
-			    label      	(object SegLabel @33
-				Parent_View 	@31
-				location   	(4555, 1491)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.745977
-				height     	41
-				orientation 	1))
-			(object RoleView "$UNNAMED$13" @34
-			    Parent_View 	@30
-			    location   	(2842, 594)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DA1C0232"
-			    client     	@30
-			    supplier   	@28
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$28" @35
-		    location   	(4385, 1273)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"41F016E7002E"
-		    roleview_list 	(list RoleViews
-			(object RoleView "serParmDesc" @36
-			    Parent_View 	@35
-			    location   	(1265, -71)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @37
-				Parent_View 	@36
-				location   	(4534, 1252)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	285
-				justify    	0
-				label      	"-serParmDesc"
-				pctDist    	0.595893
-				height     	48
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"41F016E802A7"
-			    client     	@35
-			    supplier   	@21
-			    line_style 	0
-			    label      	(object SegLabel @38
-				Parent_View 	@36
-				location   	(4590, 1364)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.904386
-				height     	54
-				orientation 	1))
-			(object RoleView "$UNNAMED$29" @39
-			    Parent_View 	@35
-			    location   	(1265, -71)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"41F016E802B1"
-			    client     	@35
-			    supplier   	@28
-			    vertices   	(list Points
-				(4385, 1273)
-				(4326, 1263)
-				(4071, 1302))
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::java::Method" @40
-		    ShowCompartmentStereotypes 	TRUE
-		    SuppressAttribute 	TRUE
-		    IncludeAttribute 	TRUE
-		    location   	(2592, 3264)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@40
-			location   	(2492, 3190)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	200
-			justify    	0
-			label      	"Method")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"3654AE910271"
-		    width      	218
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::MethodProxy" @41
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2560, 2768)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@41
-			location   	(2398, 2717)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	324
-			justify    	0
-			label      	"MethodProxy")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A8984C901C3"
-		    width      	342
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AttachView "" @42
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@2
-		    supplier   	@41
-		    line_style 	0)
-		(object AssociationViewNew "$UNNAMED$24" @43
-		    location   	(2575, 3004)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A89865B01D5"
-		    roleview_list 	(list RoleViews
-			(object RoleView "method" @44
-			    Parent_View 	@43
-			    location   	(271, 1084)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @45
-				Parent_View 	@44
-				location   	(2539, 3072)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	162
-				justify    	0
-				label      	"+method"
-				pctDist    	0.376068
-				height     	41
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A89865C01AE"
-			    client     	@43
-			    supplier   	@40
-			    line_style 	0
-			    label      	(object SegLabel @46
-				Parent_View 	@44
-				location   	(2639, 3158)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "$UNNAMED$25" @47
-			    Parent_View 	@43
-			    location   	(271, 1084)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A89865C01CC"
-			    client     	@43
-			    supplier   	@41
-			    line_style 	0)))
-		(object InheritView "" @48
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3DFA19B600DE"
-		    client     	@41
-		    supplier   	@8
-		    line_style 	0)
-		(object AttachView "" @49
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@6
-		    supplier   	@4
-		    line_style 	0)
-		(object ClassView "Class" "Logical View::beaninfo::IndexedPropertyDecorator" @50
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(752, 2288)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@50
-			location   	(460, 2237)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	584
-			justify    	0
-			label      	"IndexedPropertyDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A79DC450309"
-		    width      	602
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::BeanDecorator" @51
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(512, 1456)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@51
-			location   	(7, 1150)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1010
-			justify    	0
-			label      	"BeanDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A79D0DF02D1"
-		    compartment 	(object Compartment
-			Parent_View 	@51
-			location   	(7, 1211)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	11
-			max_width  	868)
-		    width      	1028
-		    height     	636
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @52
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DE8E007F"
-		    client     	@51
-		    supplier   	@10
-		    line_style 	3
-		    origin_attachment 	(381, 1137)
-		    terminal_attachment 	(381, 1105)
-		    drawSupplier 	@11)
-		(object ClassView "Class" "Logical View::beaninfo::EventSetDecorator" @53
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2848, 1424)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@53
-			location   	(2395, 1268)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	906
-			justify    	0
-			label      	"EventSetDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A79D1D2004F"
-		    compartment 	(object Compartment
-			Parent_View 	@53
-			location   	(2395, 1329)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	4
-			max_width  	778)
-		    width      	924
-		    height     	336
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @54
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DEA200EC"
-		    client     	@53
-		    supplier   	@10
-		    line_style 	3
-		    origin_attachment 	(2831, 1255)
-		    terminal_attachment 	(2831, 1105)
-		    drawSupplier 	@11)
-		(object AssociationViewNew "$UNNAMED$6" @55
-		    location   	(2692, 2148)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79D3E10364"
-		    roleview_list 	(list RoleViews
-			(object RoleView "listenerMethods" @56
-			    Parent_View 	@55
-			    location   	(1828, 1252)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @57
-				Parent_View 	@56
-				location   	(2580, 2585)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	324
-				justify    	0
-				label      	"+listenerMethods"
-				pctDist    	0.790503
-				height     	19
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D3E6007D"
-			    client     	@55
-			    supplier   	@41
-			    line_style 	0
-			    label      	(object SegLabel @58
-				Parent_View 	@56
-				location   	(2598, 2522)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1..n"
-				pctDist    	0.676961
-				height     	14
-				orientation 	1))
-			(object RoleView "$UNNAMED$7" @59
-			    Parent_View 	@55
-			    location   	(1828, 1252)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D3E60091"
-			    client     	@55
-			    supplier   	@53
-			    line_style 	0)))
-		(object AttachView "" @60
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@1
-		    supplier   	@55
-		    line_style 	0)
-		(object AssociationViewNew "$UNNAMED$32" @61
-		    location   	(2525, 2221)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"41F1278A01A5"
-		    roleview_list 	(list RoleViews
-			(object RoleView "serListMthd" @62
-			    Parent_View 	@61
-			    location   	(269, 813)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @63
-				Parent_View 	@62
-				location   	(2296, 2688)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	229
-				justify    	0
-				label      	"-serListMthd"
-				pctDist    	0.765012
-				height     	39
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"41F1278B021F"
-			    client     	@61
-			    supplier   	@41
-			    vertices   	(list Points
-				(2525, 2221)
-				(2303, 2771)
-				(2388, 2769))
-			    line_style 	0
-			    label      	(object SegLabel @64
-				Parent_View 	@62
-				location   	(2239, 2587)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1..n"
-				pctDist    	0.657692
-				height     	129
-				orientation 	1))
-			(object RoleView "$UNNAMED$33" @65
-			    Parent_View 	@61
-			    location   	(269, 813)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"41F1278B0229"
-			    client     	@61
-			    supplier   	@53
-			    line_style 	0)))
-		(object AttachView "" @66
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@6
-		    supplier   	@53
-		    vertices   	(list Points
-			(1878, 2808)
-			(2016, 2021)
-			(2612, 1592))
-		    line_style 	0)
-		(object ClassView "Class" "Logical View::java::Method" @67
-		    ShowCompartmentStereotypes 	TRUE
-		    SuppressAttribute 	TRUE
-		    location   	(1664, 2096)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@67
-			location   	(1564, 2022)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	200
-			justify    	0
-			label      	"Method")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"3654AE910271"
-		    width      	218
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "$UNNAMED$20" @68
-		    location   	(1315, 2289)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DE34036F"
-		    roleview_list 	(list RoleViews
-			(object RoleView "indexedReadMethod" @69
-			    Parent_View 	@68
-			    location   	(563, 401)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @70
-				Parent_View 	@69
-				location   	(1421, 2275)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	404
-				justify    	0
-				label      	"+indexedReadMethod"
-				pctDist    	0.385248
-				height     	14
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DE3503CA"
-			    client     	@68
-			    supplier   	@67
-			    vertices   	(list Points
-				(1315, 2289)
-				(1375, 2289)
-				(1554, 2168))
-			    line_style 	0
-			    label      	(object SegLabel @71
-				Parent_View 	@69
-				location   	(1249, 2238)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	-0.240775
-				height     	52
-				orientation 	0))
-			(object RoleView "$UNNAMED$21" @72
-			    Parent_View 	@68
-			    location   	(563, 401)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DE3503DE"
-			    client     	@68
-			    supplier   	@50
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$22" @73
-		    location   	(1442, 2361)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DE540180"
-		    roleview_list 	(list RoleViews
-			(object RoleView "indexedWriteMethod" @74
-			    Parent_View 	@73
-			    location   	(690, 473)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @75
-				Parent_View 	@74
-				location   	(1597, 2374)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	409
-				justify    	0
-				label      	"+indexedWriteMethod"
-				pctDist    	0.501177
-				height     	37
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DE5503D0"
-			    client     	@73
-			    supplier   	@67
-			    vertices   	(list Points
-				(1442, 2361)
-				(1632, 2382)
-				(1654, 2182))
-			    line_style 	0
-			    label      	(object SegLabel @76
-				Parent_View 	@74
-				location   	(1639, 2306)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.681972
-				height     	2
-				orientation 	0))
-			(object RoleView "$UNNAMED$23" @77
-			    Parent_View 	@73
-			    location   	(690, 473)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DE5503E4"
-			    client     	@73
-			    supplier   	@50
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$4" @78
-		    location   	(1898, 1691)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79D3080128"
-		    roleview_list 	(list RoleViews
-			(object RoleView "addListenerMethod" @79
-			    Parent_View 	@78
-			    location   	(1034, 795)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @80
-				Parent_View 	@79
-				location   	(1561, 1824)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	385
-				justify    	0
-				label      	"+addListenerMethod"
-				pctDist    	0.627386
-				height     	90
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D3090346"
-			    client     	@78
-			    supplier   	@67
-			    vertices   	(list Points
-				(1898, 1691)
-				(1647, 1763)
-				(1658, 2009))
-			    line_style 	0
-			    label      	(object SegLabel @81
-				Parent_View 	@79
-				location   	(1699, 1853)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.694068
-				height     	48
-				orientation 	0))
-			(object RoleView "$UNNAMED$5" @82
-			    Parent_View 	@78
-			    location   	(1034, 795)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D309035A"
-			    client     	@78
-			    supplier   	@53
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$10" @83
-		    location   	(2162, 1812)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79D4DF020B"
-		    roleview_list 	(list RoleViews
-			(object RoleView "removeListenerMethod" @84
-			    Parent_View 	@83
-			    location   	(1298, 916)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @85
-				Parent_View 	@84
-				location   	(2115, 1846)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	448
-				justify    	0
-				label      	"+removeListenerMethod"
-				pctDist    	0.129058
-				height     	6
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D4E10395"
-			    client     	@83
-			    supplier   	@67
-			    line_style 	0
-			    label      	(object SegLabel @86
-				Parent_View 	@84
-				location   	(1839, 2058)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "$UNNAMED$11" @87
-			    Parent_View 	@83
-			    location   	(1298, 916)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D4E103A9"
-			    client     	@83
-			    supplier   	@53
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::java::JavaClass" @88
-		    ShowCompartmentStereotypes 	TRUE
-		    SuppressAttribute 	TRUE
-		    location   	(240, 2192)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@88
-			location   	(106, 2118)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	268
-			justify    	0
-			label      	"JavaClass")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"36549FCC00FA"
-		    width      	286
-		    height     	172
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "$UNNAMED$2" @89
-		    location   	(332, 1939)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79D1350248"
-		    roleview_list 	(list RoleViews
-			(object RoleView "customizerClass" @90
-			    Parent_View 	@89
-			    location   	(92, 1043)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @91
-				Parent_View 	@90
-				location   	(298, 2044)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	328
-				justify    	0
-				label      	"+customizerClass"
-				pctDist    	0.631674
-				height     	4
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D13601D2"
-			    client     	@89
-			    supplier   	@88
-			    line_style 	0
-			    label      	(object SegLabel @92
-				Parent_View 	@90
-				location   	(326, 1989)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.284188
-				height     	12
-				orientation 	0))
-			(object RoleView "$UNNAMED$3" @93
-			    Parent_View 	@89
-			    location   	(92, 1043)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D13601E6"
-			    client     	@89
-			    supplier   	@51
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$8" @94
-		    location   	(1384, 1854)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79D4A80158"
-		    roleview_list 	(list RoleViews
-			(object RoleView "listenerType" @95
-			    Parent_View 	@94
-			    location   	(520, 958)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @96
-				Parent_View 	@95
-				location   	(782, 2066)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	259
-				justify    	0
-				label      	"+listenerType"
-				pctDist    	0.610677
-				height     	33
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D4AA038B"
-			    client     	@94
-			    supplier   	@88
-			    line_style 	0
-			    label      	(object SegLabel @97
-				Parent_View 	@95
-				location   	(977, 2061)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.429590
-				height     	83
-				orientation 	0))
-			(object RoleView "$UNNAMED$9" @98
-			    Parent_View 	@94
-			    location   	(520, 958)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79D4AA03B4"
-			    client     	@94
-			    supplier   	@53
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$30" @99
-		    location   	(1392, 1913)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"41F11E710387"
-		    roleview_list 	(list RoleViews
-			(object RoleView "eventAdapterClass" @100
-			    Parent_View 	@99
-			    location   	(-864, 505)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @101
-				Parent_View 	@100
-				location   	(771, 2132)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	367
-				justify    	0
-				label      	"+eventAdapterClass"
-				pctDist    	0.629702
-				height     	10
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"41F11E730249"
-			    client     	@99
-			    supplier   	@88
-			    vertices   	(list Points
-				(1392, 1913)
-				(766, 2124)
-				(383, 2172))
-			    line_style 	0
-			    label      	(object SegLabel @102
-				Parent_View 	@100
-				location   	(494, 2197)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.898257
-				height     	38
-				orientation 	0))
-			(object RoleView "$UNNAMED$31" @103
-			    Parent_View 	@99
-			    location   	(-864, 505)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"41F11E73025D"
-			    client     	@99
-			    supplier   	@53
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::java::Field" @104
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(816, 2672)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@104
-			location   	(720, 2597)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	192
-			justify    	0
-			label      	"Field")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777088
-		    quidu      	"3654AF8F0280"
-		    width      	210
-		    height     	174
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::beaninfo::PropertyDecorator" @105
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(1808, 1456)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@105
-			location   	(1316, 1200)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	984
-			justify    	0
-			label      	"PropertyDecorator")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A79DA68010E"
-		    compartment 	(object Compartment
-			Parent_View 	@105
-			location   	(1316, 1261)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	9
-			max_width  	838)
-		    width      	1002
-		    height     	536
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @106
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DE840388"
-		    client     	@50
-		    supplier   	@105
-		    line_style 	0)
-		(object InheritView "" @107
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DE9702BD"
-		    client     	@105
-		    supplier   	@10
-		    line_style 	3
-		    origin_attachment 	(1772, 1188)
-		    terminal_attachment 	(1772, 1105)
-		    drawSupplier 	@11)
-		(object AssociationViewNew "$UNNAMED$16" @108
-		    location   	(1003, 1968)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DBBD0000"
-		    roleview_list 	(list RoleViews
-			(object RoleView "readMethod" @109
-			    Parent_View 	@108
-			    location   	(235, 1072)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @110
-				Parent_View 	@109
-				location   	(1308, 2033)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	254
-				justify    	0
-				label      	"+readMethod"
-				pctDist    	0.553714
-				height     	7
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DBBF0071"
-			    client     	@108
-			    supplier   	@67
-			    line_style 	0
-			    label      	(object SegLabel @111
-				Parent_View 	@109
-				location   	(1471, 2131)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.873365
-				height     	72
-				orientation 	1))
-			(object RoleView "$UNNAMED$17" @112
-			    Parent_View 	@108
-			    location   	(235, 1072)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DBBF0085"
-			    client     	@108
-			    supplier   	@105
-			    vertices   	(list Points
-				(1003, 1968)
-				(909, 1950)
-				(1316, 1724))
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$18" @113
-		    location   	(1035, 2106)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DBDF02D0"
-		    roleview_list 	(list RoleViews
-			(object RoleView "writeMethod" @114
-			    Parent_View 	@113
-			    location   	(267, 1210)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @115
-				Parent_View 	@114
-				location   	(1325, 2090)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	254
-				justify    	0
-				label      	"+writeMethod"
-				pctDist    	0.560930
-				height     	12
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DBE101F7"
-			    client     	@113
-			    supplier   	@67
-			    line_style 	0
-			    label      	(object SegLabel @116
-				Parent_View 	@114
-				location   	(1503, 2056)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.901632
-				height     	43
-				orientation 	0))
-			(object RoleView "$UNNAMED$19" @117
-			    Parent_View 	@113
-			    location   	(267, 1210)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DBE1020B"
-			    client     	@113
-			    supplier   	@105
-			    vertices   	(list Points
-				(1035, 2106)
-				(975, 2107)
-				(1462, 1724))
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$14" @118
-		    location   	(844, 1907)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A79DB0B0339"
-		    roleview_list 	(list RoleViews
-			(object RoleView "propertyEditorClass" @119
-			    Parent_View 	@118
-			    location   	(76, 1011)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @120
-				Parent_View 	@119
-				location   	(778, 1967)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	392
-				justify    	0
-				label      	"+propertyEditorClass"
-				pctDist    	0.166430
-				height     	26
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DB0E013F"
-			    client     	@118
-			    supplier   	@88
-			    line_style 	0
-			    label      	(object SegLabel @121
-				Parent_View 	@119
-				location   	(1123, 1915)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	-0.490182
-				height     	126
-				orientation 	0))
-			(object RoleView "$UNNAMED$15" @122
-			    Parent_View 	@118
-			    location   	(76, 1011)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3A79DB0E0171"
-			    client     	@118
-			    supplier   	@105
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$34" @123
-		    location   	(1296, 2186)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"4207D83F01DA"
-		    roleview_list 	(list RoleViews
-			(object RoleView "field" @124
-			    Parent_View 	@123
-			    location   	(-112, 778)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @125
-				Parent_View 	@124
-				location   	(938, 2513)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	112
-				justify    	0
-				label      	"+field"
-				pctDist    	0.892515
-				height     	57
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"4207D8400290"
-			    client     	@123
-			    supplier   	@104
-			    vertices   	(list Points
-				(1296, 2186)
-				(1103, 2463)
-				(921, 2593))
-			    line_style 	0
-			    label      	(object SegLabel @126
-				Parent_View 	@124
-				location   	(1046, 2557)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.780986
-				height     	43
-				orientation 	0))
-			(object RoleView "$UNNAMED$35" @127
-			    Parent_View 	@123
-			    location   	(-112, 778)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"4207D8400292"
-			    client     	@123
-			    supplier   	@105
-			    line_style 	0)))))))
diff --git a/plugins/org.eclipse.jem.beaninfo/rose/introspect.mdl b/plugins/org.eclipse.jem.beaninfo/rose/introspect.mdl
deleted file mode 100644
index c7ca9ef..0000000
--- a/plugins/org.eclipse.jem.beaninfo/rose/introspect.mdl
+++ /dev/null
@@ -1,556 +0,0 @@
-
-(object Petal
-    version    	47
-    _written   	"Rose 8.0.0303.1400"
-    charSet    	0)
-
-(object Design "Logical View"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    attributes 	(list Attribute_Set
-	(object Attribute
-	    tool       	"Java"
-	    name       	"IDE"
-	    value      	"Internal Editor")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName3"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText3"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply3"
-	    value      	""))
-    quid       	"3A79EBA50331"
-    defaults   	(object defaults
-	rightMargin 	0.250000
-	leftMargin 	0.250000
-	topMargin  	0.250000
-	bottomMargin 	0.500000
-	pageOverlap 	0.250000
-	clipIconLabels 	TRUE
-	autoResize 	TRUE
-	snapToGrid 	TRUE
-	gridX      	16
-	gridY      	16
-	defaultFont 	(object Font
-	    size       	10
-	    face       	"Arial"
-	    bold       	FALSE
-	    italics    	FALSE
-	    underline  	FALSE
-	    strike     	FALSE
-	    color      	0
-	    default_color 	TRUE)
-	showMessageNum 	1
-	showClassOfObject 	TRUE
-	notation   	"Unified")
-    root_usecase_package 	(object Class_Category "Use Case View"
-	quid       	"3A7999AD0297"
-	exportControl 	"Public"
-	global     	TRUE
-	logical_models 	(list unit_reference_list)
-	logical_presentations 	(list unit_reference_list
-	    (object UseCaseDiagram "Main"
-		quid       	"3A7999B702F6"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    root_category 	(object Class_Category "Logical View"
-	quid       	"3A7999AD028E"
-	exportControl 	"Public"
-	global     	TRUE
-	subsystem  	"Component View"
-	quidu      	"3A7999AD02A1"
-	logical_models 	(list unit_reference_list
-	    (object Class_Category "ecore"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.emf.ecore\\model\\org.eclipse.emf.Ecore.cat"
-		quid       	"39A5ED04004E")
-	    (object Class_Category "java"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.jem\\rose\\edocjava2.cat"
-		quid       	"36549F2C004E")
-	    (object Class_Category "beaninfo"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.jem.beaninfo\\rose\\beaninfo.cat"
-		quid       	"3A799ABB0353"))
-	logical_presentations 	(list unit_reference_list
-	    (object ClassDiagram "Main"
-		quid       	"3A7999B70309"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list
-		    (object CategoryView "Logical View::beaninfo" @1
-			location   	(272, 224)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@1
-			    location   	(128, 140)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"beaninfo")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"3A799ABB0353"
-			width      	300
-			height     	180)))
-	    (object ClassDiagram "Dependencies (Don't edit)"
-		quid       	"3B869C9102E4"
-		title      	"Dependencies (Don't edit)"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list
-		    (object CategoryView "Logical View::ecore" @2
-			location   	(256, 240)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@2
-			    location   	(112, 156)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"ecore")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	16776960
-			quidu      	"39A5ED04004E"
-			width      	300
-			height     	180)
-		    (object CategoryView "Logical View::java" @3
-			location   	(896, 256)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@3
-			    location   	(749, 222)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	294
-			    justify    	0
-			    label      	"java")
-			stereotype 	(object ItemLabel
-			    Parent_View 	@3
-			    location   	(749, 172)
-			    fill_color 	13434879
-			    anchor     	10
-			    nlines     	1
-			    max_width  	294
-			    justify    	0
-			    label      	"<<metamodel>>")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	16776960
-			quidu      	"36549F2C004E"
-			width      	306
-			height     	180)
-		    (object NoteView @4
-			location   	(688, 688)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@4
-			    location   	(280, 532)
-			    fill_color 	13434879
-			    nlines     	7
-			    max_width  	780
-			    label      	"These are packages (cat files) that this model depends on. They must not be edited in here. They are only be edited by the model that owns them.")
-			line_color 	3342489
-			fill_color 	16744703
-			width      	840
-			height     	325)))))
-    root_subsystem 	(object SubSystem "Component View"
-	quid       	"3A7999AD02A1"
-	physical_models 	(list unit_reference_list)
-	physical_presentations 	(list unit_reference_list
-	    (object Module_Diagram "Main"
-		quid       	"3A7999B702F5"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    process_structure 	(object Processes
-	quid       	"3A7999AD02A2"
-	ProcsNDevs 	(list
-	    (object Process_Diagram "Deployment View"
-		quid       	"3A7999AD02A4"
-		title      	"Deployment View"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    properties 	(object Properties
-	attributes 	(list Attribute_Set
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"propertyId"
-		value      	"809135969")
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"classifierName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"constraints"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlContentKind"
-			value      	("ContentKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"ContentKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Empty"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Mixed"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"ElementOnly"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"operationName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"attributeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isID"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"visibility"
-			value      	("VisibilityKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"VisibilityKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"None"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only unsettable"
-				value      	4)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write unsettable"
-				value      	5)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlNamespace"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlFeatureKind"
-			value      	("FeatureKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"FeatureKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Attribute"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Element"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"referenceName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isResolveProxies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"visibility"
-			value      	("VisibilityKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"VisibilityKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"None"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only unsettable"
-				value      	4)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write unsettable"
-				value      	5)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlNamespace"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlFeatureKind"
-			value      	("FeatureKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"FeatureKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Attribute"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Element"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	""))))
-	quid       	"3A7999AD02A3"))
diff --git a/plugins/org.eclipse.jem.beaninfo/schema/registrations.exsd b/plugins/org.eclipse.jem.beaninfo/schema/registrations.exsd
deleted file mode 100644
index 6a90380..0000000
--- a/plugins/org.eclipse.jem.beaninfo/schema/registrations.exsd
+++ /dev/null
@@ -1,258 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jem.beaninfo">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jem.beaninfo" id="registrations" name="BeanInfo Extension Registrations"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to register contributors, beaninfo, and overrides for BeanInfo contributions.
-&lt;p&gt;An important concept is visibility of a container, plugin, or project to the top-level project. The top-level project is the project being introspected. For a container, plugin, or project to be visible to that project, the container, plugin, or project must be in the classpath of the top-level project, or it must be exported from a visible project or plugin. Once a non-visible project/plugin is reached, any projects, containers, or plugins that it may contain are not considered to be visible.
-&lt;p&gt;The registrations are identified with the container id and/or plugin id. If that container or plugin is visible, then that registration will be processed for the top-level project. If the container/plugin is found more than once in the build path of the top-level project, it will only be processed once.
-&lt;p&gt;There are three forms of registrations.
-&lt;ul&gt;
-&lt;li&gt;BeanInfo registrations. These supply standard BeanInfo and overrides.
-&lt;li&gt;&lt;samp&gt;IClasspathContainer&lt;/samp&gt; that implements &lt;samp&gt;IBeanInfoContributor&lt;/samp&gt;.
-&lt;li&gt;An explicit contributor that implements &lt;samp&gt;IBeanInfoContributor&lt;/samp&gt;.
-&lt;/ul&gt;
-&lt;p&gt;It runs through the visible BeanInfo registrations. 
-&lt;p&gt;
-The IClasspathContainer registration isn&apos;t specified as part of this extension point. For all visible containers, if the classpath container (from JDT) also implements IBeanInfoContributor, then it will be called to contribute to the BeanInfo.
-&lt;p&gt;Then it runs through the visible explicit contributors. Note that if the explicit contributor also implements &lt;samp&gt;org.eclipse.jem.internal.proxy.core.IConfigurationContributor&lt;/samp&gt; it will also be called for proxy contributions. This allows for special setup required by any contributed BeanInfo for the launched proxy registry. This shouldn&apos;t normally be necessary because normal classpath updates to include the BeanInfo jar will be done by the IBeanInfoContributor itself through the BeanInfo registration callback.
-&lt;p&gt;The order of processing for the overrides will be to first run through the specified overrides (through Beaninfo registrations). Then it runs through the visible containers that implement IBeanInfoContributor, and then finally it runs through the explicit IBeanInfoContributors. This order is chosen because the overrides files are not dynamic so they need to be applied in a consistent way. The contributors are dynamic and can handle change.
-&lt;p&gt;The only order guarantee is that contributions from this extension point will be processed in plugin order of where the extension was declared. For example if there was an extension declared in plugin A and in plugin B, and plugin B requires plugin A, then the extensions declarations in plugin A will be processed before the extension declarations in plugin B.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="registration" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="contributor" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="registration">
-      <annotation>
-         <documentation>
-            This is a registration for a container or plugin. It supplies the BeanInfo and the overrides.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="beaninfo" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="override" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="container" type="string">
-            <annotation>
-               <documentation>
-                  contributor is for a container. The value is the container id (e.g. &lt;b&gt;&quot;JRE_CONTAINER&quot;&lt;/b&gt;). This will match &quot;/JRE_CONTAINER&quot; or &quot;/JRE_CONTAINER/...&quot;. Or &lt;b&gt;&quot;JRE_CONTAINER/XYZ&quot;&lt;/b&gt; would match &quot;/JRE_CONTAINER/XYZ/...&quot;.
-&lt;p&gt;
-You can also use a regular expression. An expression such as &lt;b&gt;&quot;SWT_CONTAINER/.*/JFACE&quot;&lt;/b&gt; will match &quot;/SWT_CONTAINER/PDE/JFACE&quot; but will not match &quot;/SWT_CONTAINER&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="plugin" type="string">
-            <annotation>
-               <documentation>
-                  contributor is for a plugin. The value is the plugin id (e.g. &quot;org.eclipse.swt&quot;).
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="contributor">
-      <annotation>
-         <documentation>
-            This is a contributor for the visible container/plugin defined by container and plugin attributes.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="container" type="string">
-            <annotation>
-               <documentation>
-                  contributor is for a container. The value is the container id (e.g. &lt;b&gt;&quot;JRE_CONTAINER&quot;&lt;/b&gt;). This will match &quot;/JRE_CONTAINER&quot; or &quot;/JRE_CONTAINER/...&quot;. Or &lt;b&gt;&quot;JRE_CONTAINER/XYZ&quot;&lt;/b&gt; would match &quot;/JRE_CONTAINER/XYZ/...&quot;.
-&lt;p&gt;
-You can also use a regular expression. An expression such as &lt;b&gt;&quot;SWT_CONTAINER/.*/JFACE&quot;&lt;/b&gt; will match &quot;/SWT_CONTAINER/PDE/JFACE&quot; but will not match &quot;/SWT_CONTAINER&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="plugin" type="string">
-            <annotation>
-               <documentation>
-                  contributor is for a plugin. The value is the plugin id (e.g. &quot;org.eclipse.swt&quot;).
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the class that implements this contributor. The class must implement IBeanInfoContributor.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.jem.internal.beaninfo.core.IBeanInfoContributor"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="beaninfo">
-      <annotation>
-         <documentation>
-            Provide a BeanInfo jar from this or some other plugin, and provide search path packages.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="searchpath" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="path" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This is the path to the BeanInfo jar from within this or some other plugin. If it is within this plugin, there should be no leading &apos;/&apos;. There can be subfolders though, e.g. &lt;samp&gt;xyz/qxr.jar&lt;/samp&gt;. If it is within another plugin, then it must be fully-qualified with leading &apos;/&apos; followed by plugin id, followed by a &apos;/&apos; and then the path to the jar relative to that plugin, e.g. &lt;samp&gt;/org.xyz/qxr/ddd.jar&lt;/samp&gt;.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="searchpath">
-      <annotation>
-         <documentation>
-            This is a search path. It gives the package to add to the search path for BeanInfo.
-It refers to packages within the BeanInfo jar contributed by the &lt;samp&gt;beaninfo&lt;/samp&gt; element that it is found within.
-There really should be at least one search path. The only way this jar could contribute BeanInfo and not need something added to the search path is if the BeanInfos are in the same package as the bean itself. This is not a recommended way of supplying BeanInfo.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="package" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This is the java package to search into for BeanInfo. If there are more than one search paths in this &lt;samp&gt;beaninfo&lt;/samp&gt; element, then they will be searched in the order found in the element.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="override">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="package"/>
-         </appInfo>
-         <documentation>
-            This describes an override file for BeanInfo. An override file is an XMI file that is read when a class is first introspected. It happens before the actual introspection. It allows overrides to the Java EMF model class (&lt;samp&gt;JavaClass&lt;/samp&gt;) that can be done through standard BeanInfo. These are annotations that are specific to the Visual Editor implementation in Eclipse. The annotations have no meaning to the standard BeanInfo specification so they are supplied here instead. They provide a much enriched experience in the Visual Editor by providing classes that run in the editor.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="package" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This is the name of a package or a package fragment. When this package or package fragment matches the package or fragment of a class being introspected, the specified override file from the given path will be applied. For example if the package was &lt;samp&gt;javax.swing&lt;/samp&gt; and the path was &quot;xyz&quot;, then for class &quot;javax.swing.Container&quot; it will look for file &quot;xyz/Container.override&quot;, and if found, it will apply it. If it was &lt;samp&gt;javax.swing.text.JTextComponent&lt;/samp&gt; it will look for file &quot;xyz/text/JTextComponent.override&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="path" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This is the path relative to the plugin where this extension is declared for the folder to search for the override files. See the package attribute description above for how this works.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         1.0.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a registration:
-&lt;p&gt;
-&lt;pre&gt;
-  &lt;extension point=&quot;org.eclipse.jem.beaninfo.registration&quot;&gt;
-    &lt;registration container=&quot;VE_CONTAINER&quot;&gt;
-      &lt;beaninfo path=&quot;xyzbeaninfo.jar&quot;&gt;
-        &lt;searchpath package=&quot;com.xyz.beaninfo&quot;/&gt;
-        &lt;searchpath package=&quot;com.xyz.qxr.beaninfo&quot;/&gt;
-      &lt;/beaninfo&gt;
-      &lt;override package=&quot;com.xyz&quot; path=&quot;overrides/e&quot;/&gt;
-    &lt;/registration&gt;
-    &lt;contributor plugin=&quot;org.eclipse.ve&quot; class=&quot;com.xyz.myContributor&quot;/&gt;
-  &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-&lt;p&gt;
-This says that if container &quot;VE_CONTAINER&quot; is visible to the project being introspected, then then BeanInfo jar &quot;xyzbeaninfo.jar&quot; (found in the plugin that declared this extension) will be looked into for BeanInfos. The two packages listed will be added to the search path of packages.
-&lt;p&gt;
-The override says that, again for &quot;VE_CONTAINER&quot; visible, for any classes that start with &quot;com.xyz&quot;, then the override file (classname.override) will be searched for in the directory &quot;overrides/e&quot;. For example, if the class was &lt;samp&gt;com.xyz.ABC&lt;/samp&gt; it will look for override file &quot;overrides/e/ABC.override&quot;. If the class was &lt;samp&gt;com.xyz.qxr.ABC&lt;/samp&gt; it will for file &quot;overrides/e/qxr/ABC.override&quot;.
-&lt;p&gt;
-Finally if plugin &quot;org.eclipse.ve&quot; is visible to the project, then &lt;samp&gt;com.xyz.myContributor&lt;/samp&gt; will be used to contribute to the BeanInfo.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The &lt;samp&gt;class&lt;/samp&gt; attribute must be a class that implements the &lt;samp&gt;org.eclipse.jem.internal.beaninfo.core.IBeanInfoContributor&lt;/samp&gt; interface.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         [Enter information about supplied implementation of this extension point.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004 IBM Corporation and others.&lt;br&gt;
-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 
-&lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/BaseBeanInfo.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/BaseBeanInfo.java
deleted file mode 100644
index 4cfc8de..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/BaseBeanInfo.java
+++ /dev/null
@@ -1,839 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.beaninfo.vm;
-
-/*
- *  $RCSfile: BaseBeanInfo.java,v $
- *  $Revision: 1.11 $  $Date: 2005/10/18 15:32:19 $ 
- */
-
-import java.awt.Image;
-import java.beans.*;
-import java.lang.reflect.*;
-
-import org.eclipse.jem.beaninfo.common.IBaseBeanInfoConstants;
-
-
-/**
- * A BaseBeanInfo that provides common support for BeanInfos within the JEM environment.
- * 
- * @since 1.1.0
- */
-public abstract class BaseBeanInfo extends SimpleBeanInfo implements IBaseBeanInfoConstants {
-
-	// Constants to use to create all descriptors etc.
-	protected static java.util.ResourceBundle RESBUNDLE = java.util.ResourceBundle.getBundle("org.eclipse.jem.beaninfo.vm.beaninfo"); //$NON-NLS-1$
-
-	/**
-	 * Bound indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String BOUND = "bound";//$NON-NLS-1$
-
-	/**
-	 * Constrained indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String CONSTRAINED = "constrained";//$NON-NLS-1$
-
-	/**
-	 * Property editor class indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String PROPERTYEDITORCLASS = "propertyEditorClass";//$NON-NLS-1$
-
-	/**
-	 * Read Method indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String READMETHOD = "readMethod";//$NON-NLS-1$
-
-	/**
-	 * Write method indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String WRITEMETHOD = "writeMethod";//$NON-NLS-1$
-
-	/**
-	 * Displayname indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String DISPLAYNAME = "displayName";//$NON-NLS-1$
-	
-	/**
-	 * Expert indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String EXPERT = "expert";//$NON-NLS-1$
-
-	/**
-	 * Hidden indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String HIDDEN = "hidden";//$NON-NLS-1$
-
-	/**
-	 * Preferred indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String PREFERRED = "preferred";//$NON-NLS-1$
-
-	/**
-	 * Short description indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String SHORTDESCRIPTION = "shortDescription";//$NON-NLS-1$
-
-	/**
-	 * Customizer class indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String CUSTOMIZERCLASS = "customizerClass";//$NON-NLS-1$
-
-	/**
-	 * In Default eventset indicator for apply property arguments.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String INDEFAULTEVENTSET = "inDefaultEventSet";//$NON-NLS-1$
-	
-	/**
-	 * This is a Feature Attribute Key. When this key exists, the value is a java.lang.reflect.Field. It means this property
-	 * is a field and not a getter/setter. The getter/setter will be ignored and the property type will be the type of the field.
-	 * <p>
-	 * At this time, do not use field on an indexed property. This is currently an undefined situation.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String FIELDPROPERTY = "field"; //$NON-NLS-1$
-
-	/**
-	 * Obscure indicator for apply property arguments. Obsure is a pre-defined attribute name too. That is where the obscure setting is stored.
-	 * <p>
-	 * Obsure means most users don't need it. In the future such features won't even be cached so as to reduce the in-memory costs. Currently this
-	 * flag is ignored.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String OBSCURE = "ivjObscure";//$NON-NLS-1$
-
-	/**
-	 * Design time indicator for apply property arguments. Design time is a pre-defined attribute name too. That is where the design time setting is
-	 * stored.
-	 * <p>
-	 * Design time means:
-	 * <ul>
-	 * <li>Not set: Will be a property that can be connected to, and shows on property sheet (if not hidden).
-	 * <li><code>true</code>: Special property (it will show on property sheet if not hidden), but it can't be connected to. Usually this is a
-	 * property that is fluffed up for the IDE purposes but doesn't have a get/set method. This means it is a property for design time and not for
-	 * runtime.
-	 * <li><code>false</code>: This property will not show up on property sheet but it can be connected to.
-	 * </ul>
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String DESIGNTIMEPROPERTY = "ivjDesignTimeProperty"; //$NON-NLS-1$
-	
-	/**
-	 * EventAdapterClass indicator for apply property arguments. Event adapter class is a pre-defined attribute name too. That is where the event
-	 * adapter is stored.
-	 * <p>
-	 * Adapter class for eventSetDescriptors that provide default no-op implementation of the interface methods. For example
-	 * <code>java.awt.event.WindowListener</code> has an adapter of <code>java.awt.event.WindowAdapter</code>. What is stored is actually the
-	 * class name, not the class itself.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String EVENTADAPTERCLASS = "eventAdapterClass"; //$NON-NLS-1$
-
-
-	public static final boolean JVM_1_3 = System.getProperty("java.version", "").startsWith("1.3"); //$NON-NLS-1$ //$NON-NLS-2$  //$NON-NLS-3$
-	
-	/**
-	 * Empty args list for those descriptors that don't have arguments.
-	 * @since 1.1.0
-	 */
-	public static final Object[] EMPTY_ARGS = new Object[0];
-
-	/**
-	 * Capitalize the string. This uppercases only the first character. So if you have property name of "abc" it will become "Abc".
-	 * 
-	 * @param s
-	 * @return string with first letter capitalized.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String capitalize(String s) {
-		if (s.length() == 0) { return s; }
-		char chars[] = s.toCharArray();
-		chars[0] = Character.toUpperCase(chars[0]);
-		return new String(chars);
-	}
-
-	/**
-	 * Create a BeanDescriptor object given an array of keyword/value arguments. Use the keywords defined in this class, e.g. BOUND, EXPERT, etc.
-	 * 
-	 * @param cls
-	 *            bean for which the bean descriptor is being created.
-	 * @param args
-	 *            arg pairs, [0] keyword, [1] value, [2] keyword, [3] value, etc.
-	 * @return new bean descriptor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static BeanDescriptor createBeanDescriptor(Class cls, Object[] args) {
-		Class customizerClass = null;
-
-		/* Find the specified customizerClass */
-		for (int i = 0; i < args.length; i += 2) {
-			if (CUSTOMIZERCLASS.equals(args[i])) {
-				customizerClass = (Class) args[i + 1];
-				break;
-			}
-		}
-
-		BeanDescriptor bd = new BeanDescriptor(cls, customizerClass);
-
-		for (int i = 0; i < args.length; i += 2) {
-			String key = (String) args[i];
-			Object value = args[i + 1];
-			setFeatureDescriptorValue(bd, key, value);
-		}
-
-		return bd;
-	}
-
-	/**
-	 * Create a beans EventSetDescriptor given the following:
-	 * 
-	 * @param cls
-	 *            The bean class
-	 * @param name
-	 *            Name of event set
-	 * @param args
-	 *            arg pairs, [0] keyword, [1] value, [2] keyword, [3] value, etc.
-	 * @param lmds
-	 *            array of MethodDescriptors defining the listener methods
-	 * @param listenerType
-	 *            type of listener
-	 * @param addListenerName
-	 *            add listener method name
-	 * @param removeListenerNameremove
-	 *            listener method name
-	 * @return new event set descriptor
-	 * @since 1.1.0
-	 */
-	public static EventSetDescriptor createEventSetDescriptor(Class cls, String name, Object[] args, MethodDescriptor[] lmds, Class listenerType,
-			String addListenerName, String removeListenerName) {
-		EventSetDescriptor esd = null;
-		Class[] paramTypes = { listenerType};
-		try {
-			java.lang.reflect.Method addMethod = null;
-			java.lang.reflect.Method removeMethod = null;
-			try {
-				/* get addListenerMethod with parameter types. */
-				addMethod = cls.getMethod(addListenerName, paramTypes);
-			} catch (Exception ie) {
-				throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_get_the_meth1_EXC_"), //$NON-NLS-1$
-						new Object[] { addListenerName}));
-			}
-			;
-			try {
-				/* get removeListenerMethod with parameter types. */
-				removeMethod = cls.getMethod(removeListenerName, paramTypes);
-			} catch (Exception ie) {
-				throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_get_the_meth1_EXC_"), //$NON-NLS-1$
-						new Object[] { removeListenerName}));
-			}
-			;
-
-			esd = new EventSetDescriptor(name, listenerType, lmds, addMethod, removeMethod);
-		} catch (Exception ie) {
-			throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_the_E1_EXC_"), //$NON-NLS-1$
-					new Object[] { name}));
-		}
-		;
-		// set the event set descriptor properties
-		for (int i = 0; i < args.length; i += 2) {
-			String key = (String) args[i];
-			Object value = args[i + 1];
-			if (INDEFAULTEVENTSET.equals(key)) {
-				esd.setInDefaultEventSet(((Boolean) value).booleanValue());
-			} else
-				setFeatureDescriptorValue(esd, key, value);
-		}
-
-		return esd;
-	}
-
-	/**
-	 * Create a bean's MethodDescriptor.
-	 * 
-	 * @param cls
-	 *            class of the method.
-	 * @param name
-	 *            name of the method.
-	 * @param args
-	 *            arg pairs, [0] keyword, [1] value, [2] keyword, [3] value, etc.
-	 * @param params
-	 *            parameter descriptors or <code>null</code> if no parameter descriptors.
-	 * @param paramTypes
-	 *            parameter types
-	 * @return new method descriptor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static MethodDescriptor createMethodDescriptor(Class cls, String name, Object[] args, ParameterDescriptor[] params, Class[] paramTypes) {
-		MethodDescriptor md = null;
-		try {
-			java.lang.reflect.Method aMethod = null;
-			try {
-				/* getMethod with parameter types. */
-				aMethod = cls.getMethod(name, paramTypes);
-			} catch (Exception ie) {
-				throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_get_the_meth1_EXC_"), //$NON-NLS-1$
-						new Object[] { name}));
-			}
-			;
-			if (params != null && params.length > 0)
-				md = new MethodDescriptor(aMethod, params);
-			else
-				md = new MethodDescriptor(aMethod);
-		} catch (Exception ie) {
-			throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_Method_EXC_"), //$NON-NLS-1$
-					new Object[] { name}));
-		}
-		;
-		// set the method properties
-		for (int i = 0; i < args.length; i += 2) {
-			String key = (String) args[i];
-			Object value = args[i + 1];
-			setFeatureDescriptorValue(md, key, value);
-		}
-		return md;
-	}
-
-	private static PropertyDescriptor createOtherPropertyDescriptor(String name, Class cls) throws IntrospectionException {
-		Method readMethod = null;
-		Method writeMethod = null;
-		String base = capitalize(name);
-		Class[] parameters = new Class[0];
-
-		// First we try boolean accessor pattern
-		try {
-			readMethod = cls.getMethod("is" + base, parameters);//$NON-NLS-1$
-		} catch (Exception ex1) {
-		}
-		if (readMethod == null) {
-			try {
-				// Else we try the get accessor pattern.
-				readMethod = cls.getMethod("get" + base, parameters);//$NON-NLS-1$
-			} catch (Exception ex2) {
-				// Find by matching methods of the class
-				readMethod = findMethod(cls, "get" + base, 0);//$NON-NLS-1$
-			}
-		}
-
-		if (readMethod == null) {
-			// For write-only properties, find the write method
-			writeMethod = findMethod(cls, "set" + base, 1);//$NON-NLS-1$
-		} else {
-			// In Sun's code, reflection fails if there are two
-			// setters with the same name and the first setter located
-			// does not have the same return type of the getter.
-			// This fixes that.
-			parameters = new Class[1];
-			parameters[0] = readMethod.getReturnType();
-			try {
-				writeMethod = cls.getMethod("set" + base, parameters);//$NON-NLS-1$
-			} catch (Exception ex3) {
-			}
-		}
-		// create the property descriptor
-		if ((readMethod != null) || (writeMethod != null)) {
-			return new PropertyDescriptor(name, readMethod, writeMethod);
-		} else {
-			throw new IntrospectionException(java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_find_the_acc1_EXC_"), //$NON-NLS-1$
-					new Object[] { name}));
-		}
-	}
-
-	/**
-	 * Create a beans parameter descriptor.
-	 * 
-	 * @param name
-	 *            name of parameter
-	 * @param args
-	 *            arg pairs, [0] keyword, [1] value, [2] keyword, [3] value, etc.
-	 * @return new parameter descriptor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static ParameterDescriptor createParameterDescriptor(String name, Object[] args) {
-		ParameterDescriptor pd = null;
-		try {
-			pd = new ParameterDescriptor();
-		} catch (Exception ie) {
-			throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_Param1_EXC_"), //$NON-NLS-1$
-					new Object[] { name}));
-		}
-		;
-		// set the name
-		pd.setName(name);
-		// set the method properties
-		for (int i = 0; i < args.length; i += 2) {
-			String key = (String) args[i];
-			Object value = args[i + 1];
-			setFeatureDescriptorValue(pd, key, value);
-		}
-
-		return pd;
-	}
-	
-	private static Method GETCLASS; 
-	
-	static {
-		try {
-			GETCLASS = Object.class.getMethod("getClass", null); //$NON-NLS-1$
-		} catch (SecurityException e) {
-		} catch (NoSuchMethodException e) {
-		}
-	}
-	/**
-	 * Create a property descriptor describing a field property.
-	 * <p>
-	 * Note: This is non-standard. The VE knows how to handle this, but any one else using BeanInfo will see this as a property with
-	 * no getter or setter.
-	 * @param name
-	 * @param field
-	 * @param args
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static PropertyDescriptor createFieldPropertyDescriptor(String name, Field field, Object[] args) {
-		try {
-			PropertyDescriptor pd = new PropertyDescriptor(name, null, null);
-			pd.setValue(FIELDPROPERTY, field);	// Set the field property so we know it is a field.
-			applyFieldArguments(pd, args);
-			// Need to set in a phony read method because Introspector will throw it away otherwise. We just use Object.getClass for this.
-			// We will ignore the property type for fields. If used outside of VE then it will look like a class property.
-			pd.setReadMethod(GETCLASS);
-			return pd;
-		} catch (IntrospectionException e) {
-			throwError(e, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_the_P1_EXC_"), //$NON-NLS-1$
-					new Object[] { name}));
-			return null;
-		}
-	}
-
-	/**
-	 * Create a bean's property descriptor.
-	 * 
-	 * @param cls
-	 *            class of who owns the property (usually the bean). It is used to look up get/set methods for the property.
-	 * @param name
-	 *            name of the property. It will use get{Name} and set{Name} to find get/set methods.
-	 * @param args
-	 *            arg pairs, [0] keyword, [1] value, [2] keyword, [3] value, etc.
-	 * @return new property descriptor
-	 * 
-	 * @since 1.1.0
-	 */
-	public static PropertyDescriptor createPropertyDescriptor(Class cls, String name, Object[] args) {
-		PropertyDescriptor pd = null;
-		try {
-			// Create assuming that the getter/setter follows reflection patterns
-			pd = new PropertyDescriptor(name, cls);
-		} catch (IntrospectionException e) {
-			// Try creating a property descriptor for read-only, write-only
-			// or if Sun's reflection fails
-			try {
-				pd = createOtherPropertyDescriptor(name, cls);
-			} catch (IntrospectionException ie) {
-				throwError(ie, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_the_P1_EXC_"), //$NON-NLS-1$
-						new Object[] { name}));
-			}
-		}
-
-		applyPropertyArguments(pd, args, cls);
-
-		return pd;
-	}
-
-
-	/**
-	 * Create a new PropertyDescriptor based upon the PD sent in. It will clone the sent in one, and apply the args to override any specific setting.
-	 * Class cls is used for finding read/write methods, if any.
-	 * 
-	 * This is used when wanting to override only a few specific settings from a property descriptor from the super class.
-	 * 
-	 * @param fromPDS
-	 *            The PropertyDescriptor array to find the entry to clone. It will be changed in place in the array.
-	 * @param name
-	 *            The name of the property to find and clone and override.
-	 * @param cls
-	 *            The class to use to find read/write methods in args. If no read/write methods specified, then this may be null.
-	 * @param args
-	 *            The arguments to override from fromPD. arg pairs, [0] keyword, [1] value, [2] keyword, [3] value, etc.
-	 */
-	public void replacePropertyDescriptor(PropertyDescriptor[] pds, String name, Class cls, Object[] args) {
-		PropertyDescriptor pd = null;
-		int iPD = findPropertyDescriptor(pds, name);
-		if (iPD == -1)
-			return;
-		PropertyDescriptor fromPD = pds[iPD];
-		try {
-
-			pd = pds[iPD] = new PropertyDescriptor(fromPD.getName(), null, null);
-		} catch (IntrospectionException e) {
-			throwError(e, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_the_P1_EXC_"), //$NON-NLS-1$
-					new Object[] { fromPD.getName()}));
-		}
-
-		// Now copy over the contents of fromPD.
-		clonePropertySettings(fromPD, pd);
-
-		// Now apply the overrides
-		applyPropertyArguments(pd, args, cls);
-		return;
-	}
-
-	private void clonePropertySettings(PropertyDescriptor fromPD, PropertyDescriptor pd) {
-		try {
-			pd.setReadMethod(fromPD.getReadMethod());
-			pd.setWriteMethod(fromPD.getWriteMethod());
-			pd.setPropertyEditorClass(fromPD.getPropertyEditorClass());
-			pd.setBound(fromPD.isBound());
-			pd.setConstrained(fromPD.isConstrained());
-			cloneFeatureSettings(fromPD, pd);
-		} catch (IntrospectionException e) {
-			throwError(e, java.text.MessageFormat.format(RESBUNDLE.getString("Cannot_create_the_P1_EXC_"), //$NON-NLS-1$
-					new Object[] { fromPD.getName()}));
-		}
-	}
-
-	private void cloneFeatureSettings(FeatureDescriptor fromFD, FeatureDescriptor fd) {
-		fd.setExpert(fromFD.isExpert());
-		fd.setHidden(fromFD.isHidden());
-		fd.setPreferred(fromFD.isPreferred());
-		fd.setShortDescription(fromFD.getShortDescription());
-		fd.setDisplayName(fromFD.getDisplayName());
-
-		java.util.Enumeration keys = fromFD.attributeNames();
-		while (keys.hasMoreElements()) {
-			String key = (String) keys.nextElement();
-			Object value = fromFD.getValue(key);
-			fd.setValue(key, value);
-		}
-	}
-
-	/*
-	 * The common property arguments between field and standard properties.
-	 */
-	private static boolean applyCommonPropertyArguments(PropertyDescriptor pd, String key, Object value) {
-		if (BOUND.equals(key)) {
-			pd.setBound(((Boolean) value).booleanValue());
-		} else if (CONSTRAINED.equals(key)) {
-			pd.setConstrained(((Boolean) value).booleanValue());
-		} else if (PROPERTYEDITORCLASS.equals(key)) {
-			pd.setPropertyEditorClass((Class) value);
-		} else if (FIELDPROPERTY.equals(key))
-			return true;	// This should not be applied except through createFieldProperty.
-		else
-			return false;
-		return true;
-	
-	}
-	
-	private static void applyPropertyArguments(PropertyDescriptor pd, Object[] args, Class cls) {
-		for (int i = 0; i < args.length; i += 2) {
-			String key = (String) args[i];
-			Object value = args[i + 1];
-
-			if (!applyCommonPropertyArguments(pd, key, value)) {
-				if (READMETHOD.equals(key)) {
-					String methodName = (String) value;
-					Method method;
-					try {
-						method = cls.getMethod(methodName, new Class[0]);
-						pd.setReadMethod(method);
-					} catch (Exception e) {
-						throwError(e, java.text.MessageFormat.format(RESBUNDLE.getString("{0}_no_read_method_EXC_"), //$NON-NLS-1$
-								new Object[] { cls, methodName}));
-					}
-				} else if (WRITEMETHOD.equals(key)) {
-					String methodName = (String) value;
-					try {
-						if (methodName == null) {
-							pd.setWriteMethod(null);
-						} else {
-							Method method;
-							Class type = pd.getPropertyType();
-							method = cls.getMethod(methodName, new Class[] { type});
-							pd.setWriteMethod(method);
-						}
-					} catch (Exception e) {
-						throwError(e, java.text.MessageFormat.format(RESBUNDLE.getString("{0}_no_write_method_EXC_"), //$NON-NLS-1$
-								new Object[] { cls, methodName}));
-					}
-				} else {
-					// arbitrary value
-					setFeatureDescriptorValue(pd, key, value);
-				}
-			}
-		}
-	}
-
-	private static void applyFieldArguments(PropertyDescriptor pd, Object[] args) {
-		for (int i = 0; i < args.length; i += 2) {
-			String key = (String) args[i];
-			Object value = args[i + 1];
-
-			if (!applyCommonPropertyArguments(pd, key, value)) {
-				if (READMETHOD.equals(key)) {
-					// ignored for field.
-				} else if (WRITEMETHOD.equals(key)) {
-					// ignored for field.
-				} else {
-					// arbitrary value
-					setFeatureDescriptorValue(pd, key, value);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Find the method by comparing (name & parameter size) against the methods in the class. This is an expensive call and should be used only if
-	 * getMethod with specific parameter types can't find method.
-	 * 
-	 * @return java.lang.reflect.Method
-	 * @param aClass
-	 *            java.lang.Class
-	 * @param methodName
-	 *            java.lang.String
-	 * @param parameterCount
-	 *            int
-	 */
-	public static java.lang.reflect.Method findMethod(java.lang.Class aClass, java.lang.String methodName, int parameterCount) {
-		try {
-			/*
-			 * Since this method attempts to find a method by getting all methods from the class, this method should only be called if getMethod
-			 * cannot find the method.
-			 */
-			java.lang.reflect.Method methods[] = aClass.getMethods();
-			for (int index = 0; index < methods.length; index++) {
-				java.lang.reflect.Method method = methods[index];
-				if ((method.getParameterTypes().length == parameterCount) && (method.getName().equals(methodName))) { return method; }
-				;
-			}
-			;
-		} catch (java.lang.Throwable exception) {
-			return null;
-		}
-		;
-		return null;
-	}
-
-	/**
-	 * Find a property descriptor of a given name in the list.
-	 * 
-	 * @param pds
-	 *            The array of property descriptors to search, may be null.
-	 * @param name
-	 *            The name to search for.
-	 * @return The found property descriptor index, or -1 if not found.
-	 */
-	public static int findPropertyDescriptor(PropertyDescriptor[] pds, String name) {
-		for (int i = 0; i < pds.length; i++) {
-			if (name.equals(pds[i].getName()))
-				return i;
-		}
-		return -1;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.beans.BeanInfo#getDefaultEventIndex()
-	 */
-	public int getDefaultEventIndex() {
-		return -1;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.beans.BeanInfo#getDefaultPropertyIndex()
-	 */
-	public int getDefaultPropertyIndex() {
-		return -1;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see java.beans.SimpleBeanInfo#getBeanDescriptor()
-	 */
-	public BeanDescriptor getBeanDescriptor() {
-		// Default is to create an empty one.
-		return createBeanDescriptor(getBeanClass(), EMPTY_ARGS);
-	}
-
-	/**
-	 * Implementation for BeanInfo. This implementation will return the BeanInfo of the superclass.
-	 * 
-	 * @see BeanInfo#getAdditionalBeanInfo()
-	 * @since 1.1.0
-	 */
-	public BeanInfo[] getAdditionalBeanInfo() {
-		try {
-			BeanInfo[] result = new BeanInfo[] { Introspector.getBeanInfo(getBeanClass().getSuperclass())};
-			PropertyDescriptor[] oPDs = result[0].getPropertyDescriptors();
-			PropertyDescriptor[] nPDs = overridePropertyDescriptors(oPDs);
-			if (oPDs != nPDs)
-				result[0] = new OverridePDBeanInfo(result[0], nPDs);
-			return result;
-		} catch (IntrospectionException e) {
-			return new BeanInfo[0];
-		}
-	}
-
-	private static class OverridePDBeanInfo implements BeanInfo {
-
-		private BeanInfo originalBeanInfo;
-
-		private PropertyDescriptor[] overridePDs;
-
-		public OverridePDBeanInfo(BeanInfo bi, PropertyDescriptor[] pds) {
-			originalBeanInfo = bi;
-			overridePDs = pds;
-		}
-
-		public BeanInfo[] getAdditionalBeanInfo() {
-			return originalBeanInfo.getAdditionalBeanInfo();
-		}
-
-		public BeanDescriptor getBeanDescriptor() {
-			return originalBeanInfo.getBeanDescriptor();
-		}
-
-		public int getDefaultEventIndex() {
-			return originalBeanInfo.getDefaultEventIndex();
-		}
-
-		public int getDefaultPropertyIndex() {
-			return originalBeanInfo.getDefaultPropertyIndex();
-		}
-
-		public EventSetDescriptor[] getEventSetDescriptors() {
-			return originalBeanInfo.getEventSetDescriptors();
-		}
-
-		public Image getIcon(int iconKind) {
-			return originalBeanInfo.getIcon(iconKind);
-		}
-
-		public MethodDescriptor[] getMethodDescriptors() {
-			return originalBeanInfo.getMethodDescriptors();
-		}
-
-		public PropertyDescriptor[] getPropertyDescriptors() {
-			return overridePDs;
-		}
-	}
-
-	/**
-	 * Allow overrides to parent beaninfo. Subclasses should override this method if they wish to override and change any inherited properties. This
-	 * allows removal of inherited properties or changes of specific properties (such as change from hidden to not hidden).
-	 * 
-	 * Note: If there any changes, this must return a DIFFERENT array. If it returns the same array, then the changes will not be accepted. If just
-	 * overriding, should use pds.clone() to get the new array and then change the specific entries.
-	 * 
-	 * @param pds
-	 * @return The new changed array or the same array if no changes.
-	 * @since 1.1.0
-	 */
-	protected PropertyDescriptor[] overridePropertyDescriptors(PropertyDescriptor[] pds) {
-		return pds;
-	}
-
-	/**
-	 * Get the bean class this beaninfo is for. Used by subclasses to quickly get the bean class without having to code it over and over.
-	 * 
-	 * @return bean class for this beaninfo.
-	 * 
-	 * @since 1.1.0
-	 */
-	public abstract Class getBeanClass();
-
-	/**
-	 * Called whenever the bean information class throws an exception. By default it prints a message and then a stacktrace to sys err.
-	 * 
-	 * @param exception
-	 *            java.lang.Throwable
-	 * @since 1.1.0
-	 */
-	public void handleException(Throwable exception) {
-		System.err.println(RESBUNDLE.getString("UNCAUGHT_EXC_")); //$NON-NLS-1$
-		exception.printStackTrace();
-	}
-
-	private static void setFeatureDescriptorValue(FeatureDescriptor fd, String key, Object value) {
-		if (DISPLAYNAME.equals(key)) {
-			fd.setDisplayName((String) value);
-		} else if (EXPERT.equals(key)) {
-			fd.setExpert(((Boolean) value).booleanValue());
-		} else if (HIDDEN.equals(key)) {
-			fd.setHidden(((Boolean) value).booleanValue());
-		} else if (PREFERRED.equals(key)) {
-			fd.setPreferred(((Boolean) value).booleanValue());
-			if (JVM_1_3) {
-				// Bug in 1.3 doesn't preserve the preferred flag, so we will put it into the attributes too.
-				fd.setValue(PREFERRED, value);
-			}
-		} else if (SHORTDESCRIPTION.equals(key)) {
-			fd.setShortDescription((String) value);
-		}
-		// Otherwise assume an arbitrary-named value
-		// Assume that the FeatureDescriptor private hashTable\
-		// contains only arbitrary-named attributes
-		else {
-			fd.setValue(key, value);
-		}
-	}
-
-	/**
-	 * Fatal errors are handled by calling this method. By default it throws an Error exception.
-	 * 
-	 * @param e
-	 *            exception exception message placed into the new Error thrown.
-	 * @param s
-	 *            message added to exception message. <code>null</code> if nothing to add.
-	 * 
-	 * @throws Error
-	 *             turns exception into an Error.
-	 * @since 1.1.0
-	 */
-	protected static void throwError(Exception e, String s) {
-		throw new Error(e.toString() + " " + s);//$NON-NLS-1$
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/basebeaninfonls.properties b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/basebeaninfonls.properties
deleted file mode 100644
index e78fb11..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/basebeaninfonls.properties
+++ /dev/null
@@ -1,31 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/Attic/basebeaninfonls.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 20:31:28 $
-#
-
-
-#
-# Properties for the IvjBeanInfo
-#
-
-#
-# IvjBeanInfo Strings
-#
-Cannot_get_the_meth1_EXC_ = IWAV0011E Cannot get the method {0}.
-Cannot_create_the_E1_EXC_ = IWAV0012E Cannot create the EventSetDescriptor for {0}.
-Cannot_create_Method_EXC_ = IWAV0013E Cannot create the MethodDescriptor for {0}.
-Cannot_find_the_acc1_EXC_ = IWAV0014E Cannot find at least the write or read accessor for property {0}.
-Cannot_create_Param1_EXC_ = IWAV0015E Cannot create the ParameterDescriptor for {0}.
-Cannot_create_the_P1      = Cannot create the PropertyDescriptor for {0}.
-{0}_no_read_method_EXC_   = IWAV0016E Class {0} doesn''t have the requested read accessor {1}.
-{0}_no_write_method_EXC_  = IWAV0017E Class {0} doesn''t have the requested write accessor {1}.
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/beaninfo.properties b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/beaninfo.properties
deleted file mode 100644
index 81fddc2..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/beaninfo.properties
+++ /dev/null
@@ -1,32 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/beaninfo/vm/Attic/beaninfo.properties,v $
-# $Revision: 1.4 $  $Date: 2005/08/24 20:31:28 $
-#
-
-
-#
-# Properties for the VCE Beaninfo
-#
-
-#
-# IvjBeanInfo Strings
-#
-Cannot_get_the_meth1_EXC_ = IWAV0007E Cannot get the method {0}.
-Cannot_create_the_E1_EXC_ = IWAV0008E Cannot create the EventSetDescriptor for {0}.
-Cannot_create_Method_EXC_ = IWAV0009E Cannot create the MethodDescriptor for {0}.
-Cannot_find_the_acc1_EXC_ = IWAV0010E Cannot find at least the write or read accessor for property {0}.
-Cannot_create_Param1_EXC_ = IWAV0146E Cannot create the ParameterDescriptor for {0}.
-Cannot_create_the_P1_EXC_ = IWAV0147E Cannot create the PropertyDescriptor for {0}.
-{0}_no_read_method_EXC_   = IWAV0148E Class {0} doesn''t have the requested read accessor {1}.
-{0}_no_write_method_EXC_  = IWAV0149E Class {0} doesn''t have the requested write accessor {1}.
-UNCAUGHT_EXC_             = IWAV0123E --------- UNCAUGHT EXCEPTION ---------
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/BeanDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/BeanDescriptorEquality.java
deleted file mode 100644
index 01f0b29..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/BeanDescriptorEquality.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: BeanDescriptorEquality.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-/**
- * Equality tester for BeanDescriptors
- */
-public class BeanDescriptorEquality extends FeatureDescriptorEquality {
-	static void INIT() {
-		try {
-			MAP_EQUALITY.put(BeanDescriptor.class, (BeanDescriptorEquality.class).getConstructor(new Class[] {BeanDescriptor.class}));
-		} catch (NoSuchMethodException e) {
-		}
-	}
-	
-	/**
-	 * Constructor for BeanDescriptorEquality.
-	 */
-	public BeanDescriptorEquality() {
-		super();
-	}
-
-
-	public BeanDescriptorEquality(BeanDescriptor descr) {
-		super(descr);
-	}
-	
-	/**
-	 * Calculate the hashcode for the current feature, add this
-	 * to the hashcode received from super.calculateHashCode
-	 * and return the new value.
-	 *
-	 * NOTE: for subclasses, it is MANDITORY that the first line be:
-	 *         int hashcode = super.calculateHashCode();
-	 *       and the last line be:
-	 *         return hashcode*31 + (your calculated hashcode for just this subclass);
-	 */
-	protected int calculateHashCode() {
-		int hashcode = super.calculateHashCode();
-		BeanDescriptor bd = (BeanDescriptor) fFeature;
-		int hc = bd.getBeanClass().hashCode();
-		if (bd.getCustomizerClass() != null)
-			hc += bd.getCustomizerClass().hashCode();
-			
-		return hashcode*31 + hc;
-	}
-	 
-	public boolean equals(Object obj) {
-		if (identityTest(obj))
-			return true;
-		if (!super.equals(obj))
-			return false;
- 	
-		BeanDescriptor ob = (BeanDescriptor) ((FeatureDescriptorEquality) obj).fFeature;
-		BeanDescriptor fb = (BeanDescriptor) fFeature;
- 		
-		if (ob.getBeanClass() != fb.getBeanClass())
-			return false;
-		if (ob.getCustomizerClass() != fb.getCustomizerClass())
-			return false;
- 			
-		return true;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/EventSetDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/EventSetDescriptorEquality.java
deleted file mode 100644
index d7b1c29..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/EventSetDescriptorEquality.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: EventSetDescriptorEquality.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-import java.util.*;
-import java.lang.reflect.Method;
-/**
- * Equality tester for EventSetDescriptors
- */
-public class EventSetDescriptorEquality extends FeatureDescriptorEquality {
-	
-	static void INIT() {
-		try {
-			MAP_EQUALITY.put(EventSetDescriptor.class, (EventSetDescriptorEquality.class).getConstructor(new Class[] {EventSetDescriptor.class}));
-		} catch (NoSuchMethodException e) {
-		}
-	}
-	
-	private ArrayList fListenerMethodDescriptors;	// Array of MethodDescriptorEquality's.
-	
-	/**
-	 * Constructor for EventSetDescriptorEquality.
-	 */
-	public EventSetDescriptorEquality() {
-		super();
-	}
-
-
-	public EventSetDescriptorEquality(EventSetDescriptor descr) {
-		super(descr);
-	}
-	
-	/**
-	 * A new feature is being set into this object,
-	 * clear any cache members so that they can be reconstructed.
-	 *
-	 * NOTE: Subclasses - remember to call super.clearFeature();
-	 */
-	protected void clearFeature() {
-		super.clearFeature();
-		fListenerMethodDescriptors = null;
-	}
-		
-	protected ArrayList listenerMethodDescriptors() {
-		if (fListenerMethodDescriptors == null) {
-			MethodDescriptor[] mds = ((EventSetDescriptor) fFeature).getListenerMethodDescriptors();
-			fListenerMethodDescriptors = new ArrayList(mds.length);
-			for (int i=0; i<mds.length; i++)
-				fListenerMethodDescriptors.add(new MethodDescriptorEquality(mds[i]));
-		}
-		return fListenerMethodDescriptors;
-	}	
-	
-	/**
-	 * Calculate the hashcode for the current feature, add this
-	 * to the hashcode received from super.calculateHashCode
-	 * and return the new value.
-	 *
-	 * NOTE: for subclasses, it is MANDITORY that the first line be:
-	 *         int hashcode = super.calculateHashCode();
-	 *       and the last line be:
-	 *         return hashcode*31 + (your calculated hashcode for just this subclass);
-	 */
-	protected int calculateHashCode() {
-		int hashcode = super.calculateHashCode();
-		EventSetDescriptor bd = (EventSetDescriptor) fFeature;
-		int hc = bd.getAddListenerMethod().hashCode();
-		Method[] methods = bd.getListenerMethods();
-		int mhc = 0;
-		for (int i=0; i<methods.length; i++)
-			mhc = mhc*31 + methods[i].hashCode();
-		hc += mhc;
-		hc += listenerMethodDescriptors().hashCode();
-		hc += bd.getListenerType().hashCode();
-		hc += bd.getRemoveListenerMethod().hashCode();
-		hc += (bd.isInDefaultEventSet() ? Boolean.TRUE : Boolean.FALSE).hashCode();
-		hc += (bd.isUnicast() ? Boolean.TRUE : Boolean.FALSE).hashCode();		
-
-		return hashcode*31 + hc;
-	}
-
-	 
-	public boolean equals(Object obj) {
-		if (identityTest(obj))
-			return true;
-			
-		if (!super.equals(obj))
- 			return false;
- 	
-		EventSetDescriptor oe = (EventSetDescriptor) ((FeatureDescriptorEquality) obj).fFeature;
-		EventSetDescriptor fe = (EventSetDescriptor) fFeature;
-		
-		EventSetDescriptorEquality oee = (EventSetDescriptorEquality) obj;
- 		
-		if (!oe.getAddListenerMethod().equals(fe.getAddListenerMethod()))
-			return false;
-		if (!java.util.Arrays.equals(oe.getListenerMethods(), fe.getListenerMethods()))
-			return false;	
-		if (oe.getListenerType() != fe.getListenerType())
-			return false;
-		if (oe.getRemoveListenerMethod() != fe.getRemoveListenerMethod())
-			return false;
-		if (oe.isInDefaultEventSet() != fe.isInDefaultEventSet())
-			return false;
-		if (oe.isUnicast() != oe.isUnicast())
-			return false;
-		
-		if (fListenerMethodDescriptors != null || oee.fListenerMethodDescriptors != null) {
-			// We are in a Map lookup situation, so one side has listener method equalities, so we will compare that way.
-			if (!oee.listenerMethodDescriptors().equals(listenerMethodDescriptors()))			
-				return false;
-		} else {
-			// We are in the building the list phases, don't waste space building entire list.
-			MethodDescriptor[] ours = fe.getListenerMethodDescriptors();
-			MethodDescriptor[] theirs = oe.getListenerMethodDescriptors();
-			if (ours.length != theirs.length)
-				return false;
-			if (ours.length > 0) {
-				MethodDescriptorEquality workingOurs = new MethodDescriptorEquality();
-				MethodDescriptorEquality workingThiers = new MethodDescriptorEquality();
-				for (int i = 0; i < ours.length; i++) {
-					workingOurs.setFeature(ours[i]);
-					workingThiers.setFeature(theirs[i]);
-					if (!workingOurs.equals(workingThiers))
-						return false;
-				}
-			}			
-		}
-			
-		return true;			
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/FeatureDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/FeatureDescriptorEquality.java
deleted file mode 100644
index e06cc02..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/FeatureDescriptorEquality.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: FeatureDescriptorEquality.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-import java.util.*;
-import java.lang.reflect.*;
-/**
- * This object is used to test for semantic equality (equals())
- * between feature objects. It is needed because Feature's don't
- * provide a semantic equality, only an identity equality. Need
- * semantic equality so that keys in map can be found equal
- * semantically.
- */
-
-public class FeatureDescriptorEquality {
-	protected FeatureDescriptor fFeature;
-	
-	private HashMap fValues;	// The key/values for this feature. We grab them out
-								// so that we don't have to keep re-getting them for equality
-								// compares. This is done the first time needed in the equals
-								// statement.
-								
-	private int fHashCode = 0;	// Hashcode of this equality object. The hashcode for the feature is expensive
-					// so we will calculate it once (the assumption is that
-					// features once created aren't changed, which for our
-					// purposes here in beaninfo land is good).
-		
-	protected static HashMap MAP_EQUALITY = new HashMap(10);	// Map from descriptor to equality type.
-	static {
-		try {
-			MAP_EQUALITY.put(FeatureDescriptor.class, (FeatureDescriptorEquality.class).getConstructor(new Class[] {FeatureDescriptor.class}));
-		} catch (NoSuchMethodException e) {
-		}
-		// Need to set up the others.
-		BeanDescriptorEquality.INIT();
-		EventSetDescriptorEquality.INIT();		
-		IndexedPropertyDescriptorEquality.INIT();
-		MethodDescriptorEquality.INIT();		
-		ParameterDescriptorEquality.INIT();
-	}
-			
-	/**
-	 * Create the appropriate descriptor equality for this object.
-	 */
-	public static FeatureDescriptorEquality createEquality(FeatureDescriptor descr) {
-		try {
-			return (FeatureDescriptorEquality) ((Constructor) MAP_EQUALITY.get(descr.getClass())).newInstance(new Object[] {descr});
-		} catch (IllegalAccessException e) {
-		} catch (InstantiationException e) {
-		} catch (InvocationTargetException e) {
-			e.printStackTrace();
-		}
-		return null;
-	}
-		
-	public FeatureDescriptorEquality() {
-	}
-	
-	/**
-	 * NOTE: Every subclass needs to implement an override for the methods:
-	 *       calculateHashCode
-	 *       equals
-	 *       clearFeature - if it has any cache values
-	 */
-					
-	public FeatureDescriptorEquality(FeatureDescriptor feature) {
-		setFeature(feature);
-	}
-	
-	public final void setFeature(FeatureDescriptor feature) {
-		clearFeature();
-		fFeature = feature;
-	}
-	
-	/**
-	 * A new feature is being set into this object,
-	 * clear any cache members so that they can be reconstructed.
-	 *
-	 * NOTE: Subclasses - remember to call super.clearFeature();
-	 */
-	protected void clearFeature() {
-		fValues = null;
-		fHashCode = 0;
-	}
-	
-	public final int hashCode() {
-		if (fHashCode == 0)
-			fHashCode = calculateHashCode();
-		return fHashCode;
-	}
-
-	protected final HashMap values() {
-		if (fValues == null) {
-			fValues = new HashMap(5);
-			
-			Enumeration keys = fFeature.attributeNames();
-			while (keys.hasMoreElements()) {
-				String key = (String) keys.nextElement();
-				fValues.put(key, fFeature.getValue(key));
-			}
-		}
-		return fValues;
-	}
-	
-	/**
-	 * Calculate the hashcode for the current feature, add this
-	 * to the hashcode received from super.calculateHashCode
-	 * and return the new value.
-	 *
-	 * NOTE: for subclasses, it is MANDITORY that the first line be:
-	 *         int hashcode = super.calculateHashCode();
-	 *       and the last line be:
-	 *         return hashcode*31 + (your calculated hashcode for just this subclass);
-	 */
-	protected int calculateHashCode() {
-		int hashcode = 0;
-		if (fFeature.getName() != null)
-			hashcode += fFeature.getName().hashCode();
-			
-		if (fFeature.getDisplayName() != fFeature.getName())
-			hashcode += fFeature.getDisplayName().hashCode();
-		if (fFeature.getShortDescription() != fFeature.getDisplayName())
-			hashcode += fFeature.getShortDescription().hashCode();			
-			
-		hashcode += (fFeature.isExpert() ? Boolean.TRUE : Boolean.FALSE).hashCode();
-		hashcode += (fFeature.isHidden() ? Boolean.TRUE : Boolean.FALSE).hashCode();		
-		hashcode += (fFeature.isPreferred() ? Boolean.TRUE : Boolean.FALSE).hashCode();
-		
-		hashcode += values().hashCode();
-		return hashcode;
-	}
-	
-	/**
-	 * equals: See if this is equal semantically.
-	 *
-	 * NOTE: Every subclass needs to implement this and
-	 *       the first few lines should be:
-	 *         if (identityTest())
-	 *           return true;
-	 *         if (!super.equals(obj))
-	 *           return false;
-	 */
-	 
-	 public boolean equals(Object obj) {
-		if (identityTest(obj))
-			return true;
-		if (!(obj instanceof FeatureDescriptorEquality))
-			return false;
-			
-		FeatureDescriptorEquality ofe = (FeatureDescriptorEquality) obj;	 		
-	 	FeatureDescriptor of = ofe.fFeature;
-	 		
-	 	if (fFeature.getClass() != of.getClass())
-	 		return false;
-	 		
-	 	if (!fFeature.getName().equals(of.getName()))
-	 		return false;
-	 	if (!fFeature.getDisplayName().equals(of.getDisplayName()))
-	 		return false;
-	 	if (!fFeature.getShortDescription().equals(of.getShortDescription()))
-	 		return false;	 
-	 	if (fFeature.isExpert() != of.isExpert() ||
-		 		fFeature.isHidden() != of.isHidden() ||
-		 		fFeature.isPreferred() != of.isPreferred())
-	 		return false;
-	 	
-		if (!values().equals(ofe.values()))
-			return false;
-		return true;
-	 }
-	 
-	 /*
-	  * Identity test: Tests for quick identity of
-	  * descriptors. If this returns true, then 
-	  * no other tests required.
-	  */
-	 protected boolean identityTest(Object obj) {
-	 	if (!(obj instanceof FeatureDescriptorEquality))
-	 		return false;
-	 	if (this == obj)
-	 		return true;
-
-	 	if (((FeatureDescriptorEquality) obj).fFeature == fFeature)
-	 		return true;
-	 		
-	 	return false;	 	
-	 }	
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/IndexedPropertyDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/IndexedPropertyDescriptorEquality.java
deleted file mode 100644
index 3e84939..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/IndexedPropertyDescriptorEquality.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: IndexedPropertyDescriptorEquality.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-/**
- * IndexedPropertyDescriptor equality tester
- */
-public class IndexedPropertyDescriptorEquality extends PropertyDescriptorEquality {
-
-	static void INIT() {
-		try {
-			MAP_EQUALITY.put(IndexedPropertyDescriptor.class, (IndexedPropertyDescriptorEquality.class).getConstructor(new Class[] {PropertyDescriptor.class}));
-			MAP_EQUALITY.put(PropertyDescriptor.class, (IndexedPropertyDescriptorEquality.class).getConstructor(new Class[] {PropertyDescriptor.class}));
-		} catch (NoSuchMethodException e) {
-		}
-	}	
-	
-	public IndexedPropertyDescriptorEquality() {
-	}
-	
-	public IndexedPropertyDescriptorEquality(PropertyDescriptor descr) {
-		super(descr);
-	}	
-	/**
-	 * Calculate the hashcode for the current feature, add this
-	 * to the hashcode received from super.calculateHashCode
-	 * and return the new value.
-	 *
-	 * NOTE: for subclasses, it is MANDITORY that the first line be:
-	 *         int hashcode = super.calculateHashCode();
-	 *       and the last line be:
-	 *         return hashcode*31 + (your calculated hashcode for just this subclass);
-	 */
-	protected int calculateHashCode() {
-		int hashcode = super.calculateHashCode();
-		if (fFeature instanceof IndexedPropertyDescriptor) {
-			IndexedPropertyDescriptor pd = (IndexedPropertyDescriptor) fFeature;
-			
-			int hc = pd.getIndexedPropertyType().hashCode();
-	
-			if (pd.getIndexedReadMethod() != null)
-				hc += pd.getIndexedReadMethod().hashCode();
-			if (pd.getIndexedWriteMethod() != null)
-				hc += pd.getIndexedWriteMethod().hashCode();
-			return hashcode*31 + hc;
-		} else
-			return hashcode;
-	}
-
-	public boolean equals(Object obj) {
-		if (!(obj instanceof FeatureDescriptorEquality))
-			return false;
-		if (identityTest(obj))
-			return true;
-		if (fFeature.getClass() != ((FeatureDescriptorEquality) obj).fFeature.getClass())
-			return false;	// If they aren't both PropertyDesciptors or IndexedPropertyDescriptors, then they don't match.
-		if (!super.equals(obj))
-			return false;
- 	
-		if (fFeature instanceof IndexedPropertyDescriptor) {
-			IndexedPropertyDescriptor op = (IndexedPropertyDescriptor) ((FeatureDescriptorEquality) obj).fFeature;
-			IndexedPropertyDescriptor fp = (IndexedPropertyDescriptor) fFeature;
-
-			if (op.getIndexedPropertyType() != fp.getIndexedPropertyType())
-				return false;
-			if (op.getIndexedReadMethod() != fp.getIndexedReadMethod())
-				return false;
-			if (op.getIndexedWriteMethod() != fp.getIndexedWriteMethod())
-				return false; 
-		}													
-			
-		return true;
-	}
-
-
-	
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/MethodDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/MethodDescriptorEquality.java
deleted file mode 100644
index 263319a..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/MethodDescriptorEquality.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: MethodDescriptorEquality.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-import java.util.*;
-/**
- * Equality tester for MethodDescriptors
- */
-public class MethodDescriptorEquality extends FeatureDescriptorEquality {
-	
-	static void INIT() {
-		try {
-			MAP_EQUALITY.put(MethodDescriptor.class, (MethodDescriptorEquality.class).getConstructor(new Class[] {MethodDescriptor.class}));
-		} catch (NoSuchMethodException e) {
-		}
-	}	
-	
-	private ArrayList fParameterDescriptors;	// Array of ParameterDescriptorEquality's.
-	
-	public MethodDescriptorEquality() {
-	}
-	
-	public MethodDescriptorEquality(MethodDescriptor descr) {
-		super(descr);
-	}
-	
-	/**
-	 * A new feature is being set into this object,
-	 * clear any cache members so that they can be reconstructed.
-	 *
-	 * NOTE: Subclasses - remember to call super.clearFeature();
-	 */
-	protected void clearFeature() {
-		super.clearFeature();
-		fParameterDescriptors = null;
-	}	
-	
-	protected ArrayList parameterDescriptors() {
-		if (fParameterDescriptors == null) {
-			ParameterDescriptor[] pds = ((MethodDescriptor) fFeature).getParameterDescriptors();
-			if (pds != null) {			
-				fParameterDescriptors = new ArrayList(pds.length);
-				for (int i=0; i<pds.length; i++)
-					fParameterDescriptors.add(new ParameterDescriptorEquality(pds[i]));
-			}
-		}
-		return fParameterDescriptors;
-	}
-	/**
-	 * Calculate the hashcode for the current feature, add this
-	 * to the hashcode received from super.calculateHashCode
-	 * and return the new value.
-	 *
-	 * NOTE: for subclasses, it is MANDITORY that the first line be:
-	 *         int hashcode = super.calculateHashCode();
-	 *       and the last line be:
-	 *         return hashcode*31 + (your calculated hashcode for just this subclass);
-	 */
-	protected int calculateHashCode() {
-		int hashcode = super.calculateHashCode();
-		MethodDescriptor bd = (MethodDescriptor) fFeature;
-		int hc = bd.getMethod().hashCode();
-		if (parameterDescriptors() != null)
-			hc += parameterDescriptors().hashCode(); 
-
-		return hashcode*31 + hc;
-	}
-
-	public boolean equals(Object obj) {
-		if (identityTest(obj))
-			return true;
-			
-		if (!super.equals(obj))
-			return false;
-
-		MethodDescriptorEquality oem = (MethodDescriptorEquality) obj;
-		MethodDescriptor om = (MethodDescriptor) oem.fFeature;
-		MethodDescriptor fm = (MethodDescriptor) fFeature;
- 		
-		if (fm.getMethod() != om.getMethod())
-			return false;
-				
-		if (fParameterDescriptors != null || oem.fParameterDescriptors != null) {
-			// We are in a Map lookup situation, so one side has listener method equalities, so we will compare that way.
-			if (parameterDescriptors() == null)
-				if (((MethodDescriptorEquality) obj).parameterDescriptors() != null)
-					return false;
-				else ;
-			else
-				if (!parameterDescriptors().equals(((MethodDescriptorEquality) obj).parameterDescriptors()))
-					return false;
-		} else {
-			// We are in the building the list phases, don't waste space building entire list.
-			ParameterDescriptor[] ours = fm.getParameterDescriptors();
-			ParameterDescriptor[] theirs = om.getParameterDescriptors();
-			if (ours == theirs)
-				return true;
-			else if (ours == null)
-				if (theirs != null)
-					return false;
-				else
-					;
-			else if (theirs == null)
-				return false;
-			else if (ours.length != theirs.length)
-				return false;
-			else if (ours.length > 0) {
-				ParameterDescriptorEquality workingOurs = new ParameterDescriptorEquality();
-				ParameterDescriptorEquality workingThiers = new ParameterDescriptorEquality();
-				for (int i = 0; i < ours.length; i++) {
-					workingOurs.setFeature(ours[i]);
-					workingThiers.setFeature(theirs[i]);
-					if (!workingOurs.equals(workingThiers))
-						return false;
-				}
-			}			
-		}
-				
- 			
-		return true;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfo.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfo.java
deleted file mode 100644
index 444943b..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfo.java
+++ /dev/null
@@ -1,863 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-
-/*
- *  $RCSfile: ModelingBeanInfo.java,v $
- *  $Revision: 1.11 $  $Date: 2005/10/18 15:32:19 $ 
- */
-
-import java.beans.*;
-import java.io.IOException;
-import java.io.ObjectOutputStream;
-import java.lang.reflect.*;
-import java.util.*;
-
-import org.eclipse.jem.beaninfo.common.IBaseBeanInfoConstants;
-import org.eclipse.jem.beaninfo.vm.BaseBeanInfo;
-import org.eclipse.jem.internal.beaninfo.common.*;
-import org.eclipse.jem.internal.proxy.common.*;
-
-/**
- * This class is the beaninfo class that is created when beaninfo modeling introspects a bean. Its purpose is to gather together and analyze the
- * beaninfo. For example, it checks with the supertype beaninfo to see if all of the supertype's descriptors are included in this list. If they are,
- * then it knows that it does a straight inheritance of the supertype's descriptors, and those descriptors can be removed from the list. This makes it
- * easier on the model side so that there isn't a great proliferation of descriptors all describing the same properties. In that case they can be
- * merged from the supertype model. If some are not found, then that means this beaninfo is trying to hide some of them, and in that case this is the
- * definitive list and inheritance shouldn't be used on the model side. However, for those features which are essentially the inherited feature (i.e.
- * the BeanInfo simply filtered out some inherited but not all), they will be returnable (by name). The IDE side will take these that are "inherited"
- * and will return the actual structured feature from the inherited class.
- * 
- * The test for seeing if the super feature is included in the beaninfo is first to see if the the feature is in the beaninfo by name, if it is then
- * it is marked as included. Then a check is made on equality, if they are equal, then the feature is removed from the beaninfo list, but the merge
- * flag is still left on, and removed inherited feature is added to the list of inherited features. If all inherited features are found, this list is
- * cleared and flag is set which simply says merge all inherited. This allows merging to occur but it also allows overrides to occur.
- * 
- * Note: Test for identity is different between JDK 1.5 and above and below. 1.5 and above, we can use actual equals() because the same descriptor is
- * returned from inherited features. In 1.3, clones were always returned and equals() would answer false, so we need to create a special equality
- * descriptor which turns the equals() into one that can test clones for semantic equality. See Java Bug ID#4996673 The problem was supposed to be
- * fixed in 1.4 but it was not fixed. Originally a new clone was created each time a beaninfo was requested. That is no longer done in 1.4, but the
- * processing to create the original beaninfo does a clone accidently under the covers. Looking at 1.5 it looks this was fixed, but it hasn't been
- * tested here yet.
- */
-
-public abstract class ModelingBeanInfo implements ICallback {
-
-	private static boolean PRE15;
-	static {
-		String version = System.getProperty("java.version", ""); //$NON-NLS-1$ //$NON-NLS-2$
-		PRE15 = version.startsWith("1."); //$NON-NLS-1$
-		if (PRE15) {
-			// Continue to check, get the revision.
-			int revision = 0;
-			if (version.length() > 2) {
-				int revEnd = version.indexOf('.', 2);
-				revision = version.length() > 2 ? Integer.parseInt(revEnd != -1 ? version.substring(2, revEnd) : version.substring(2)) : 0;
-				PRE15 = revision < 5;
-			}
-		}
-	}
-
-	static class FeatureEqualitySet extends HashSet {
-
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0
-		 */
-		private static final long serialVersionUID = -3744776740604328324L;
-		private FeatureDescriptorEquality workingKey;
-
-		public FeatureEqualitySet(List features) {
-			super(features.size());
-			// Get first feature to fiqure out type of working key. This will not be reentrant.
-			workingKey = FeatureDescriptorEquality.createEquality((FeatureDescriptor) features.get(0));
-			this.addAll(features);
-		}
-
-		/**
-		 * @see java.util.Collection#add(Object)
-		 */
-		public boolean add(Object o) {
-			return super.add(FeatureDescriptorEquality.createEquality((FeatureDescriptor) o));
-		}
-
-		/**
-		 * @see java.util.Collection#contains(Object)
-		 */
-		public boolean contains(Object o) {
-			workingKey.setFeature((FeatureDescriptor) o);
-			return super.contains(workingKey);
-		}
-
-	}
-
-	// The following fields indicate if the super info should be merged
-	// in on the model side. no merge means there were no inherited methods at all. So the
-	// beaninfo presented is definitive. If merge, then get...Descriptors will return just
-	// the ones for this level, and getSuper...Descriptors will return the inherited ones.
-	// Though in this case, if the returned super list is null, then that means use ALL of
-	// the inherited ones.
-	// The super list returns simply the names, don't need to have the full descriptors in that case.
-	protected boolean fMergeInheritedEvents = false, fMergeInheritedMethods = false, fMergeInheritedProperties = false;
-
-	protected final BeanInfo fTargetBeanInfo; // The beaninfo being modeled.
-
-	// Local descriptors
-	protected EventSetDescriptor[] fEventSets;
-
-	protected MethodDescriptor[] fMethods;
-
-	protected PropertyDescriptor[] fProperties;
-
-	// Not inherited descriptor names, will be null if no merge or if merge all. This is list of names to NOT merge. It is usually shorter than the list to merge from super.
-
-	// Methods are special. You can have duplicates, so name is not sufficient.
-	// So for methods,
-	// will use an array of Strings where:
-	//   For each one the full signature
-	//   will be in the list, e.g. "name:methodName(argtype,..." where argtype is the fullyqualified
-	//   classname (using "." notation for inner classes), and using format "java.lang.String[]" for
-	//   arrays.
-	//
-	// This is because even if there are no duplicates, it will take less time/space to simply create the entries
-	// then it would to create a set to see if there are duplicates and then create the final array.
-	protected String[] fNotInheritedEventSets;
-
-	protected String[] fNotInheritedMethods;
-
-	protected String[] fNotInheritedProperties;
-	
-	protected int doFlags;
-
-	/**
-	 * Method used to do introspection and create the appropriate ModelingBeanInfo
-	 * 
-	 * This will always introspect.
-	 */
-	public static ModelingBeanInfo introspect(Class introspectClass, int doFlags) throws IntrospectionException {
-		return introspect(introspectClass, true, doFlags);
-	}
-
-	/**
-	 * Method used to do introspection and create the appropriate ModelingBeanInfo
-	 * 
-	 * introspectIfNoBeanInfo: If this is true, then if no explicit beaninfo was found for this class, then introspection will be done anyway. The
-	 * Introspector will use reflection for local methods/events/properties of this class and then add in the results of the superclass introspection.
-	 * If this parameter is false, then if the explicit beaninfo is not found, then no introspection will be done and null will be returned.
-	 */
-	public static ModelingBeanInfo introspect(Class introspectClass, boolean introspectIfNoBeanInfo, int doFlags) throws IntrospectionException {
-		if (!Beans.isDesignTime())
-			Beans.setDesignTime(true);	// Since this a jem beaninfo specific vm, we should also be considered design time.
-		if (!introspectIfNoBeanInfo) {
-			// Need to check if the beaninfo is explicitly supplied.
-			// If not, then we return null.
-			// The checks will be the same that Introspector will use.
-
-			boolean found = false;
-			// 1. Is there a BeanInfo class in the same package
-			if (!classExists(introspectClass.getName() + "BeanInfo", introspectClass)) { //$NON-NLS-1$
-				// 2. Is this class a BeanInfo class for itself.
-				if (!(BeanInfo.class).isAssignableFrom(introspectClass)) {
-					// 3. Can this class be found in the Beaninfo searchpath.
-					String[] searchPath = Introspector.getBeanInfoSearchPath();
-					int startClassname = introspectClass.getName().lastIndexOf(".") + 1; //$NON-NLS-1$
-					String biName = "." + introspectClass.getName().substring(startClassname) + "BeanInfo"; //$NON-NLS-1$ //$NON-NLS-2$
-					for (int i = 0; i < searchPath.length; i++) {
-						if (classExists(searchPath[i] + biName, introspectClass)) {
-							found = true;
-							break;
-						}
-					}
-				} else
-					found = true;
-			} else
-				found = true;
-
-			if (!found)
-				return null;
-		}
-
-		BeanInfo bInfo = Introspector.getBeanInfo(introspectClass);
-		Class superClass = introspectClass.getSuperclass();
-
-		if (superClass == null)
-			return PRE15 ? (ModelingBeanInfo) new ModelingBeanInfoPre15(bInfo, doFlags) : new ModelingBeanInfo15(bInfo, doFlags);
-		else
-			return PRE15 ? (ModelingBeanInfo) new ModelingBeanInfoPre15(bInfo, Introspector.getBeanInfo(superClass), doFlags) : new ModelingBeanInfo15(bInfo,
-					Introspector.getBeanInfo(superClass), doFlags);
-	}
-
-	/**
-	 * See if this class exists, first in the class loader of the sent class, then in the system loader, then the bootstrap loader, and finally the
-	 * current thread context class loader.
-	 */
-	protected static boolean classExists(String className, Class fromClass) {
-		if (fromClass.getClassLoader() != null)
-			try {
-				fromClass.getClassLoader().loadClass(className);
-				return true;
-			} catch (ClassNotFoundException e) {
-			}
-		if (ClassLoader.getSystemClassLoader() != null)
-			try {
-				ClassLoader.getSystemClassLoader().loadClass(className);
-				return true;
-			} catch (ClassNotFoundException e) {
-			}
-		try {
-			Class.forName(className);
-			return true;
-		} catch (ClassNotFoundException e) {
-		}
-
-		try {
-			// Use the classloader from the current Thread.
-			ClassLoader cl = Thread.currentThread().getContextClassLoader();
-			cl.loadClass(className);
-			return true;
-		} catch (ClassNotFoundException e) {
-		}
-
-		return false;
-
-	}
-
-	/**
-	 * Used only for Object since that is the only bean that doesn't have a superclass. Superclass beaninfo required for all other classes. If this is
-	 * constructed then this means no merge and the list is definitive.
-	 */
-	protected ModelingBeanInfo(BeanInfo beanInfo, int doFlags) {
-		fTargetBeanInfo = beanInfo;
-		this.doFlags = doFlags;
-	}
-
-	protected ModelingBeanInfo(BeanInfo beanInfo, BeanInfo superBeanInfo, int doFlags) {
-		this(beanInfo, doFlags);
-
-		// Now go through the beaninfo to determine the merge state.
-		// The default is no merge.
-
-		if ((doFlags & IBeanInfoIntrospectionConstants.DO_EVENTS) != 0) {
-			List full = addAll(beanInfo.getEventSetDescriptors());
-			List inherited = addAll(superBeanInfo.getEventSetDescriptors());
-
-			fMergeInheritedEvents = stripList(full, inherited);
-			if (fMergeInheritedEvents) {
-				if (!full.isEmpty())
-					fEventSets = (EventSetDescriptor[]) full.toArray(new EventSetDescriptor[full.size()]);
-				if (!inherited.isEmpty())
-					createEventArray(inherited); // This is actually a list of those NOT inherited.
-			}
-		}
-
-		if ((doFlags & IBeanInfoIntrospectionConstants.DO_METHODS) != 0) {
-			List full = addAll(beanInfo.getMethodDescriptors());
-			List inherited = addAll(superBeanInfo.getMethodDescriptors());
-
-			fMergeInheritedMethods = stripList(full, inherited);
-			if (fMergeInheritedMethods) {
-				if (!full.isEmpty())
-					fMethods = (MethodDescriptor[]) full.toArray(new MethodDescriptor[full.size()]);
-				if (!inherited.isEmpty())
-					createMethodEntries(inherited); // This is actually a list of those NOT inherited.
-			}
-		}
-
-		if ((doFlags & IBeanInfoIntrospectionConstants.DO_PROPERTIES) != 0) {
-			List full = addAll(beanInfo.getPropertyDescriptors());
-			List inherited = addAll(superBeanInfo.getPropertyDescriptors());
-
-			fMergeInheritedProperties = stripList(full, inherited);
-			if (fMergeInheritedProperties) {
-				if (!full.isEmpty())
-					fProperties = (PropertyDescriptor[]) full.toArray(new PropertyDescriptor[full.size()]);
-				if (!inherited.isEmpty())
-					createPropertyArray(inherited); // This is actually a list of those NOT inherited.
-			}
-		}
-	}
-
-	protected void createEventArray(List features) {
-		fNotInheritedEventSets = createDescriptorNames(features);
-	}
-
-	protected void createMethodEntries(List features) {
-		int s = features.size();
-		fNotInheritedMethods = new String[s];
-		for (int i = 0; i < s; i++) {
-			fNotInheritedMethods[i] = longName((MethodDescriptor) features.get(i));
-		}
-	}
-
-	protected String longName(MethodDescriptor md) {
-		String n = md.getName();
-		StringBuffer sb = new StringBuffer(n.length() + 20);
-		sb.append(n);
-		sb.append(':');
-		Method m = md.getMethod();
-		sb.append(m.getName());
-		sb.append('(');
-		Class[] parms = m.getParameterTypes();
-		for (int j = 0; j < parms.length; j++) {
-			if (j > 0)
-				sb.append(',');
-			if (!parms[j].isArray())
-				sb.append(parms[j].getName().replace('$', '.'));
-			else {
-				Class finalType = parms[j].getComponentType();
-				int insrt = sb.length();
-				while (finalType.isArray()) {
-					sb.append("[]"); //$NON-NLS-1$
-					finalType = finalType.getComponentType();
-				}
-				sb.insert(insrt, finalType.getName().replace('$', '.'));
-			}
-		}
-		return sb.toString();
-	}
-
-	protected void createPropertyArray(List features) {
-		fNotInheritedProperties = createDescriptorNames(features);
-	}
-
-	protected String[] createDescriptorNames(List features) {
-		String[] result = new String[features.size()];
-		for (int i = 0; i < result.length; i++) {
-			result[i] = ((FeatureDescriptor) features.get(i)).getName();
-		}
-		return result;
-	}
-
-	protected List addAll(Object[] set) {
-		if (set != null) {
-			ArrayList l = new ArrayList(set.length);
-			for (int i = 0; i < set.length; i++) {
-				l.add(set[i]);
-			}
-			return l;
-		} else
-			return Collections.EMPTY_LIST;
-	}
-
-	/**
-	 * If this returns true, then all of the super class's events should be merged in. If it returns false, then the events returned are it, there are
-	 * no others.
-	 */
-	public boolean isMergeInheritedEvents() {
-		return fMergeInheritedEvents;
-	}
-
-	/**
-	 * If this returns true, then all of the super class's methods should be merged in. If it returns false, then the methods returned are it, there
-	 * are no others.
-	 */
-	public boolean isMergeInheritedMethods() {
-		return fMergeInheritedMethods;
-	}
-
-	/**
-	 * If this returns true, then all of the super class's properties should be merged in. If it returns false, then the properties returned are it,
-	 * there are no others.
-	 */
-	public boolean isMergeInheritedProperties() {
-		return fMergeInheritedProperties;
-	}
-
-	public BeanInfo[] getAdditionalBeanInfo() {
-		return fTargetBeanInfo.getAdditionalBeanInfo();
-	}
-
-	public BeanDescriptor getBeanDescriptor() {
-		return fTargetBeanInfo.getBeanDescriptor();
-	}
-
-	public EventSetDescriptor[] getEventSetDescriptors() {
-		return fMergeInheritedEvents ? fEventSets : fTargetBeanInfo.getEventSetDescriptors();
-	}
-
-	public java.awt.Image getIcon(int iconKind) {
-		return fTargetBeanInfo.getIcon(iconKind);
-	}
-
-	public MethodDescriptor[] getMethodDescriptors() {
-		return fMergeInheritedMethods ? fMethods : fTargetBeanInfo.getMethodDescriptors();
-	}
-
-	public PropertyDescriptor[] getPropertyDescriptors() {
-		return fMergeInheritedProperties ? fProperties : fTargetBeanInfo.getPropertyDescriptors();
-	}
-
-	public String[] getNotInheritedEventSetDescriptors() {
-		return fNotInheritedEventSets;
-	}
-
-	public String[] getNotInheritedMethodDescriptors() {
-		return fNotInheritedMethods;
-	}
-
-	public String[] getNotInheritedPropertyDescriptors() {
-		return fNotInheritedProperties;
-	}
-
-	protected String computeKey(FeatureDescriptor feature) {
-		return feature instanceof MethodDescriptor ? longName((MethodDescriptor) feature) : feature.getName();
-	}
-
-	/*
-	 * Strip the list down using the Equality objects.
-	 */
-	protected boolean stripList(List fullList, List inheritedList) {
-		// The process is to create a boolean list mirroring the inheritedList.
-		// This boolean list indicates if the corresponding (by index)
-		// entry from the inheritedList is to be retained in the final computed
-		// list.
-		//
-		// A Hashmap is created where the key is the computedKey from the inheritedList
-		// and the value is the index into the inheritedList. This is so that we can quickly determine if the
-		// entry is matching.
-		//
-		// Then the fullList will be stepped through and see if there is
-		// an entry in the Hashmap for it. If there is an entry, then
-		// the entry is checked to see if it is semantically equal.
-		// If it is, then the boolean list entry is marked so that
-		// the inheritedList entry will be retained, the fullList entry removed and the counter
-		// of the number of entries in the inheritedList copy is incremented.
-		// If they aren't semantically equal, then we know that this is
-		// an override. In that case, the fullList entry is kept, the inheritedList
-		// entry is not retained, but we don't prevent merge later.
-		//
-		// If the fullList entry is not found in the HashMap, then we know it is not
-		// from the inheritedList, so it will be retained in the fullList.
-		//
-		// If we get all of the way through, then we know that what is left
-		// in fullList is just this level.
-		//
-		// When we return we know that
-		//   a) fullList has only the features that are found at the local level
-		//   b) inheritedList if not empty contains the ones from super that SHOULD NOT be inherited.
-		//      If it is empty, then if this method returns true, then ALL should be inherited,
-		//      or if this method returns false, then it doesn't matter because we aren't merging any.
-		//
-		// All of this is based upon the assumption that the list can
-		// get quite large (which it does for javax.swing) and that
-		// a simple n-squared order search would be too slow.
-
-		if (fullList.isEmpty()) {
-			return false; // There are none in the full list, so there should be none, and don't merge.
-		} else if (inheritedList.isEmpty())
-			return false; // There are no inheritedList features, so treat as no merge.
-
-		// We have some features and some inheritedList features, so we need to go through the lists.
-
-		// Create a working copy of the FeatureDescriptorEquality for fullList and stripList and just reuse them
-		FeatureDescriptorEquality workingStrip = FeatureDescriptorEquality.createEquality((FeatureDescriptor) inheritedList.get(0));
-		FeatureDescriptorEquality workingFull = FeatureDescriptorEquality.createEquality((FeatureDescriptor) fullList.get(0));
-
-		int inheritedSize = inheritedList.size();
-		boolean[] copy = new boolean[inheritedSize];
-
-		HashMap inheritedMap = new HashMap(inheritedSize);
-		for (int i = 0; i < inheritedSize; i++) {
-			FeatureDescriptor f = (FeatureDescriptor) inheritedList.get(i);
-			String key = computeKey(f);
-			Object value = inheritedMap.get(key);
-			if (value == null)
-				inheritedMap.put(key, new Integer(i));
-			else {
-				// Shouldn't occur.
-			}
-
-		}
-
-		// When we are done with this processing, inheritedList will contain the super that should not be used, and full list will contain only the locals
-		// (those defined at this class level).;
-		int inheritedRetained = 0;
-		Iterator fullItr = fullList.iterator();
-		// Continue while we've retained less than the full super amount. If we've retained all of the inheritedList, there is no
-		// need to continue processing the fullList because there can't possibly be any inheritedList entries left to find.
-		while (inheritedRetained < inheritedSize && fullItr.hasNext()) {
-			FeatureDescriptor f = (FeatureDescriptor) fullItr.next();
-			boolean foundFull = false;
-			Object index = inheritedMap.get(computeKey(f));
-			if (index != null) {
-				workingFull.setFeature(f);
-				int ndx = ((Integer) index).intValue();
-				workingStrip.setFeature((FeatureDescriptor) inheritedList.get(ndx));
-				if (workingFull.equals(workingStrip)) {
-					// They are semantically identical, so retain in the inheritedList.
-					copy[ndx] = true;
-					foundFull = true;
-					inheritedRetained++;
-				}
-			}
-
-			if (foundFull) {
-				// We found the inheritedList entry semantically equal in the full list somewhere, so we need to remove the full entry.
-				fullItr.remove();
-			}
-		}
-
-		if (inheritedRetained == inheritedSize) {
-			inheritedList.clear(); // All were found in inheritedList, so just clear the inheritedList and return just what was left in the found.
-								   // Those in full found in super had been removed from full during the processing.
-			return true; // We merge with all inherited. 
-		} else	if (inheritedRetained != 0) {
-			// Some were retained, take out of the list those that were retained.
-			// When done the list will contain those that should be dropped from the inherited list.
-			// We start from end because the actual number of bytes moved overall will be less than if we started from the front.
-			for (ListIterator itr = inheritedList.listIterator(inheritedList.size()); itr.hasPrevious();) {
-				int i = itr.previousIndex();
-				itr.previous();	// To back up the itr so that remove can remove it. We actually don't care what the value is.
-				if (copy[i])
-					itr.remove();
-			}
-			return true;	// We merge, and the list is not empty but it did have some removed, so we leave the list alone. Those are not inherited.
-		} else
-			return false;	// All were removed (retained == 0). None were retained. So we just don't do a merge. The list will be ignored.
-	}
-
-	// The modeling beaninfo is also used to send itself back in serialized mode as a callback.
-
-	private IVMCallbackServer vmServer;
-
-	private int callbackID;
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.common.ICallback#initializeCallback(org.eclipse.jem.internal.proxy.common.IVMServer, int)
-	 */
-	public void initializeCallback(IVMCallbackServer vmServer, int callbackID) {
-		this.vmServer = vmServer;
-		this.callbackID = callbackID;
-	}
-	
-	public void send() throws IOException, CommandException {
-		if (doFlags != 0) {
-			ObjectOutputStream stream = new ObjectOutputStream(vmServer.requestStream(callbackID, 0));
-			if ((doFlags & IBeanInfoIntrospectionConstants.DO_BEAN_DECOR) != 0)
-				sendBeanDecorator(stream);
-			if ((doFlags & IBeanInfoIntrospectionConstants.DO_PROPERTIES) != 0)
-				sendPropertyDecorators(stream);
-			if ((doFlags & IBeanInfoIntrospectionConstants.DO_METHODS) != 0)
-				sendMethodDecorators(stream);
-			if ((doFlags & IBeanInfoIntrospectionConstants.DO_EVENTS) != 0)
-				sendEventDecorators(stream);
-			stream.writeInt(IBeanInfoIntrospectionConstants.DONE);
-			stream.close();
-		}
-	}
-
-	/**
-	 * Called by IDE to send the bean decorator information back through the callback.
-	 * @throws CommandException
-	 * @throws IOException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void sendBeanDecorator(ObjectOutputStream stream) throws IOException, CommandException {
-		BeanRecord br = new BeanRecord();
-		BeanDescriptor bd = getBeanDescriptor();
-
-		if (bd != null) {
-			br.customizerClassName = getClassName(bd.getCustomizerClass());
-			br.mergeInheritedProperties = isMergeInheritedProperties();
-			br.mergeInheritedOperations = isMergeInheritedMethods();
-			br.mergeInheritedEvents = isMergeInheritedEvents();
-			br.notInheritedPropertyNames = getNotInheritedPropertyDescriptors();
-			br.notInheritedOperationNames = getNotInheritedMethodDescriptors();
-			br.notInheritedEventNames = getNotInheritedEventSetDescriptors();
-			fill(bd, br, BEAN_RECORD_TYPE);
-		}
-		stream.writeInt(IBeanInfoIntrospectionConstants.BEAN_DECORATOR_SENT);
-		stream.writeObject(br);
-	}
-
-	/**
-	 * Called by IDE to send the property decorators information back through the callback.
-	 * 
-	 * @throws CommandException
-	 * @throws IOException
-	 * @since 1.1.0
-	 */
-	public void sendPropertyDecorators(ObjectOutputStream stream) throws IOException, CommandException {
-		PropertyDescriptor[] properties = getPropertyDescriptors();
-		if (properties != null && properties.length > 0) {
-			// Now start writing the records.
-			stream.writeInt(IBeanInfoIntrospectionConstants.PROPERTY_DECORATORS_SENT);
-			stream.writeInt(properties.length);
-			for (int i = 0; i < properties.length; i++) {
-				PropertyDescriptor pd = properties[i];
-				// Much of the two types are common, so if indexed, fill in the index part and then pass on to property part.
-				PropertyRecord usepr = null;
-				int useType = 0;
-				if (pd.getClass() == IndexedPropertyDescriptor.class) {
-					IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
-					IndexedPropertyRecord ipr = new IndexedPropertyRecord();
-					usepr = ipr;
-					useType = INDEXEDPROPERTY_RECORD_TYPE;
-					ipr.indexedReadMethod = getReflectedMethodRecord(ipd.getIndexedReadMethod());
-					ipr.indexedWriteMethod = getReflectedMethodRecord(ipd.getIndexedWriteMethod());
-					ipr.indexedPropertyTypeName = getClassName(ipd.getIndexedPropertyType());
-				} else {
-					usepr = new PropertyRecord();
-					useType = PROPERTY_RECORD_TYPE;
-				}
-				usepr.propertyEditorClassName = getClassName(pd.getPropertyEditorClass());
-				usepr.propertyTypeName = getClassName(pd.getPropertyType());
-				usepr.readMethod = getReflectedMethodRecord(pd.getReadMethod());
-				usepr.writeMethod = getReflectedMethodRecord((pd.getWriteMethod()));
-				usepr.bound = pd.isBound();
-				usepr.constrained = pd.isConstrained();
-				usepr.designTime = null;
-				usepr.field = null;
-				fill(pd, usepr, useType);
-				stream.writeObject(usepr);
-			}
-		}
-	}
-
-	/**
-	 * Called by IDE to send the method decorators information back through the callback.
-	 * 
-	 * @throws CommandException
-	 * @throws IOException
-	 * @since 1.1.0
-	 */
-	public void sendMethodDecorators(ObjectOutputStream stream) throws IOException, CommandException {
-		MethodDescriptor[] methods = getMethodDescriptors();
-		if (methods != null && methods.length > 0) {
-			// Now start writing the records.
-			stream.writeInt(IBeanInfoIntrospectionConstants.METHOD_DECORATORS_SENT);
-			stream.writeInt(methods.length);
-			for (int i = 0; i < methods.length; i++) {
-				MethodRecord mr = new MethodRecord();
-				fill(mr, methods[i]);
-				stream.writeObject(mr);
-			}
-		}
-	}
-
-	/**
-	 * Fill in a MethodRecord from the MethodDescriptor.
-	 * @param mr
-	 * @param md
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fill(MethodRecord mr, MethodDescriptor md) {
-		mr.methodForDescriptor = getReflectedMethodRecord(md.getMethod());
-		ParameterDescriptor[] parms = md.getParameterDescriptors();
-		if (parms == null)
-			mr.parameters = null;
-		else {
-			mr.parameters = new ParameterRecord[parms.length];
-			for (int j = 0; j < parms.length; j++) {
-				ParameterRecord pr = new ParameterRecord();
-				fill(parms[j], pr, PARAMETER_RECORD_TYPE);
-				mr.parameters[j] = pr;
-			}
-		}
-		fill(md, mr, METHOD_RECORD_TYPE);
-	}
-
-	/**
-	 * Called by IDE to send the event set decorators information back through the callback.
-	 * 
-	 * @throws CommandException
-	 * @throws IOException
-	 * @since 1.1.0
-	 */
-	public void sendEventDecorators(ObjectOutputStream stream ) throws IOException, CommandException {
-		EventSetDescriptor[] events = getEventSetDescriptors();
-		if (events != null && events.length > 0) {
-			// Now start writing the records.
-			stream.writeInt(IBeanInfoIntrospectionConstants.EVENT_DECORATORS_SENT);
-			stream.writeInt(events.length);
-			for (int i = 0; i < events.length; i++) {
-				EventSetDescriptor ed = events[i];
-				EventSetRecord er = new EventSetRecord();
-				er.addListenerMethod = getReflectedMethodRecord(ed.getAddListenerMethod());
-				MethodDescriptor[] mds = ed.getListenerMethodDescriptors();
-				if (mds == null)
-					er.listenerMethodDescriptors = null;
-				else {
-					er.listenerMethodDescriptors = new MethodRecord[mds.length];
-					for (int j = 0; j < mds.length; j++) {
-						fill(er.listenerMethodDescriptors[j] = new MethodRecord(), mds[j]);
-					}
-				}
-				er.listenerTypeName = getClassName(ed.getListenerType());
-				er.removeListenerMethod = getReflectedMethodRecord(ed.getRemoveListenerMethod());
-				er.inDefaultEventSet = ed.isInDefaultEventSet();
-				er.unicast = ed.isUnicast();
-				er.eventAdapterClassName = null;
-				fill(ed, er, EVENTSET_RECORD_TYPE);
-				stream.writeObject(er);
-			}
-		}
-	}
-
-	protected static final int BEAN_RECORD_TYPE = 0;
-
-	protected static final int PROPERTY_RECORD_TYPE = 1;
-
-	protected static final int INDEXEDPROPERTY_RECORD_TYPE = 2;
-	
-	protected static final int METHOD_RECORD_TYPE = 3;
-	
-	protected static final int PARAMETER_RECORD_TYPE = 4;
-	
-	protected static final int EVENTSET_RECORD_TYPE = 5;
-
-	/**
-	 * Fill in the special attr/values for the given record type. The default handles the standard ones.
-	 * 
-	 * @param record
-	 * @param descr
-	 * @param attributeName
-	 * @param recordType
-	 *            type of record ultimately being processed.
-	 * @return <code>true</code> if this attribute is a special one and processed, <code>false</code> if not special and should be added to
-	 *         attributes list transferred to IDE.
-	 * 
-	 * @see ModelingBeanInfo#PROPERTY_RECORD_TYPE
-	 * @since 1.1.0
-	 */
-	protected boolean fillFromAttributes(FeatureRecord record, FeatureDescriptor descr, String attributeName, int recordType) {
-		switch (recordType) {
-			case INDEXEDPROPERTY_RECORD_TYPE:
-			case PROPERTY_RECORD_TYPE:
-				if (BaseBeanInfo.DESIGNTIMEPROPERTY.equals(attributeName)) {
-					((PropertyRecord) record).designTime = (Boolean) descr.getValue(attributeName);
-					return true;
-				} else if (BaseBeanInfo.FIELDPROPERTY.equals(attributeName)) {
-					Field f = (Field) descr.getValue(attributeName);
-					// We have a field, set the property type to this since we couldn't correctly create this otherwise.
-					PropertyRecord pr = (PropertyRecord) record;
-					pr.propertyTypeName = getClassName(f.getType());
-					pr.field = getReflectedFieldRecord(f);
-					pr.readMethod = null;	// Need to wipe out our dummy.
-					pr.writeMethod = null;	// Or if it set, not valid for a field.
-					return true;
-				}
-				break;
-			case EVENTSET_RECORD_TYPE:
-				if (BaseBeanInfo.EVENTADAPTERCLASS.equals(attributeName)) {
-					((EventSetRecord) record).eventAdapterClassName = (String) descr.getValue(attributeName);
-					return true;
-				}
-				break;
-			default:
-				break; // Didn't handle it.
-		}
-		return false;
-	}
-
-	/**
-	 * Fill in the feature portion of the Descriptor into the record. We can be reusing some records (so we don't keep allocating when not needed), so
-	 * we will null out unset fields.
-	 * 
-	 * @param descr
-	 * @param record
-	 * @param recordType
-	 *            type of record ultimately being processed. Used for fillFromAttributes.
-	 * 
-	 * @see ModelingBeanInfo#PROPERTY_RECORD_TYPE
-	 * @since 1.1.0
-	 */
-	protected void fill(FeatureDescriptor descr, FeatureRecord record, int recordType) {
-		record.name = descr.getName();
-		String dn = descr.getDisplayName();
-		if (!record.name.equals(dn))
-			record.displayName = dn; // display name returns name if display name not set. We don't want to send it if identical. (Note some Beaninfos are setting displayname the same text but not same string).
-		else
-			record.displayName = null;
-		String shd = descr.getShortDescription();
-		if (!dn.equals(shd))
-			record.shortDescription = shd; // short description returns displayname if short description not set. We don't want to send it if
-										   // identical.
-		else
-			record.shortDescription = null;
-		record.expert = descr.isExpert();
-		record.hidden = descr.isHidden();
-		record.preferred = descr.isPreferred();
-		record.category = null; // Clear out in case not set.
-		Enumeration attrs = descr.attributeNames();
-		if (attrs.hasMoreElements()) {
-			// We don't have a way of knowing how many there are ahead of time, so we will build into lists and then turn into arrays at the end.
-			List names = new ArrayList();
-			List values = new ArrayList();
-			while (attrs.hasMoreElements()) {
-				String attrName = (String) attrs.nextElement();
-				if (attrName.equals(IBaseBeanInfoConstants.CATEGORY))
-					record.category = (String) descr.getValue(IBaseBeanInfoConstants.CATEGORY);
-				else if (attrName.equals(BaseBeanInfo.PREFERRED)) {
-					// A bug in Java 1.3, doing setPreferred was lost. So for those also stored it in attributes. So if set here, then use it.
-					record.preferred = ((Boolean) descr.getValue(BaseBeanInfo.PREFERRED)).booleanValue();
-				} else if (!fillFromAttributes(record, descr, attrName, recordType)) {
-					// Just copy accross. FillfromAttributes didn't handle it.
-					FeatureAttributeValue fv = new FeatureAttributeValue();
-					fv.setValue(descr.getValue(attrName));
-					names.add(attrName);
-					values.add(fv);
-				}
-			}
-			if (!names.isEmpty()) {
-				record.attributeNames = (String[]) names.toArray(new String[names.size()]);
-				record.attributeValues = (FeatureAttributeValue[]) values.toArray(new FeatureAttributeValue[values.size()]);
-			} else {
-				record.attributeNames = null;
-				record.attributeValues = null;
-			}
-		} else {
-			record.attributeNames = null;
-			record.attributeValues = null;
-		}
-
-	}
-
-	/*
-	 * Get the classname from the class. If classs is null, then this return null.
-	 */
-	private String getClassName(Class classs) {
-		return classs != null ? classs.getName() : null;
-	}
-
-	private ReflectMethodRecord getReflectedMethodRecord(Method method) {
-		if (method != null) {
-			ReflectMethodRecord rmr = new ReflectMethodRecord();
-			rmr.className = getClassName(method.getDeclaringClass());
-			rmr.methodName = method.getName();
-			Class[] parmTypes = method.getParameterTypes();
-			if (parmTypes.length > 0) {
-				rmr.parameterTypeNames = new String[parmTypes.length];
-				for (int i = 0; i < parmTypes.length; i++) {
-					rmr.parameterTypeNames[i] = getClassName(parmTypes[i]);
-				}
-			}
-			return rmr;
-		} else
-			return null;
-	}
-	
-	private ReflectFieldRecord getReflectedFieldRecord(Field field) {
-		if (field != null) {
-			ReflectFieldRecord rf = new ReflectFieldRecord();
-			rf.className = getClassName(field.getDeclaringClass());
-			rf.fieldName = field.getName();
-			rf.readOnly = Modifier.isFinal(field.getModifiers());
-			return rf;
-		} else
-			return null;
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfo15.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfo15.java
deleted file mode 100644
index db59589..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfo15.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: ModelingBeanInfo15.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.BeanInfo;
-
-/**
- * This was supposed to for 1.4 or above where it can use identity
- * to test for inherited features, but it still is not correct
- * in 1.4. See the header comments in ModelingBeanInfo.
- * @see org.eclipse.jem.internal.beaninfo.vm.ModelingBeanInfo
- */
-public class ModelingBeanInfo15 extends ModelingBeanInfo {
-
-	/**
-	 * Constructor for ModelingBeanInfo15.
-	 * @param beanInfo
-	 */
-	public ModelingBeanInfo15(BeanInfo beanInfo, int doFlags) {
-		super(beanInfo, doFlags);
-	}
-
-	/**
-	 * Constructor for ModelingBeanInfo15.
-	 * @param beanInfo
-	 * @param superBeanInfo
-	 */
-	public ModelingBeanInfo15(BeanInfo beanInfo, BeanInfo superBeanInfo, int doFlags) {
-		super(beanInfo, superBeanInfo, doFlags);
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfoPre15.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfoPre15.java
deleted file mode 100644
index 50f5538..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ModelingBeanInfoPre15.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: ModelingBeanInfoPre15.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.BeanInfo;
-
-/**
- * This is the modeling BeanInfo for Pre-JDK 1.4.
- */
-public class ModelingBeanInfoPre15 extends ModelingBeanInfo {
-
-	public ModelingBeanInfoPre15(BeanInfo beanInfo, int doFlags) {
-		super(beanInfo, doFlags);
-	}
-
-	public ModelingBeanInfoPre15(BeanInfo beanInfo, BeanInfo superBeanInfo, int doFlags) {
-		super(beanInfo, superBeanInfo, doFlags);
-	}
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ParameterDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ParameterDescriptorEquality.java
deleted file mode 100644
index 0b06da1..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/ParameterDescriptorEquality.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: ParameterDescriptorEquality.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-/**
- * ParameterDescriptor equality tester
- */
-public class ParameterDescriptorEquality extends FeatureDescriptorEquality {
-	
-	static void INIT() {
-		try {
-			MAP_EQUALITY.put(ParameterDescriptor.class, (ParameterDescriptorEquality.class).getConstructor(new Class[] {ParameterDescriptor.class}));
-		} catch (NoSuchMethodException e) {
-		}
-	}	
-	
-	public ParameterDescriptorEquality() {
-	}
-	
-	public ParameterDescriptorEquality(ParameterDescriptor descr) {
-		super(descr);
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/PropertyDescriptorEquality.java b/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/PropertyDescriptorEquality.java
deleted file mode 100644
index db1c1dd..0000000
--- a/plugins/org.eclipse.jem.beaninfo/vm_beaninfovm/org/eclipse/jem/internal/beaninfo/vm/PropertyDescriptorEquality.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.vm;
-/*
- *  $RCSfile: PropertyDescriptorEquality.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:31:29 $ 
- */
-
-import java.beans.*;
-/**
- * PropertyDescriptor equality tester
- */
-public abstract class PropertyDescriptorEquality extends FeatureDescriptorEquality {	
-	
-	public PropertyDescriptorEquality() {
-	}
-	
-	public PropertyDescriptorEquality(PropertyDescriptor descr) {
-		super(descr);
-	}	
-	/**
-	 * Calculate the hashcode for the current feature, add this
-	 * to the hashcode received from super.calculateHashCode
-	 * and return the new value.
-	 *
-	 * NOTE: for subclasses, it is MANDITORY that the first line be:
-	 *         int hashcode = super.calculateHashCode();
-	 *       and the last line be:
-	 *         return hashcode*31 + (your calculated hashcode for just this subclass);
-	 */
-	protected int calculateHashCode() {
-		int hashcode = super.calculateHashCode();
-		PropertyDescriptor pd = (PropertyDescriptor) fFeature;
-		int hc = 0;
-		if (pd.getPropertyEditorClass() != null)
-			hc += pd.getPropertyEditorClass().hashCode();
-		if (pd.getPropertyType() != null)
-			hc += pd.getPropertyType().hashCode();
-		if (pd.getReadMethod() != null)
-			hc += pd.getReadMethod().hashCode();
-		if (pd.getWriteMethod() != null)
-			hc += pd.getWriteMethod().hashCode();
-			
-		hc += (pd.isBound() ? Boolean.TRUE : Boolean.FALSE).hashCode();
-		hc += (pd.isConstrained() ? Boolean.TRUE : Boolean.FALSE).hashCode();		
-						
-		return hashcode*31 + hc;
-	}
-
-	public boolean equals(Object obj) {
-		if (identityTest(obj))
-			return true;
-			
-		if (!super.equals(obj))
-			return false;
- 	
-		PropertyDescriptor op = (PropertyDescriptor) ((FeatureDescriptorEquality) obj).fFeature;
-		PropertyDescriptor fp = (PropertyDescriptor) fFeature;
- 		
-		if (op.getPropertyEditorClass() != fp.getPropertyEditorClass())
-			return false;
-		if (op.getReadMethod() != fp.getReadMethod())
-			return false;
-		if (op.getWriteMethod() != fp.getWriteMethod())
-			return false;
-		if (op.isBound() != fp.isBound())
-			return false;				
-		if (op.isConstrained() != fp.isConstrained())
-			return false;														
-			
-		return true;
-	}
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/.classpath b/plugins/org.eclipse.jem.proxy/.classpath
deleted file mode 100644
index 2ff85e0..0000000
--- a/plugins/org.eclipse.jem.proxy/.classpath
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="proxyCommon"/>
-	<classpathentry kind="src" path="initParser"/>
-	<classpathentry kind="src" path="remoteCommon"/>
-	<classpathentry output="vm_bin" kind="src" path="vm_remotevm"/>
-	<classpathentry kind="src" path="proxy"/>
-	<classpathentry kind="src" path="proxyRemote"/>
-	<classpathentry kind="src" path="proxyide"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/plugins/org.eclipse.jem.proxy/.cvsignore b/plugins/org.eclipse.jem.proxy/.cvsignore
deleted file mode 100644
index 44fb1cf..0000000
--- a/plugins/org.eclipse.jem.proxy/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin
-build.xml
-common_bin
-vm_bin
diff --git a/plugins/org.eclipse.jem.proxy/.options b/plugins/org.eclipse.jem.proxy/.options
deleted file mode 100644
index 95c080f..0000000
--- a/plugins/org.eclipse.jem.proxy/.options
+++ /dev/null
@@ -1,9 +0,0 @@
-org.eclipse.jem.proxy/remote/debug/debugvm=false
-org.eclipse.jem.proxy/remote/debug/ioconsole=false
-org.eclipse.jem.proxy/remote/debug/vmtraceout=false
-org.eclipse.jem.proxy/remote/debug/notimeouts=false
-org.eclipse.jem.proxy/debug/traceexpressions=false
-org.eclipse.jem.proxy/debug/traceexpressionstimethreshold=100
-org.eclipse.jem.proxy/debug/logtrace=default
-org.eclipse.jem.proxy/debug/logtracefile=default
-org.eclipse.jem.proxy/debug/loglevel=default
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/.project b/plugins/org.eclipse.jem.proxy/.project
deleted file mode 100644
index b820075..0000000
--- a/plugins/org.eclipse.jem.proxy/.project
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem.proxy</name>
-	<comment></comment>
-	<projects>
-		<project>org.eclipse.core.resources</project>
-		<project>org.eclipse.core.runtime.compatibility</project>
-		<project>org.eclipse.debug.core</project>
-		<project>org.eclipse.jdt.core</project>
-		<project>org.eclipse.jdt.launching</project>
-		<project>org.eclipse.pde.core</project>
-	</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/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 0b71ad8..0000000
--- a/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,282 +0,0 @@
-#Thu Jun 16 12:51:01 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=error
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=1
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=0
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
-org.eclipse.jdt.core.formatter.comment.format_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
-org.eclipse.jdt.core.formatter.comment.line_length=150
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=150
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=tab
-org.eclipse.jdt.core.formatter.tabulation.size=4
diff --git a/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 4cff627..0000000
--- a/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed May 11 16:20:15 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.ignorelowercasenames=true
-org.eclipse.jdt.ui.importorder=java;javax;org;org.eclipse.wtp;org.eclipse.jem;org.eclipse.ve.internal.cdm;org.eclipse.ve.internal.cde;org.eclipse.ve.internal.jcm;org.eclipse.ve.internal.java;org.eclipse.ve;com;
-org.eclipse.jdt.ui.ondemandthreshold=3
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.pde.core.prefs b/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.pde.core.prefs
deleted file mode 100644
index 78eace4..0000000
--- a/plugins/org.eclipse.jem.proxy/.settings/org.eclipse.pde.core.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Thu Jun 16 11:08:13 EDT 2005
-eclipse.preferences.version=1
-selfhosting.binExcludes=/org.eclipse.jem.proxy/vm_bin
diff --git a/plugins/org.eclipse.jem.proxy/META-INF/MANIFEST.MF b/plugins/org.eclipse.jem.proxy/META-INF/MANIFEST.MF
deleted file mode 100644
index 4f105ea..0000000
--- a/plugins/org.eclipse.jem.proxy/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,28 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jem.proxy; singleton:=true
-Bundle-Version: 1.2.0
-Bundle-Activator: org.eclipse.jem.internal.proxy.core.ProxyPlugin
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Export-Package: org.eclipse.jem.internal.proxy.awt,
- org.eclipse.jem.internal.proxy.common,
- org.eclipse.jem.internal.proxy.common.remote,
- org.eclipse.jem.internal.proxy.core,
- org.eclipse.jem.internal.proxy.ide,
- org.eclipse.jem.internal.proxy.ide.awt,
- org.eclipse.jem.internal.proxy.initParser,
- org.eclipse.jem.internal.proxy.initParser.tree,
- org.eclipse.jem.internal.proxy.remote,
- org.eclipse.jem.internal.proxy.remote.awt,
- org.eclipse.jem.internal.proxy.vm.remote
-Require-Bundle: org.eclipse.core.resources,
- org.eclipse.jdt.launching,
- org.eclipse.jdt.core,
- org.eclipse.debug.core,
- org.eclipse.jem.util,
- org.eclipse.pde.core;resolution:=optional,
- org.eclipse.core.runtime,
- org.eclipse.ui;resolution:=optional
-Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jem.proxy/about.html b/plugins/org.eclipse.jem.proxy/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/plugins/org.eclipse.jem.proxy/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/build.properties b/plugins/org.eclipse.jem.proxy/build.properties
deleted file mode 100644
index b449a7a..0000000
--- a/plugins/org.eclipse.jem.proxy/build.properties
+++ /dev/null
@@ -1,31 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = plugin.xml,\
-               plugin.properties,\
-               vm/remotevm.jar,\
-               .options,\
-               about.html,\
-               META-INF/,\
-               .
-src.includes = about.html,\
-               schema/,\
-               proxy.jars
-jars.compile.order = .,\
-                     vm/remotevm.jar
-source.vm/remotevm.jar = vm_remotevm/
-output.vm/remotevm.jar = vm_bin/
-output.. = bin/
-source.. = proxyCommon/,\
-           initParser/,\
-           remoteCommon/,\
-           proxy/,\
-           proxyRemote/,\
-           proxyide/
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/ArrayArguments.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/ArrayArguments.java
deleted file mode 100644
index d963f6b..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/ArrayArguments.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: ArrayArguments.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.io.StringWriter;
-import java.lang.reflect.Array;
-import java.util.*;
-/**
- * This represents the arguments in a multi dimensional array with construction parameters, e.g.
- * new int[][] { { 2 ,3 } , { 4 ,5 }}
- * the arguments of the constructor will be instance of ArrayArguments 
- */
-public class ArrayArguments extends Expression {
-	
-	Static fType;
-	List arguments = new ArrayList(2);
-	boolean argsClosed;
-	boolean insideArgsOpenedParen;
-	boolean insideArgsClosedParen;
-	
-public Expression push(char[] token, char tokenDelimiter) {
-	
-	// If the args are opened and a token was supplied then it must be an argument
-	//if ( argsOpened && ( tokenDelimiter == DelimiterCloseParen || tokenDelimiter == DelimiterComma || 
-	//tokenDelimiter == DelimiterSpace || tokenDelimiter == DelimiterQuote || tokenDelimiter == DelimiterPeriod)) {
-	if (!argsClosed){	
-		if ( arguments.size() > 0 ){
-			Expression openArgument = (Expression)arguments.get(arguments.size()-1);
-			if ( !openArgument.isComplete() ) {
-				openArgument.push(token,tokenDelimiter);
-				// If the argument is complete and we received a ) then the message is complete
-				if ( openArgument.isComplete() && tokenDelimiter == DelimiterCloseElipse){
-					argsClosed = true;
-				}
-				return this;
-			}
-		}	
-		
-		// We must have a new argument - process accordingly	
-		Expression newArgument = null;
-		if (!insideArgsOpenedParen && tokenDelimiter == DelimiterOpenParen){
-			insideArgsOpenedParen = true;
-			newArgument = new Statement(fClassLoader).push(token,tokenDelimiter);
-			newArgument = new MessageArgument(newArgument);
-			arguments.add(newArgument);
-
-		}
-		if ( token.length > 0 || tokenDelimiter == DelimiterQuote || tokenDelimiter == DelimiterSingleQuote || tokenDelimiter == OperMinus ) {
-			newArgument = new Statement(fClassLoader).push(token,tokenDelimiter);
-			newArgument = new MessageArgument(newArgument);
-			arguments.add(newArgument);
-		}
-		// If the token after the argument is a ) then the message is being closed
-		if ( !insideArgsOpenedParen  && tokenDelimiter == DelimiterCloseElipse ) {
-			argsClosed = true;
-			return this;
-		}
-		if ( insideArgsOpenedParen  && tokenDelimiter == DelimiterCloseElipse ) {
-			insideArgsClosedParen  = true;
-			argsClosed = true;
-			return this;
-		}
-	}
-	return this;
-}
-/**
- * In the case of the expression new int[][] { {2,3} , {4,5} } then we are the 2,3 or the 4,5
- * to evaluate we must return an array of ints based on our size.  The type we return is determined by the initial 
- * constructor who will have given this to us as our fType
- */	
-public Object evaluate() throws Exception {
-
-	Object result = Array.newInstance(fType.getPrimitiveTypeClass(),arguments.size());
-	for (int i = 0; i < arguments.size(); i++) {
-		Object argumentValue = ((Expression)arguments.get(i)).evaluate();
-		Array.set(result,i,argumentValue);
-	}
-	return result;
-}
-
-public Class getTypeClass() throws Exception {
-	return null;
-}
-
-public boolean isComplete() {
-	return argsClosed;
-}
-
-public boolean isPrimitive() throws Exception {
-	return false;
-}
-public void setType(Static type) {
-	fType = type;
-}
-public void contributeArgumentNumber(List argumentNumberList){
-	
-	// Add the number of arguments we have to the list
-	argumentNumberList.add(new Integer(arguments.size()));
-	// If our arguments are themselves array arguments ( which will occur in an array of 3 or more dimensions )
-	// then we should cascade this message to our argument so that the total array depth is known
-	if ( arguments.size() > 0 ) {
-		Object firstArgument = arguments.get(0);
-		if ( firstArgument instanceof ArrayArguments ) {
-//			((ArrayArguments)firstArgument)contributeArgumentNumber(argumentNumberList);
-		}
-	}
-	
-}
-public String toString(){
-	StringWriter writer = new StringWriter();
-	writer.write("Args("); //$NON-NLS-1$
-	writer.write(new Integer(arguments.size()).toString());
-	writer.write(")-"); //$NON-NLS-1$
-	writer.write(arguments.toString());
-	return writer.toString();
-}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.initParser.Expression#getTypeClassName()
-	 */
-	protected String getTypeClassName() {
-		return "";	// Not applicable //$NON-NLS-1$
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Block.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Block.java
deleted file mode 100644
index c630f2e..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Block.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Block.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-/**
- */
-public class Block extends Expression {
-	
-	protected boolean fIsClosed = false;
-	protected boolean fIsComplete = false;
-	protected boolean fMessageOrField = false;
-	
-	public Block(Expression anExpression){
-		currentExpression = anExpression;
-	}
-
-	public Block(ClassLoader fClassLoader){
-		currentExpression = new Statement(fClassLoader);
-	}
-
-	public Object evaluate() throws Exception {
-		return currentExpression.evaluate();
-	}
-
-	public boolean isComplete() {
-		return fIsComplete;
-	}
-
-	public Class getTypeClass() throws Exception {
-		return currentExpression.getTypeClass();
-	}
-
-
-	public Expression push(char[] token, char tokenDelimiter) {
-			
-		// If we are closed (i.e. completed with a )) and we get a ) or , then we are all finished up
-		// We should not forward this token to the expression, as it isComplete
-		if ((fIsClosed || currentExpression.isComplete()) && (tokenDelimiter == DelimiterCloseParen || tokenDelimiter == DelimiterComma)){
-			fIsComplete = true;
-			return this;
-		}
-		
-		// If we are a message of field and we get a ( we are message or a field otherwise
-		if (fMessageOrField){
-			fMessageOrField = false;
-			// The problem now is that we are a block of an expression and we need to create a message
-			// where we are the receiver.  However we are on the stack and going to be popped when the message finishes
-			// so we must alter ourself to be a block whose current expression is message whose argument
-			// is a copy of us
-			if ( tokenDelimiter == DelimiterOpenParen){
-				Message message = new Message(currentExpression,token,fClassLoader);
-				currentExpression = message;
-				return message;
-			} else {
-				Field field = new Field(currentExpression,token,fClassLoader);
-				currentExpression = field;
-				return field;
-			}
-		}
-		
-		// If we are closed and we get a . then we must begin a message or field expression
-		if (currentExpression.isComplete() && tokenDelimiter == DelimiterPeriod ){
-			fMessageOrField = true;
-			return this;
-		}
-		
-		Expression result = currentExpression.push(token,tokenDelimiter);
-		// If the result if a push then push the stack
-		if ( result != currentExpression ) {
-			pushExpressionStack(result);	
-		}
-		// If our current expression is complete and we are receiving a close parent then we are closed
-		if (currentExpression.isComplete() && tokenDelimiter == DelimiterCloseParen){
-			fIsClosed = true;
-
-		}
-		// If we are here the current expression is still processing tokens so we should return it
-		return currentExpression;
-	}
-
-	public boolean isPrimitive() throws Exception {
-		return false;
-	}
-	public String toString(){
-		StringBuffer buffer = new StringBuffer();
-		buffer.append("Block("); //$NON-NLS-1$
-		if ( currentExpression != null ) {
-			buffer.append(currentExpression.toString());
-		}
-		buffer.append(')');
-		return buffer.toString();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.initParser.Expression#getTypeClassName()
-	 */
-	protected String getTypeClassName() {
-		return currentExpression.getTypeClassName();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/BooleanLiteral.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/BooleanLiteral.java
deleted file mode 100644
index 65204fa..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/BooleanLiteral.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: BooleanLiteral.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-public class BooleanLiteral extends Expression {
-	public boolean value;
-public BooleanLiteral(boolean aValue){
-
-	value = aValue;
-
-}
-
-public boolean isComplete(){
-	return true;
-}
-/**
- * evaluate method comment.
- */
-public Object evaluate() {
-	return new Boolean(value);
-}
-/**
- * evaluate method comment.
- */
-public Class getTypeClass(){
-	return Boolean.TYPE;
-}
-/**
- * true or false cannot consume any kind of expression so we must return null
- */
-public Expression push(char[] token , char delimiter){
-
-	return null;	
-
-}
-
-/**
- * This is primitive
- */
-public boolean isPrimitive() {
-	return true;
-}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.initParser.Expression#getTypeClassName()
-	 */
-	protected String getTypeClassName() {
-		return Boolean.TYPE.getName();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CannotProcessArrayTypesException.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CannotProcessArrayTypesException.java
deleted file mode 100644
index 042d805..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CannotProcessArrayTypesException.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: CannotProcessArrayTypesException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-/**
- * Exception to indicate that the initStringParser can't deal with arrays right now
- */
-public class CannotProcessArrayTypesException extends RuntimeException {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -4245984020065761634L;
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CannotProcessInnerClassesException.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CannotProcessInnerClassesException.java
deleted file mode 100644
index ac390b9..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CannotProcessInnerClassesException.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: CannotProcessInnerClassesException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-/**
- * This exception is thrown to indicate that inner classes cannot be processed
- */
-public class CannotProcessInnerClassesException extends RuntimeException {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = 8290504580738499445L;
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Cast.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Cast.java
deleted file mode 100644
index 2a1d54e..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Cast.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Cast.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import java.util.HashMap;
-
-public class Cast extends Expression {
-	protected static final int BYTE_TYPE = 0;
-	protected static final int SHORT_TYPE = 1;
-	protected static final int INT_TYPE = 2;
-	protected static final int LONG_TYPE = 3;
-	protected static final int FLOAT_TYPE = 4;
-	protected static final int DOUBLE_TYPE = 5;
-	
-	protected static final HashMap sTypeLookup;
-	static {
-		sTypeLookup = new HashMap(6);
-		sTypeLookup.put(Byte.TYPE, new Integer(BYTE_TYPE));
-		sTypeLookup.put(Short.TYPE, new Integer(SHORT_TYPE));
-		sTypeLookup.put(Integer.TYPE, new Integer(INT_TYPE));
-		sTypeLookup.put(Long.TYPE, new Integer(LONG_TYPE));
-		sTypeLookup.put(Float.TYPE, new Integer(FLOAT_TYPE));
-		sTypeLookup.put(Double.TYPE, new Integer(DOUBLE_TYPE));
-	}
-		
-	protected Static fCastType;
-	protected boolean fIsClosed = false;
-	
-	public Cast(Static castType, ClassLoader aClassLoader) {
-		fCastType = castType;
-		fClassLoader = aClassLoader;
-	}
-	
-	public boolean isPrimitive() throws Exception {
-		return getTypeClass().isPrimitive();
-	}
-	
-	/**
-	 * The type of a Cast expression is the type of the cast type.
-	 */
-	public Class getTypeClass() throws Exception {
-		return fCastType.getTypeClass();
-	}
-	
-	
-	public boolean isComplete() {
-		return currentExpression != null && currentExpression.isComplete();
-	}
-	
-	/**
-	 * If the type is primitive, then we need to
-	 * convert the value, otherwise just pass
-	 * the value on.
-	 *
-	 * This is important for primitives because if your
-	 * entire initialization string was simply "(short) 3"
-	 * then a Short value must be returned so that the
-	 * correct kind of primitive proxy is created.
-	 */
-	public Object evaluate() throws Exception {
-		if (getTypeClass() == currentExpression.getTypeClass())
-			return currentExpression.evaluate();	// They're the same, so just return it.
-		if (getTypeClass().isPrimitive()) {
-			// Can only cast a primitive to a primitive, except null can't be cast to a primitive.
-			if (!currentExpression.getTypeClass().isPrimitive() || currentExpression.getTypeClass() == Void.TYPE)
-				throw new EvaluationException(new ClassCastException(currentExpression.getTypeClass().getName()));			
-			// boolean only allows boolean cast.
-			if (fCastType.getTypeClass() == Boolean.TYPE || currentExpression.getTypeClass() == Boolean.TYPE)
-				throw new EvaluationException(new ClassCastException(currentExpression.getTypeClass().getName()));
-			if (fCastType.getTypeClass() == Character.TYPE) {
-				// So we have either a Character or a number as the value. Cast that.				
-				return new Character((char) ((Number) currentExpression.evaluate()).intValue());
-			} else {
-				Number value = null;
-				// See if the value is character or a number.
-				if (currentExpression.getTypeClass() == Character.TYPE)
-					value = new Integer(((Character) currentExpression.evaluate()).charValue());
-				else
-					value = (Number) currentExpression.evaluate();
-				switch (((Integer) sTypeLookup.get(fCastType.getTypeClass())).intValue()) {
-					case BYTE_TYPE:
-						return new Byte(value.byteValue());
-					case SHORT_TYPE:
-						return new Short(value.shortValue());
-					case INT_TYPE:
-						return new Integer(value.intValue());
-					case LONG_TYPE:
-						return new Long(value.longValue());
-					case FLOAT_TYPE:
-						return new Float(value.floatValue());
-					case DOUBLE_TYPE:
-						return new Double(value.doubleValue());
-					default:
-						return null;	// Shouldn't occur. Just satisifies compiler.
-				}
-			}
-			
-		} else
-			return currentExpression.evaluate();
-	}
-	/**
-	 * A cast expression always pushes onto the cast value
-	 */
-	public Expression push(char[] token , char tokenDelimiter) {
-		// If we don't have a class yet then we are within the statement to try and deterine the type being cast to
-		if(fCastType.getPrimitiveTypeClass() == null && !fIsClosed){
-			fCastType.push(token,tokenDelimiter);
-			// If the type was completed and we have a ) then close us
-			if(fCastType.getPrimitiveTypeClass() != null && tokenDelimiter == DelimiterCloseParen){
-				fIsClosed = true;
-			}
-			return this;			
-		}
-		
-		if (!fIsClosed) {
-			// The cast is not closed, but we have a static class.  This class must therefore keep processing the tokens as it could be a method or message send
-			Expression result =  fCastType.push(token,tokenDelimiter);
-			result.parenthesisLevel++;
-			return result; 
-		}
-		
-		// If we have no expression push onto the cast value		
-		if(currentExpression == null){
-			currentExpression = new Statement(fClassLoader);
-			currentExpression = currentExpression.push(token,tokenDelimiter);
-			return this;
-		} 
-		Expression result = currentExpression.push(token, tokenDelimiter);
-		// If the result if a push then push the stack
-		if ( result.isComplete() ) {
-			popExpressionStack();
-		} else if ( result != currentExpression ) {
-			pushExpressionStack(result);
-		}		
-		return this;
-	}
-	public String toString(){
-		StringBuffer buffer = new StringBuffer();
-		buffer.append("Cast("); //$NON-NLS-1$
-		if (fCastType != null){
-			buffer.append(fCastType.toString());
-		} else {
-			buffer.append("???"); //$NON-NLS-1$
-		}
-		buffer.append(") "); //$NON-NLS-1$
-		if ( currentExpression != null){
-			buffer.append(currentExpression.toString());
-		} else {
-			buffer.append("???");			 //$NON-NLS-1$
-		}
-		return buffer.toString();
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.initParser.Expression#getTypeClassName()
-	 */
-	protected String getTypeClassName() {
-		return fCastType.getTypeClassName();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CharLiteral.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CharLiteral.java
deleted file mode 100644
index a0dd4d8..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/CharLiteral.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: CharLiteral.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.text.MessageFormat;
-
-
-
-public class CharLiteral extends Expression {
-	protected boolean isComplete;
-	public char value;
-	public StringBuffer valueBuffer = new StringBuffer();
-	protected boolean isEscaped = false;
-
-/**
- * constructor
- */
-public CharLiteral(){
-}
-	
-/**
- * evaluate method comment.
- */
-public Object evaluate() throws Exception {
-	if (valueBuffer.length() == 1)
-		return new Character(valueBuffer.charAt(0));
-	else
-		throw new EvaluationException(
-			new IllegalArgumentException(MessageFormat.format(ProxyInitParserMessages.getString("CharTooComplicated_EXC_"), //$NON-NLS-1$
-				new Object[] {valueBuffer.toString()})));
-}
-
-public boolean isComplete(){
-	return isComplete;
-}
-/**
- * We must evaluate ourself and return the type of the result
- */
- 
-public Class getTypeClass() {
-	return Character.TYPE;
-}
-
-protected String getTypeClassName() {
-	return Character.TYPE.getName();
-}
-/**
- *This string might be broken into a few tokens
- *so we need a StringBuffer 
- */
-public Expression push(char[] token , char delimiter){
-	
-	if (isEscaped) {
-		isEscaped = false;
-		if (token.length != 0) {
-			// Had an escape followed by stuff, so not a true esc for our current definition
-			valueBuffer.append(DelimiterEscape);
-		} else {
-			if (delimiter == DelimiterSingleQuote || delimiter == DelimiterEscape)
-				valueBuffer.append(delimiter);	// It was a true escape.
-			else {
-				valueBuffer.append(DelimiterEscape);	// If wasn't a true escape
-				valueBuffer.append(delimiter);
-			}
-			return this;
-		}
-	}
-	
-	valueBuffer.append(token);
-	
-	if (delimiter == DelimiterSingleQuote){		
-		isComplete =true;
-		return this;
-	}
-	
-	// If the delimiter is an escape character remember it so we can escape
-	// the next token, otherwise treat it as a literal
-	if (delimiter == DelimiterEscape ){
-		isEscaped = true;
-	} else {
-		valueBuffer.append(delimiter);
-	}
-	return this;
-}
-
-/**
- * chars are primitives.
- */
-public boolean isPrimitive() {
-	return true;
-}
-public String toString(){
-	StringBuffer buffer = new StringBuffer();
-	buffer.append("Char('"); //$NON-NLS-1$
-	if ( valueBuffer != null ) {
-		buffer.append(valueBuffer.toString());
-	}
-	buffer.append(')');
-	return buffer.toString();
-}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Constructor.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Constructor.java
deleted file mode 100644
index ba88512..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Constructor.java
+++ /dev/null
@@ -1,337 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Constructor.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.util.*;
-
-import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;
-import org.eclipse.jem.internal.proxy.common.MethodHelper;
-/**
- * Insert the type's description here.
- * Creation date: (11/01/00 8:52:36 PM)
- * @author: Administrator
- */
-public class Constructor extends Expression {
-	public boolean argsOpened = false;
-	public boolean argsClosed = false;
-	public boolean trailingPeriod = false;
-	public ArrayList arguments = new ArrayList(2);
-	public Static type;
-	protected boolean fIsComplete;
-	public boolean insideArgsOpenedParen = false;
-	public boolean insideArgsClosedParen = false;
-	public boolean isString = false;
-	public java.lang.reflect.Constructor ctor;
-/**
- * Constructor constructor comment.
- */
-public Constructor(ClassLoader aClassLoader) {
-	super();
-	fClassLoader = aClassLoader;
-}
-
-public boolean isComplete(){
-	return fIsComplete;
-}
-
-/**
- * Invoke the construtor
- */
-public Object evaluate() throws Exception {
-
-	if ( type.isArray() ) {
-		// For arrays we get the array that is actually held inside the static
-		// To instantiate the array it is possible that the static knows the array size, e.g. new int[2]
-		// or else it must be given this from the number of arguments we have, e.g. new int[] { 2 , 3 }
-		if ( arguments.size() > 0 ) {
-			type.setArrayArguments(arguments);
-		}
-		Object result = type.evaluate();
-		// Deal with array initialization arguments
-		return result;
-	} else {
-		// For non arrays we find the method and invoke it on the type
-		cacheCtor();
-		// Get the array of arguments
-		Object[] args = new Object[arguments.size()];
-		Iterator itr = arguments.iterator();
-		for (int i = 0; i < arguments.size() ; i++){
-			Expression anExpression = (Expression)itr.next();
-			args[i] = anExpression.evaluate();
-		}
-	
-		try {
-			return ctor.newInstance(args);	
-		} catch (Exception e) {
-			// If we got this far, then we have a valid parse, so anything is an evaluation exception.
-			throw new EvaluationException(e);
-		}
-	}
-}
-/** A constructor can only return the class of its type
- */
-public Class getTypeClass() throws Exception {
-	if ( type.isArray() ) {
-		// For arrays we get the array that is actually held inside the static
-		// To instantiate the array it is possible that the static knows the array size, e.g. new int[2]
-		// or else it must be given this from the number of arguments we have, e.g. new int[] { 2 , 3 }
-		if ( arguments.size() > 0 ) {
-			type.setArrayArguments(arguments);
-		}
-	}
-	return type.getTypeClass();
-}
-
-protected String getTypeClassName() {
-	return type.getTypeClassName();
-}
-
-private void cacheCtor() throws Exception {
-	
-	if (ctor == null) {
-		Class[] argTypes = new Class[arguments.size()];
-		Iterator itr = arguments.iterator();
-		for (int i=0; i<argTypes.length; i++)
-			argTypes[i] = getEvaluationTypeClass((Expression) itr.next());
-			
-		try {
-			ctor = MethodHelper.findCompatibleConstructor(getEvaluationTypeClass(this), argTypes);
-		} catch (NoSuchMethodException e) {
-			throw new EvaluationException(e);
-		} catch (AmbiguousMethodException e) {
-			throw new EvaluationException(e);
-		}
-	}
-}
-protected boolean isDelimiterOpened(char token){
-	return type.isArray() ? token == DelimiterOpenElipse : token == DelimiterOpenParen;	
-}
-protected boolean isDelimiterClosed(char token){
-	return type.isArray() ? token == DelimiterCloseElipse : token == DelimiterCloseParen;
-}
-/**
- * push method comment.
- */
-public Expression push(char[] token, char tokenDelimiter) {
-
-	// If we are closed and we receive a . with no token then remember this
-	if ( argsClosed && !trailingPeriod && tokenDelimiter == DelimiterPeriod && token.length == 0 ) {
-		trailingPeriod = true;
-		return this;
-	}
-	// If we have been closed with a . and we receive a . then we are a field
-	if ( trailingPeriod && tokenDelimiter == DelimiterPeriod ) {
-		return new Field(this,token,fClassLoader);
-	}
-	// If we have been closed with a . and we receive a ( we are a message
-	if ( trailingPeriod && tokenDelimiter == DelimiterOpenParen ) {
-		return new Message(this,token,fClassLoader);
-	}
-	
-	// Lazy initialize the type if required
-	if ( type == null ) {
-		switch ( tokenDelimiter ) {
-			case DelimiterPeriod: {
-				type = new Static(token,tokenDelimiter,fClassLoader);
-				type.setClassLoader(fClassLoader);
-				return this;
-			}
-			case DelimiterOpenParen: {
-				type = new Static(token,tokenDelimiter,fClassLoader);
-				type.setClassLoader(fClassLoader);
-				argsOpened = true;
-				return this;
-			} 
-			case DelimiterOpenSquareBrace: { 
-//				throw new CannotProcessArrayTypesException();
-				// Array dimenions are created as staements in the arrayDimensions
-				// This is for expressions like new String[] or new String[3], where the Statement represents the 3, i.e.
-				// the code that declares the size of the array
-				type = new Static(token,tokenDelimiter,fClassLoader,true);
-				return this;
-			}
-			// If we get a { and our static is an array then this is the array initialization parameters
-			case DelimiterOpenElipse: { 
-				if ( type != null && type.isArray() ) {
-					argsOpened = true;
-				}
-			}
-			default: {
-				return null;
-			}
-		}
-	}
-	
-	// If we have a static that is an array then it consumes token until it is complete
-	if ( type != null && type.isArray() ) {
-		// The type consumes token as long as it is still in the array declaration section
-		if ( type.isProcessingArrayDimension || tokenDelimiter == DelimiterOpenSquareBrace ) {
-			type.push(token,tokenDelimiter);
-			return this;
-		}
-	}
-		
-	// If the type is incomplete and the token is a . ( for another class ) or a [ for an array then push it onto the type
-	if (!type.isArray() && type.getTypeClass() == null && (tokenDelimiter == DelimiterPeriod || tokenDelimiter == DelimiterOpenSquareBrace)) {
-		type.push(token , tokenDelimiter);
-		return this;
-	}
-	// If the type is incomplete and the token is a ( then push it onto the type and open the parens
-	if (!type.isArray()){
-		if (type.getTypeClass() == null && !argsOpened && isDelimiterOpened(tokenDelimiter)) {
-			argsOpened = true;
-			insideArgsOpenedParen = true;
-			type.push(token , DelimiterSpace );
-			return this;
-		}
-	} else { 
-		if ( !argsOpened && isDelimiterOpened(tokenDelimiter)) {
-			argsOpened = true;
-			insideArgsOpenedParen = true;
-			return this;			
-		}
-	}
-	
-	// If the args are already closed and we get another close expression, then just return ourselves
-	// This occurs in the case of nested array arguments within constructors
-	if ( argsClosed && (tokenDelimiter == DelimiterCloseParen)){
-		fIsComplete = true;
-		return this;
-	}
-	
-	// If the arguments are closed and we receive a { then this is an inner class declaration, e.g.
-	// new javax.swing.table.DefaultTableModel(){}
-	// This can't be processed by us so we need to throw an exception
-	if (argsClosed && tokenDelimiter == DelimiterOpenElipse ) {
-		throw new CannotProcessInnerClassesException();
-	}
-
-	// If the args are opened and a token was supplied then it must be an argument
-	if (argsOpened){
-		// If we already have an incomplete argument then this may be a constructor, a static reference, etc...
-		// and we should forward the request to the argument
-		Expression openArgument = null;
-		if ( arguments.size() > 0 ){
-			openArgument = (Expression)arguments.get(arguments.size()-1);
-			if ( !openArgument.isComplete() ) {
-				openArgument.push(token,tokenDelimiter);
-				// If the argument is complete and we received a ) then the constructor is complete
-				// or if we receive a } and are an array we are complete
-				if ( openArgument.isComplete() && isDelimiterClosed(tokenDelimiter) ){
-					argsClosed = true;
-				}
-				return this;
-			} 
-		}
-			
-		Expression newArgument = null;
-		// If we are not already inside the open arg and we get another open paren this is probably a cast
-		// or some kind of statement, and OperMinus is probably the start of a number
-		// If the args are not already open we must be opened with either a { or a ( depending on whether we are an array or not
-		// however if the args are opened already and we receive a ( then this is the start of a new statement
-//		if ((!insideArgsOpenedParen && isDelimiterOpened(tokenDelimiter)) || tokenDelimiter == DelimiterOpenParen){
-		if (tokenDelimiter == DelimiterOpenElipse || tokenDelimiter == DelimiterOpenParen){
-			insideArgsOpenedParen = true;
-			newArgument = new Statement(fClassLoader).push(token,tokenDelimiter);
-			if ( newArgument instanceof ArrayArguments ) {
-				((ArrayArguments)newArgument).setType(type);
-			}
-			newArgument = new MessageArgument(newArgument);
-			arguments.add(newArgument);
-
-		}
-		
-		// Start of a possible string or number or character
-		if ( ( token.length > 0 || tokenDelimiter == DelimiterQuote || tokenDelimiter == DelimiterSingleQuote) || tokenDelimiter == OperMinus ){
-			newArgument = new Statement(fClassLoader).push(token,tokenDelimiter);
-			newArgument = new MessageArgument(newArgument);
-			arguments.add(newArgument);
-		}
-		// If the token after the argument is a ) then the message is being closed
-		if ( !insideArgsOpenedParen || argumentsAreComplete() && isDelimiterClosed(tokenDelimiter) ) {
-			argsClosed = true;
-			return this;
-		}
-		if ( insideArgsOpenedParen && isDelimiterClosed(tokenDelimiter) ) {
-			insideArgsClosedParen  = true;
-			return this;
-		}
-
-		// If the token after the argument is a , or a ' ' then the argument is being closed
-		if ( tokenDelimiter == DelimiterComma || tokenDelimiter == DelimiterSpace ) {
-			// If our arguments are closed then we must be complete.  We need to signal the fact we are closed
-			// otherwise we will not be processed correctly if we are part of a stack 
-			if ( argsClosed ) {
-				fIsComplete = true;
-			}			
-			return this;
-		}
-		
-		// If we receive a close bracket then we are closed as long as the last argument is closed
-		if(argsOpened &&  isDelimiterClosed(tokenDelimiter)){
-			// No parms - we are a closed constructor
-			if(arguments.size() == 0){
-				argsClosed = true;
-				return this;
-			} 
-		}
-		
-		// If our last argument is closed and receive a ) and we have no new argument then we are closed
-		if (tokenDelimiter == DelimiterCloseParen && newArgument == null){
-			Expression lastArgument = (Expression)arguments.get(arguments.size()-1);
-			if ( lastArgument.isComplete() ) {
-				argsClosed = true;
-				return this;
-			}
-		}			
-				
-		// Otherwise the new argument is stil processing.  Return it
-		return newArgument;
-	}
-
-	return this;
-}
-protected boolean argumentsAreComplete(){
-	if ( arguments.size() == 0) return true;
-	return ((Expression)arguments.get(arguments.size()-1)).isComplete();
-}
-public String toString(){
-
-	java.io.StringWriter writer = new java.io.StringWriter();
-	writer.write("Constructor \""); //$NON-NLS-1$
-	if ( type != null ) {
-		writer.write(type.typeWriter.toString());
-	} else {
-		writer.write("UNTYPED"); //$NON-NLS-1$
-	}
-	for (int i = 0; i < arguments.size() ; i++){
-		writer.write(" Arg("); //$NON-NLS-1$
-		writer.write("" + (i+1)); //$NON-NLS-1$
-		writer.write(") = "); //$NON-NLS-1$
-		writer.write(arguments.get(i).toString());
-	}
-	
-	return writer.toString();
-
-}
-
-/**
- * This is never primitive
- */
-public boolean isPrimitive() {
-	return false;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/EvaluationException.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/EvaluationException.java
deleted file mode 100644
index 1d97cda..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/EvaluationException.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: EvaluationException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.lang.reflect.InvocationTargetException;
-
-/**
- * This is an InitializationStringEvaluationException, but
- * in addition, the exception that it wrappers is what should be
- * returned. This means it was a valid exception, parsing had
- * gone fine, but it was an evaluation that occured. This is
- * distinguished from the straight InitializationStringEvaluationException,
- * which means some error during parsing and evaluation.
- * 
- * Note: InvocationTargetExceptions will be unwrappered to the true exception.
- */
-public class EvaluationException extends InitializationStringEvaluationException {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -6997239021885310986L;
-
-	/**
-	 * Constructor for ReturnableException.
-	 * @param exc
-	 */
-	public EvaluationException(Throwable exc) {
-		super(exc instanceof InvocationTargetException ? ((InvocationTargetException) exc).getTargetException() : exc);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Expression.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Expression.java
deleted file mode 100644
index 5e7ec38..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Expression.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Expression.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.util.*;
-/**
- * Insert the type's description here.
- * Creation date: (11/01/00 8:46:44 PM)
- * @author: Administrator
- */
-public abstract class Expression implements IParserConstants {
-	protected Expression currentExpression;
-	protected List fExpressionStack;
-	protected ClassLoader fClassLoader;
-	public int parenthesisLevel = 0;
-/** Compare the two char arrays
- */
-public static boolean compare(char[] from , char[] to){
-
-	return Arrays.equals(from, to);
-}
-/**
- * Expression constructor comment.
- * Note: If any exceptions that are due to evaluation, and not due to some
- * invalid state, then the exception should be wrappered in an EvaluationException,
- * and the EvaluationException thrown instead. This way we can distinquish between
- * valid exceptions that result evaluations (such as null pointer exceptions) from
- * parser errors due to string is too complicated.
- */
-public abstract Object evaluate() throws Exception;
-
-public abstract boolean isComplete();
-/**
- * Return a class type that the expression syntactically would produce.
- * For example, if a field is of type XYZ, return XYZ, even though
- * the value of the field may be SubXYZ where SubXYZ is a subclass of XYZ.
- */
-public abstract Class getTypeClass() throws Exception;
-/**
- * In evaluation phase, get the type class from the expression.
- * If typeclass not found, then a ClassCastException is thrown.
- * @param exp To getTypeClass from
- * @return type class.
- * @throws Exception ClassNotFoundException if type not found.
- */
-public Class getEvaluationTypeClass(Expression exp) throws Exception {
-	Class cls = exp.getTypeClass();
-	if (cls == null)
-		throw new EvaluationException(new ClassNotFoundException(exp.getTypeClassName()));
-	return cls;
-}
-
-/**
- * @return Type name that should be returned from this expression.
- */
-protected abstract String getTypeClassName();
-
-public boolean isNumber(char[] token){
-
-	if ( token.length == 0) return false;
-	// See whether the token is a number
-	int parsePosition = 0;
-	// Take into account it may start with a - sign, e.g. -1
-	if ( token[0] == '-' ) parsePosition = 1;
-	for (int i = parsePosition; i < token.length ; i++){
-		// If the next token is a digit return true
-		// Other things like decimals or primitive types, e.g. 2.2 or 2.2f are 
-		// handled by NumberLiteral
-		return Character.isDigit(token[i]);
-	}
-	return true;
-}
-public boolean isPop(){
-	return false;
-}
-protected void popExpressionStack(){
-
-	if ( fExpressionStack != null && fExpressionStack.size() > 0 ) {
-		currentExpression = (Expression) fExpressionStack.remove(fExpressionStack.size()-1);
-	}	
-}
-protected void pushExpressionStack(Expression anExpression){
-
-	if ( fExpressionStack == null ) fExpressionStack = new ArrayList(2);
-	// The current expression should go onto the stack
-	fExpressionStack.add(currentExpression);
-	// The current expression is replaced with the argument
-	currentExpression = anExpression;
-	
-}	
-
-void setClassLoader(ClassLoader aClassLoader){
-}
-
-/**
- * Push an expression onto us
- * Return the new expression onto which subsequent token should be pushed
- */
-public abstract Expression push(char[] token , char tokenDelimiter);
-
-/**
- * Answer if this expression results in a primitive.
- */
-public abstract boolean isPrimitive() throws Exception;
-
-public String toString(int depth, boolean aBreak){
-	StringBuffer buffer = new StringBuffer();
-	if ( aBreak ) {
-		buffer.append(System.getProperty("System.lineSeparator")); //$NON-NLS-1$
-	}
-	for(int i=0;i<depth;i++){
-		buffer.append(" "); //$NON-NLS-1$
-	}
-	buffer.append(toString());
-	return buffer.toString();
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Field.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Field.java
deleted file mode 100644
index eae848c..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Field.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Field.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-/**
- * Insert the type's description here.
- * Creation date: (11/05/00 10:39:28 PM)
- * @author: Administrator
- */
-public class Field extends Expression {
-	public boolean isComplete;
-	protected java.lang.reflect.Field fField;
-	public Expression receiver;
-	public String fieldName;
-	protected Class fResultType;
-	
-public Field(Expression aReceiver , char[] token , ClassLoader aClassLoader){
-
-	receiver = aReceiver;
-	if ( token.length > 0 ){
-		fieldName = new String(token);
-	}
-
-}
-public boolean isComplete(){
-	return isComplete;
-}
-
-/**
- * Send the message to the receiver
- */
-public Object evaluate() throws Exception {
-	Object receiverValue = receiver.evaluate();	// So if it fails, we get an evaluation exception going on up.
-	try {
-		cacheField();		
-		return fField.get(receiverValue);
-	} catch (Exception e) {
-		throw new EvaluationException(e);	// Any exception at this point is an evaluation exception.
-	}
-}
-
-/**
- * Get the field from reflection.
- */
-protected void cacheField() throws Exception {
-	if (fField == null) {
-		Class aReceiverClass = getEvaluationTypeClass(receiver);
-		fField = aReceiverClass.getField(fieldName);
-		fResultType = fField.getType();		
-	}
-}
-
-/**
- * The result type is the type of the field.
- */
-public Class getTypeClass() throws Exception {
-	if ( fResultType == null ) {
-		cacheField();
-	}
-	return fResultType;
-}
-
-protected String getTypeClassName() {
-	return "";	// If we got this far, we don't know what it is. //$NON-NLS-1$
-}
-/**
- * push method comment.
- */
-public Expression push(char[] token, char tokenDelimiter) {
-
-	// If the delimiter is a ( then this is the start of a message
-	if ( tokenDelimiter == DelimiterOpenParen ) {
-		return new Message(this , token , fClassLoader);
-	}
-
-	// If the delimiter is a . then this is a field
-	if (token.length > 0  && ( tokenDelimiter == DelimiterPeriod || tokenDelimiter == DelimiterSpace
-	|| tokenDelimiter == DelimiterComma)) {
-		isComplete = true;
-		return new Field(this , token , fClassLoader);
-		
-	}
-	
-	if(fieldName != null && tokenDelimiter == DelimiterComma){
-		isComplete = true;
-		return this;
-	}
-	
-	// If we have no delimiter or a close paren then we have just received the field name
-	if (!isComplete && fieldName == null) {
-		fieldName = new String(token);
-		return this;
-	}
-	
-	if(tokenDelimiter == BitOR || tokenDelimiter == BitAND){
-		isComplete = true;
-		PrimitiveOperation result = new PrimitiveOperation(this,tokenDelimiter);
-		return result;
-	}
-	
-	// Ignore spaces as this maybe padding between the field and the next valid token
-	if(token.length == 0 && tokenDelimiter == ' ') return this;
-
-	throw new RuntimeException(java.text.MessageFormat.format(ProxyInitParserMessages.getString(ProxyInitParserMessages.UNEXPECTED_TOKEN), new Object[] {new StringBuffer(token.length+1).append(token).append(tokenDelimiter).toString()}));
-	
-}
-public String toString(){
-
-	java.io.StringWriter writer = new java.io.StringWriter();
-	writer.write("Field Name=\""); //$NON-NLS-1$
-	if ( fieldName != null ) {
-		writer.write(fieldName);
-	} else {
-		writer.write("UNNAMED"); //$NON-NLS-1$
-	}
-	writer.write("\" Receiver="); //$NON-NLS-1$
-	if ( receiver != null ){
-		writer.write(receiver.toString());
-	} else {
-		writer.write("NONE"); //$NON-NLS-1$
-	}
-	return writer.toString();
-
-}
-
-/**
- * Test the field type to determine if primitive or not.
- */
-public boolean isPrimitive() throws Exception {
-	cacheField();
-	return getTypeClass().isPrimitive();
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/IParserConstants.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/IParserConstants.java
deleted file mode 100644
index 520c22f..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/IParserConstants.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: IParserConstants.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-/**
- * Constants for the parser.
- * Creation date: (11/05/00 9:37:45 PM)
- * @author: Administrator
- */
-public interface IParserConstants {
-	// Define the delimiters
-	public static final char DelimiterSpace = ' ';
-	public static final char DelimiterPeriod = '.';
-	public static final char DelimiterOpenParen = '(';
-	public static final char DelimiterCloseParen = ')';
-	public static final char DelimiterComma = ',';
-	public static final char DelimiterQuote = '"';
-	public static final char DelimiterEscape = '\\';
-	public static final char DelimiterSingleQuote = '\'';
-	public static final char DelimiterOpenElipse = '{';
-	public static final char DelimiterCloseElipse = '}';	
-	public static final char DelimiterOpenSquareBrace = '[';
-	public static final char DelimiterCloseSquareBrace = ']';
-	// Define the math functions
-	public static final char OperPlus = '+';
-	public static final char OperMinus = '-';
-	public static final char OperMultiply = '*';
-	public static final char OperDivide = '/';
-	// Define the primitive functions
-	public static final char BitOR = '|';
-	public static final char BitAND = '&';
-	
-	// Define constants
-	public static final char[] ConstantNew = new char[] { 'n' , 'e' , 'w' };
-	public static final char[] ConstantTrue = new char[] { 't' , 'r' , 'u' , 'e' };
-	public static final char[] ConstantFalse = new char[] { 'f' , 'a' , 'l' , 's' , 'e' };
-	public static final char[] ConstantNull = new char[] { 'n' , 'u' , 'l' , 'l' };
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/InitializationStringEvaluationException.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/InitializationStringEvaluationException.java
deleted file mode 100644
index 4cf3ca6..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/InitializationStringEvaluationException.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: InitializationStringEvaluationException.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-
-public class InitializationStringEvaluationException extends Exception {
-	
-	
-/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -8633390926210276727L;
-public InitializationStringEvaluationException(Throwable exc){
-	super(exc);
-}
-public Throwable getOriginalException(){
-	return getCause();
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/InitializationStringParser.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/InitializationStringParser.java
deleted file mode 100644
index 893ce84..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/InitializationStringParser.java
+++ /dev/null
@@ -1,300 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: InitializationStringParser.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.util.ArrayList;
-/**
- * Insert the type's description here.
- * Creation date: (11/01/00 8:53:45 PM)
- * @author: Administrator
- */
-public class InitializationStringParser implements IParserConstants {
-	protected ClassLoader fClassLoader;
-	protected boolean isComplete = false;
-	protected String fInitString;
-	protected int fSourceLength;
-	protected char[] fSource;
-	protected int fSourcePosition = -1;
-	private char[] fCurrentToken;
-	private char fCurrentTokenDelimiter = 0;
-	protected ArrayList fExpressionStack = new ArrayList(4);
-	protected Expression fExpression;
-/**
- * InitializationStringParser constructor comment.
- */
-public InitializationStringParser(String initString){
-
-	fInitString = initString;
-	fSource = initString.toCharArray();
-	fSourceLength = fSource.length;
-
-}
-/** Look for a known token
- */
-protected void createNextToken(){
-
-	fCurrentTokenDelimiter = 0;
-	if ( fSourcePosition >= fSourceLength - 1 ) {
-		isComplete = true;
-		return;
-	}
-
-	fSourcePosition++;
-	// If we are not in a token then look for " " or else for a period
-	char[] fCurrentTokenSource = new char[fSourceLength];
-	int i = 0;
-	scanner : for ( ; fSourcePosition < fSourceLength ; fSourcePosition++ , i++ ){
-		// Advance the source position so when finding the next token we skip over the '.' or ' '
-		// Record the delimiter that was found
-		switch ( fSource[fSourcePosition] ) {
-			case DelimiterPeriod: {
-				fCurrentTokenDelimiter = DelimiterPeriod;
-				break scanner;
-			}
-			case DelimiterOpenParen: {
-				fCurrentTokenDelimiter = DelimiterOpenParen;
-				break scanner;
-			}
-			case DelimiterCloseParen: {
-				fCurrentTokenDelimiter = DelimiterCloseParen;
-				break scanner;
-			}
-			case DelimiterComma: {
-				fCurrentTokenDelimiter = DelimiterComma;
-				break scanner;
-			}
-			case DelimiterSpace: {
-				fCurrentTokenDelimiter = DelimiterSpace;
-				break scanner;
-			}
-			case DelimiterQuote: {
-				fCurrentTokenDelimiter = DelimiterQuote;
-				break scanner;
-			}
-			case DelimiterSingleQuote: {
-				fCurrentTokenDelimiter = DelimiterSingleQuote;
-				break scanner;
-			}			
-			case DelimiterEscape: {
-				fCurrentTokenDelimiter = DelimiterEscape;
-				break scanner;
-			}
-			case DelimiterOpenElipse:{
-				fCurrentTokenDelimiter = DelimiterOpenElipse;
-				break scanner;
-			}
-			case DelimiterOpenSquareBrace:{
-				fCurrentTokenDelimiter = DelimiterOpenSquareBrace;
-				break scanner;
-			}
-			case DelimiterCloseSquareBrace:{
-				fCurrentTokenDelimiter = DelimiterCloseSquareBrace;
-				break scanner;
-			}			
-			case DelimiterCloseElipse:{
-				fCurrentTokenDelimiter = DelimiterCloseElipse;
-				break scanner;
-			}				
-			// Do the math functions
-			case OperPlus: {
-				fCurrentTokenDelimiter = OperPlus;
-				break scanner;
-			}
-			case OperMinus: {
-				fCurrentTokenDelimiter = OperMinus;
-				break scanner;
-			}
-			case OperMultiply: {
-				fCurrentTokenDelimiter = OperMultiply;
-				break scanner;
-			}
-			case OperDivide: {
-				fCurrentTokenDelimiter = OperDivide;
-				break scanner;
-			}
-			// Do the primitive BitWise operations
-			case BitOR: {
-				fCurrentTokenDelimiter = BitOR;
-				break scanner;
-			}
-			case BitAND: {
-				fCurrentTokenDelimiter = BitAND;
-				break scanner;
-			}			
-			default: {
-				fCurrentTokenSource[i] = fSource[fSourcePosition];
-			}
-		}
-	}
-
-	// Push the token onto the stack for later decoding
-	if ( i >= 1 ) {
-		fCurrentToken = new char[i];
-		System.arraycopy( fCurrentTokenSource , 0 , fCurrentToken , 0 , i );
-	} else {
-		fCurrentToken = new char[0];
-	}
-
-}
-/** Answer the result of evaluating the expression
- */
-public Object evaluate() throws InitializationStringEvaluationException {
-
-	try {
-		return fExpression.evaluate();
-	} catch (java.lang.reflect.InvocationTargetException e) {
-		throw new EvaluationException(e);
-	} catch (EvaluationException e) {
-		throw e;	// Don't loose these
-	} catch (Throwable e) {
-		throw new InitializationStringEvaluationException(e);
-	}
-
-}
-public static Object evaluate(String initString) throws InitializationStringEvaluationException {
-
-	return evaluate(initString,null);
-
-}
-public static Object evaluate(String initString,ClassLoader aClassLoader) throws InitializationStringEvaluationException {
-
-	InitializationStringParser parser = null;;
-	try {
-		parser = new InitializationStringParser(initString);
-		parser.setClassLoader(aClassLoader);
-		parser.parse();
-	} catch ( Throwable exc ) {
-		throw new InitializationStringEvaluationException(exc);
-	}		
-	return parser.evaluate();
-}
-
-/**
- * Return a parser already parsed. Use the default classloader (i.e. classloader that loaded InitializationStringParser).
- * 
- * @param initString
- * @return The parser, already parsed.
- * @throws InitializationStringEvaluationException
- */
-
-public static InitializationStringParser createParser(String initString) throws InitializationStringEvaluationException {
-	return createParser(initString, null);
-}
- 
-/**
- * Return a parser already parsed. Use the given classloader.
- * 
- * @param initString
- * @param classLoader
- * @return The parser, already parsed.
- * @throws InitializationStringEvaluationException
- */
-public static InitializationStringParser createParser(String initString, ClassLoader classLoader) throws InitializationStringEvaluationException {
-
-	try {
-		InitializationStringParser parser = new InitializationStringParser(initString);
-		parser.setClassLoader(classLoader);
-		parser.parse();
-		return parser;
-	} catch ( Throwable exc ) {
-		throw new InitializationStringEvaluationException(exc);
-	}
-
-}
-
-/** Analyze the string
- */
-public void parse(){
-	
-	createFirstExpression();
-	int i =1;
-	while ( true ){
-		createNextToken();
-		if ( isComplete ) {
-			// If the current expression is incomplete it must be completed 
-			// by the end, which is basically the equiavlent of a;
-			return;
-		} else  {
-			i++;
-			Expression result = fExpression.push( fCurrentToken , fCurrentTokenDelimiter );
-			// If the result if a push then push the stack
-			if ( result.isComplete() ) {
-				popExpressionStack();
-			} else if ( result != fExpression ) {
-				pushExpressionStack(result);
-			}
-		}
-	}
-}
-
-/**
- * Answer if the string results in a primitive.
- */
-public boolean isPrimitive() throws InitializationStringEvaluationException {
-	try {
-		return fExpression.isPrimitive();
-	} catch (Exception e) {
-		throw new InitializationStringEvaluationException(e);
-	}
-}
-
-public Class getExpectedType() throws InitializationStringEvaluationException {
-	try {
-		return fExpression.getTypeClass();
-	} catch (Exception e) {
-		throw new InitializationStringEvaluationException(e);
-	}
-}
-
-/* Pop the top expression off the stack
- */
-protected void popExpressionStack(){
-
-	if ( fExpressionStack.size() > 0 ) {
-		fExpression = (Expression) fExpressionStack.remove(fExpressionStack.size()-1);
-	}	
-}
-/* Push the expression onto the stack
- */
-protected void pushExpressionStack(Expression anExpression){
-
-	// The current expression should go onto the stack
-	fExpressionStack.add(fExpression);
-	// The current expression is replaced with the argument
-	fExpression = anExpression;
-	
-}
-protected void createFirstExpression(){
-	if ( fExpression == null ) {
-		fExpression = new Statement(fClassLoader);
-	};
-}
-public void setClassLoader(ClassLoader aClassLoader){
-	fClassLoader = aClassLoader;	
-}
-public String toString(){
-	StringBuffer writer = new StringBuffer();
-	writer.append("Parser. token=\""); //$NON-NLS-1$
-	if ( fCurrentToken != null ) {
-		writer.append(fCurrentToken);
-	} 
-	writer.append("\", delim=\""); //$NON-NLS-1$
-	writer.append(fCurrentTokenDelimiter);
-	writer.append("\", initString=\""); //$NON-NLS-1$
-	writer.append(fInitString);
-	return writer.toString();	
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Message.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Message.java
deleted file mode 100644
index be1e072..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Message.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Message.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Iterator;
-
-import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;
-import org.eclipse.jem.internal.proxy.common.MethodHelper;
-
-public class Message extends Expression {
-	protected boolean trailingPeriod = false;
-	protected Method fMethod;
-	public Expression receiver;
-	public String message;
-	public boolean argsClosed = false;
-	public boolean insideArgsOpenedParen = false;
-	public boolean insideArgsClosedParen = false;
-	protected boolean isComplete = false;
-	public ArrayList arguments = new ArrayList(2);
-	
-public Message(Expression aReceiver , char[] token , ClassLoader aClassLoader){
-	receiver = aReceiver;
-	message = new String(token);
-	fClassLoader = aClassLoader;
-}
-public boolean isComplete(){
-	return isComplete;
-}
-
-/**
- * Send the message to the receiver
- */
-public Object evaluate() throws Exception {
-	cacheMethod();
-	
-	// Get the array of arguments
-	Object[] args = new Object[arguments.size()];
-	Iterator itr = arguments.iterator();
-	for (int i = 0; i < arguments.size() ; i++){
-		Expression anExpression = (Expression)itr.next();
-		args[i] = anExpression.evaluate();
-	}
-	
-	Object receiverValue = receiver.evaluate();	// So if evaluation exception thrown, we don't wrapper again.
-	
-	try {
-		return fMethod.invoke(receiverValue, args);
-	} catch (Exception e) {
-		throw new EvaluationException(e);
-	}
-}
-
-/**
- * Cache the message
- */
-protected void cacheMethod() throws Exception {
-	if (fMethod == null) {
-		Class[] argTypes = new Class[arguments.size()];
-		Iterator itr = arguments.iterator();
-		for (int i=0; i<argTypes.length; i++)
-			argTypes[i] = getEvaluationTypeClass((Expression) itr.next());
-			
-		try {
-			fMethod = MethodHelper.findCompatibleMethod(getEvaluationTypeClass(receiver), message, argTypes);
-		} catch (NoSuchMethodException e) {
-			throw new EvaluationException(e);
-		} catch (AmbiguousMethodException e) {
-			throw new EvaluationException(e);
-		}
-	}
-}
-
-
-/**
- * getTypeClass method comment.
- */
-public Class getTypeClass() throws Exception {
-	cacheMethod();
-	return fMethod.getReturnType();
-}
-
-protected String getTypeClassName() {
-	return "";	// If we got this far, we don't know what it is. //$NON-NLS-1$
-}
-/**
- * push method comment.
- */
-public Expression push(char[] token, char tokenDelimiter) {
-	
-	// If we are closed and we receive a . with no token then remember this
-	if ( argsClosed && !trailingPeriod && tokenDelimiter == DelimiterPeriod && token.length == 0 ) {
-		trailingPeriod = true;
-		return this;
-	}
-	// If we have been closed with a . and we receive a . then we are a field
-	if ( trailingPeriod && tokenDelimiter == DelimiterPeriod ) {
-		return new Field(this,token,fClassLoader);
-	}
-	// If we have been closed with a . and we receive a ( we are a message
-	if ( trailingPeriod && tokenDelimiter == DelimiterOpenParen ) {
-		return new Message(this,token,fClassLoader);
-	}
-	
-	// If we have been closed and we receive a , or a ) we are complete - this is a structural token intended for someone else,
-	// probably a message argument lower down the stack
-	if (argsClosed && (tokenDelimiter == DelimiterComma || tokenDelimiter == DelimiterCloseParen)){
-		isComplete = true;
-		return this;
-	}
-	
-
-	// If the args are opened and a token was supplied then it must be an argument
-	//if ( argsOpened && ( tokenDelimiter == DelimiterCloseParen || tokenDelimiter == DelimiterComma || 
-	//tokenDelimiter == DelimiterSpace || tokenDelimiter == DelimiterQuote || tokenDelimiter == DelimiterPeriod)) {
-	if (!argsClosed){	
-		if ( arguments.size() > 0 ){
-			Expression openArgument = (Expression)arguments.get(arguments.size()-1);
-			if ( !openArgument.isComplete() ) {
-				openArgument.push(token,tokenDelimiter);
-				// If the argument is complete and we received a ) then the message is complete
-				if ( openArgument.isComplete() && tokenDelimiter == DelimiterCloseParen){
-					argsClosed = true;
-				}
-				return this;
-			}
-		}	
-		
-		// We must have a new argument - process accordingly	
-		Expression newArgument = null;
-		if (!insideArgsOpenedParen && tokenDelimiter == DelimiterOpenParen){
-			insideArgsOpenedParen = true;
-			newArgument = new Statement(fClassLoader).push(token,tokenDelimiter);
-			newArgument = new MessageArgument(newArgument);
-			arguments.add(newArgument);
-
-		}
-		if ( newArgument == null && (token.length > 0 || tokenDelimiter == DelimiterQuote || tokenDelimiter == DelimiterSingleQuote || tokenDelimiter == DelimiterOpenParen )) {
-			newArgument = new Statement(fClassLoader).push(token,tokenDelimiter);
-			newArgument = new MessageArgument(newArgument);
-			arguments.add(newArgument);
-		}
-		// If the token after the argument is a ) then the message is being closed
-		if ( !insideArgsOpenedParen  && tokenDelimiter == DelimiterCloseParen ) {
-			argsClosed = true;
-			return this;
-		}
-		if ( insideArgsOpenedParen  && tokenDelimiter == DelimiterCloseParen ) {
-			insideArgsClosedParen  = true;
-			return this;
-		}
-
-		// If the token after the argument is a , or a ' ' then the argument is being closed
-		if ( tokenDelimiter == DelimiterComma || tokenDelimiter == DelimiterSpace ) {
-			return this;
-		}
-		
-		// Otherwise the new argument is stil processing.  Return it
-//		return newArgument;
-	}
-	
-	// If we don't have a message yet, then consume this one
-	if ( message.length() == 0 ) {
-		message = new String(token);
-		return this;
-	}	
-
-	return this;	
-}
-public String toString(){
-
-	java.io.StringWriter writer = new java.io.StringWriter();
-	writer.write("Msg Name=\""); //$NON-NLS-1$
-	if ( message != null ) {
-		writer.write(message);
-	} else {
-		writer.write("UNNAMED"); //$NON-NLS-1$
-	}
-	writer.write("\" Rcv=("); //$NON-NLS-1$
-	if ( receiver != null ){
-		writer.write(receiver.toString());
-	} else {
-		writer.write("NONE"); //$NON-NLS-1$
-	}
-	writer.write(')');
-	if ( arguments != null ) {
-		writer.write("Args(");		 //$NON-NLS-1$
-		Iterator iter = arguments.iterator();
-		int i=1;
-		while(iter.hasNext()){
-			writer.write(new Integer(i).toString());
-			writer.write('(');
-			writer.write(iter.next().toString());
-			writer.write("),");			 //$NON-NLS-1$
-		}
-		writer.write(')');				
-	}
-	
-	return writer.toString();
-
-}
-
-/**
- * Is the message result a primitive.
- */
-public boolean isPrimitive() throws Exception {
-	cacheMethod();
-	return fMethod.getReturnType().isPrimitive();
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/MessageArgument.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/MessageArgument.java
deleted file mode 100644
index 89f8584..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/MessageArgument.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: MessageArgument.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.io.StringWriter;
-import java.util.*;
-
-public class MessageArgument extends Expression {
-
-	protected boolean isComplete = false;
-	Expression fExpression;
-	ArrayList fExpressionStack = new ArrayList();
-
-public MessageArgument(Expression anExpression){
-	fExpression = anExpression;
-}
-	
-public Object evaluate() throws Exception {
-	
-	return fExpression.evaluate();
-	
-}	
-
-public Class getTypeClass() throws Exception {
-	
-	return fExpression.getTypeClass();
-	
-}
-
-protected String getTypeClassName() {
-	return fExpression.getTypeClassName();
-}
-public boolean isComplete(){
-	return isComplete || fExpression.isComplete();
-}
-	
-public Expression push(char[] token , char delimiter){
-
-	// Even if our expression is complete and we receive anything other than a , then the expression must process it as this may be a field or message
-	// that is being sent to the expression to make up a complex argument	
-	Expression result = fExpression.push(token,delimiter);
-	// If the result if a push then push the stack
-	if ( result != fExpression ) {
-		pushExpressionStack(result);
-	} else if (result.isComplete()){
-		// If our expression is complete, we are completed with a ) pop the stack so the previous expression can process us
-		if (delimiter == DelimiterCloseParen ) {
-			isComplete = true;
-			popExpressionStack();
-		} else if (delimiter == DelimiterComma || delimiter == DelimiterQuote ) {
-			// If we receive a comma we pop the stack so the previous expression can process us but we don't flag us as complete
-			popExpressionStack();
-			// unless our expression is some array argument AND it is complete AND we have a close elipse }
-		} else if ( delimiter == DelimiterCloseElipse ) {
-			popExpressionStack();
-			if ( fExpression instanceof ArrayArguments ) {
-				isComplete = true;
-			}
-		}
-	}
-	return this;
-}	
-	
-/* Pop the top expression off the stack
- */
-protected void popExpressionStack(){
-
-	if ( fExpressionStack.size() > 0 ) {
-		Expression lastExpression = (Expression)fExpressionStack.get(fExpressionStack.size() - 1);
-		if ( !lastExpression.isComplete() ) {
-			fExpression = (Expression) fExpressionStack.remove(fExpressionStack.size() - 1);
-		} else { 
-			isComplete = true;
-		} 
-	} else {
-		isComplete = true;
-	}
-}
-
-/* Push the expression onto the stack
- */
-protected void pushExpressionStack(Expression anExpression){
-
-	// The current expression should go onto the stack
-	fExpressionStack.add(fExpression);
-	// The current expression is replaced with the argument
-	fExpression = anExpression;
-	
-}
-
-public boolean isPrimitive(){
-	return false;
-}
-public String toString(){
-	StringWriter writer = new StringWriter();
-	writer.write("Arg("); //$NON-NLS-1$
-	if ( fExpression != null ) {
-		writer.write(fExpression.toString());
-	}
-	writer.write(")"); //$NON-NLS-1$
-	return writer.toString();
-}
-public void contributeArgumentNumber(List argumentNumberList){
-
-	if ( fExpression instanceof ArrayArguments ) {
-		((ArrayArguments)fExpression).contributeArgumentNumber(argumentNumberList);
-	}	
-	
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/NullLiteral.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/NullLiteral.java
deleted file mode 100644
index e120179..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/NullLiteral.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-
-import org.eclipse.jem.internal.proxy.common.MethodHelper;
-
-/*
- *  $RCSfile: NullLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-public class NullLiteral extends Expression {
-public NullLiteral(){
-}
-/**
- * evaluate method comment.
- */
-public Object evaluate() {
-	return null;
-}
-/**
- * evaluate method comment.
- */
-public Class getTypeClass(){
-	return MethodHelper.NULL_TYPE;
-}
-
-protected String getTypeClassName() {
-	return MethodHelper.NULL_TYPE.getName();
-}
-/**
- * true or false cannot consume any kind of expression so we must return null
- */
-public Expression push(char[] token , char delimiter){
-	return null;
-}
-
-public boolean isComplete(){
-	return true;
-}
-
-/**
- * Null is not primitive
- */
-public boolean isPrimitive() {
-	return false;
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/NumberLiteral.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/NumberLiteral.java
deleted file mode 100644
index 59e0e81..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/NumberLiteral.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: NumberLiteral.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-public class NumberLiteral extends Expression {
-	protected String numberString = ""; //$NON-NLS-1$
-	protected boolean isComplete = false;
-	protected Class numberClass = Integer.TYPE;
-	protected int exponentFlag = NO_EXPONENT;
-	
-	protected static final int
-		NO_EXPONENT = 0,
-		HAS_EXPONENT = 1,
-		HAS_EXPONENT_MINUS = 2;
-/**
- * evaluate method comment.
- */
-public NumberLiteral(){
-}
-/**
- * evaluate method comment.
- */
-public Object evaluate() throws Exception {
-	try {
-		// Return a number of the correct instance
-		if (numberClass == Float.TYPE){
-			return new Float(Float.parseFloat(numberString));
-		} else if (numberClass == Long.TYPE ) {
-			return Long.decode(numberString);
-		} else if (numberClass == Double.TYPE ){
-			return new Double(Double.parseDouble(numberString));
-		} else
-			return Integer.decode(numberString);
-	} catch (Exception e) {
-		throw new EvaluationException(e);
-	}
-	
-}
-public boolean isComplete(){
-	return isComplete;
-}
-
-/**
- * Return the type of number that we are.
- */
-public Class getTypeClass(){
-	return numberClass;
-}
-
-protected String getTypeClassName() {
-	return numberClass != null ? numberClass.getName() : ""; //$NON-NLS-1$
-}
-/**
- * If the delimiter is an operation such as a +,-,/,* then we can consume it
- * If the delimiter is period and we don't already have one then it is the decimal portion of us
- */
-public Expression push(char[] token , char delimiter){
-		
-	// Close brackets complete use		
-	if(delimiter == DelimiterCloseParen || delimiter == DelimiterComma || delimiter == DelimiterCloseElipse){
-		isComplete = true;
-	}
-	
-	if (delimiter == OperMinus && numberString.length() == 0)
-		numberString+=OperMinus;	// No digits yet, but we have a minus sign, so add to accumulating number.
-		
-	numberString += processNumberToken(token);	
-	
-	// If we have part of a number and are asked to do some arithmetic throw an 
-	// error that this has not been coded yet, except minus could be part of an exponent.
-	if(numberString.length() > 0 && token.length > 1) {
-		switch(delimiter){
-			case OperMinus:
-				if (exponentFlag == HAS_EXPONENT) {
-					exponentFlag = HAS_EXPONENT_MINUS;
-					numberString += OperMinus;
-					break;
-				}
-			case OperPlus:			
-			case OperMultiply:
-			case OperDivide:
-			{
-				throw new RuntimeException("Can't do arithmetic yet"); //$NON-NLS-1$
-			}
-		}
-	}
-	
-	if (delimiter == DelimiterPeriod){
-		numberClass = Double.TYPE;	// A decimal makes it double.
-		numberString += DelimiterPeriod;
-	}	
-
-	if(delimiter == BitOR || delimiter == BitAND){
-			Expression result = new PrimitiveOperation(this,delimiter);
-			isComplete = true;
-			return result;
-	}
-
-	return this;
-	
-}
-protected String processNumberToken(char[] token){
-	
-	for (int i=0; i<token.length; i++)
-		if (token[i] == 'E' || token[i] == 'e') {
-			numberClass = Double.TYPE;	// Definitely a floating because of this.
-			exponentFlag = HAS_EXPONENT;
-			break;
-		}
-			
-	// The token could be a number, e.g. 10 or 5 or could be qualified with a primitive
-	// suffix, e.g. 10l or 5f
-	char[] numberToken = token;
-	if ( token.length > 0 ) {
-		switch(token[token.length - 1]){
-			case 'F': 			
-			case 'f':
-				numberClass = Float.TYPE;
-				numberToken = new char[token.length - 1];
-				System.arraycopy(token,0,numberToken,0,numberToken.length);
-				isComplete = true;
-				break;
-			case 'L':			
-			case 'l':
-				numberClass = Long.TYPE;
-				numberToken = new char[token.length - 1];
-				System.arraycopy(token,0,numberToken,0,numberToken.length);				
-				isComplete = true;
-				break;
-			case 'D':			
-			case 'd':
-				numberClass = Double.TYPE;
-				numberToken = new char[token.length - 1];
-				System.arraycopy(token,0,numberToken,0,numberToken.length);				
-				isComplete = true;
-				break;
-		}
-	}
-			
-	return new String(numberToken);
-}
-public String toString(){
-
-	java.io.StringWriter writer = new java.io.StringWriter();
-	writer.write("Number \""); //$NON-NLS-1$
-	writer.write(numberString);
-	writer.write("\""); //$NON-NLS-1$
-	return writer.toString();
-
-}
-
-/**
- * Number literals are primitive
- */
-public boolean isPrimitive() {
-	return true;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/PrimitiveOperation.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/PrimitiveOperation.java
deleted file mode 100644
index 3ce254e..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/PrimitiveOperation.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * This is for primitive expressions that are optimized out the compiler such as bit or, bit and, etc..
-   */
-package org.eclipse.jem.internal.proxy.initParser;
-
-import java.text.MessageFormat;
-
-/*
- *  $RCSfile: PrimitiveOperation.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-public class PrimitiveOperation extends Expression {
-	
-	protected int operation;				// This can be BitOR or BitAND
-	protected Expression receiver;	// The left hand side of the expression
-	protected boolean isComplete = false;
-	
-	public PrimitiveOperation(Expression aReceiver, int anOperation){
-		receiver = aReceiver;
-		operation = anOperation;
-	}
-
-	public Object evaluate() throws Exception {
-		Object leftHandSide = receiver.evaluate();
-		Object rightHandSide = currentExpression.evaluate();
-		if (leftHandSide instanceof Integer && rightHandSide instanceof Integer) {
-			if(operation == BitOR) {
-				return new Integer(((Integer)leftHandSide).intValue() | ((Integer)rightHandSide).intValue());				
-			} else if(operation == BitAND) {
-				return new Integer(((Integer)leftHandSide).intValue() & ((Integer)rightHandSide).intValue());				
-			}
-		}
-		throw new RuntimeException(MessageFormat.format(ProxyInitParserMessages.getString("PrimitiveOperation.Evaluate.InvalidOperator_EXC_"), new Object[]{getOperDescription(), leftHandSide, rightHandSide}));		 //$NON-NLS-1$
-	}
-	protected String getOperDescription(){
-		if(operation == BitOR) return "|"; //$NON-NLS-1$
-		if (operation == BitAND) return "&";			 //$NON-NLS-1$
-		return "???"; //$NON-NLS-1$
-	}
-
-	public boolean isComplete() {
-		return isComplete;
-	}
-
-	public Class getTypeClass() throws Exception {
-		return Integer.TYPE;
-	}
-
-	protected String getTypeClassName() {
-		return Integer.TYPE.getName();
-	}
-
-	public Expression push(char[] token, char tokenDelimiter) {
-	
-		// Create a new statement if the argument is null ( we are always created with a receiver )
-		if(currentExpression == null && token.length > 0){
-			currentExpression = new Statement(fClassLoader).push(token,tokenDelimiter);
-			pushExpressionStack(currentExpression);
-			return this;
-		} 
-		
-		// Ignore whitespace
-		if(token.length == 0 && tokenDelimiter == ' ') return this;
-		
-		// If we have an argument we just keep pushing the expression onto this
-		if(currentExpression != null){
-			Expression result = currentExpression.push(token,tokenDelimiter);
-			if(result != currentExpression){
-				pushExpressionStack(result);
-			}
-		}
-		
-		if(currentExpression != null && currentExpression.isComplete()){
-			if(tokenDelimiter == DelimiterComma){
-				isComplete = true;
-				return this;
-			} else if (tokenDelimiter == DelimiterCloseParen){
-				if(receiver.parenthesisLevel > 0){
-					receiver.parenthesisLevel--;
-				} else {
-					isComplete = true;			
-					return this;		
-				}
-			}
-		}				
-	
-		return this;
-	}
-
-	public boolean isPrimitive() throws Exception {
-		return true;
-	}
-	
-	public String toString(){
-		StringBuffer buffer = new StringBuffer();
-		if (receiver != null) buffer.append(receiver.toString());
-		buffer.append(getOperDescription());
-		if (currentExpression != null) buffer.append(currentExpression.toString()); 
-		return buffer.toString();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/ProxyInitParserMessages.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/ProxyInitParserMessages.java
deleted file mode 100644
index bd6df5a..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/ProxyInitParserMessages.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: ProxyInitParserMessages.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-/**
- * General Proxy NLS Constants
- * Creation date: (4/13/00 10:46:58 AM)
- * @author: Administrator
- */
-public class ProxyInitParserMessages {
-	// Resource Bundle to use for basic Proxy NLS resources.
-	static private final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle("org.eclipse.jem.internal.proxy.initParser.messages"); //$NON-NLS-1$
-
-	// Keys for messages/strings within the resource bundle.
-	static public final String
-		UNEXPECTED_TOKEN = "UnexpectedToken_EXC_", //$NON-NLS-1$
-		STATEMENT_UNEXPECTED_EXECUTION = "Statement.UnexpectedExecution_EXC_", //$NON-NLS-1$
-		STATEMENT_UNEXPECTED_EVALUATION = "Statement.UnexpectedEvaluation_EXC_"		; //$NON-NLS-1$
-		
-	private ProxyInitParserMessages() {
-	}
-
-	public static String getString(String key) {
-		try {
-			return RESOURCE_BUNDLE.getString(key);
-		} catch (MissingResourceException e) {
-			return '!' + key + '!';
-		}
-	}		
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Statement.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Statement.java
deleted file mode 100644
index 0c24a67..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Statement.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Statement.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-
-public class Statement extends Expression {
-	public boolean isStringObject = false;
-	public boolean isCast = false;
-	protected boolean messageOrFieldStarted;
-	
-/**
- * Statement constructor comment.
- */
-public Statement(ClassLoader aClassLoader) {
-	super();
-	fClassLoader = aClassLoader;
-}
-
-public boolean isComplete(){
-	return currentExpression != null && currentExpression.isComplete();
-}
-
-/** Defer this to the expression
- */
-public Object evaluate() throws Exception {
-	if ( currentExpression != null ) {
-		return currentExpression.evaluate();
-	} else {
-		throw new RuntimeException(ProxyInitParserMessages.getString(ProxyInitParserMessages.STATEMENT_UNEXPECTED_EXECUTION));	// This is not an evaluation error, it shouldn't of occured, so it is a parser error.
-	}
-}
-/**
- */
-public Class getTypeClass() throws Exception {
-	return currentExpression.getTypeClass();
-	//throw new RuntimeException(ProxyBaseVMNLS.RESBUNDLE.getString(ProxyBaseVMNLS.STATEMENT_UNEXPECTED_EVALUATION));
-}
-
-protected String getTypeClassName() {
-	return currentExpression.getTypeClassName();
-}
-/** There are several types of token that can begin a statement.
- *  new , ' '						-	Create a constructor
- *	1-10, true, false, etc...		-	Create a literal
- *  Foo,  '.'						-	Create a Type
- */
-public Expression push(char[] token , char delimiter){
-	
-	// If messageOrFieldStart is true then our expression is complete and either a message or field is being created
-	// See which it is and create the correct expression
-	if (messageOrFieldStarted){
-		messageOrFieldStarted = false;
-		if ( delimiter == DelimiterOpenParen){
-			Message message = new Message(currentExpression,token,fClassLoader);
-			currentExpression = message;
-			return message;
-		} else { 
-			Field field = new Field(currentExpression,token,fClassLoader);
-			currentExpression = field;
-			return field;
-		}
-	}	
-	
-	// Look for "new " for a constructor"
-	if ( delimiter == DelimiterSpace && compare( token , ConstantNew ) ) {
-		// If we thought we were a possible cast and we now aren't then we must be a block expression
-		if ( isCast ) {
-			currentExpression = new Block(new Constructor(fClassLoader));
-		} else {
-			currentExpression = new Constructor(fClassLoader);
-		}
-		isCast = false;	// Can't be a cast now		
-		return currentExpression;
-	}
-	
-	// Look for "null" 
-	if ( compare( token , ConstantNull ) ) {
-		currentExpression = new NullLiteral();
-		isCast = false;	// Can't be a cast now		
-		// Null cannot process anything so we return the statement
-		return this;
-	}
-
-	// Look for a number
-	if ( isNumber( token ) || delimiter == OperMinus ) {
-		currentExpression = new NumberLiteral();
-		currentExpression = currentExpression.push(token,delimiter);
-		isCast = false;	// Can't be a cast now		
-		return currentExpression;
-	}
-
-	if ( compare( token , ConstantTrue ) ) {
-		currentExpression  = new BooleanLiteral(true);
-		// true cannot process anything so we return the statement
-		isCast = false;	// Can't be a cast now		
-		return currentExpression;
-//		return this;
-	}
-
-	if ( compare( token , ConstantFalse ) ) {
-		// false cannot process anything so we return the statement
-		currentExpression = new BooleanLiteral(false);
-		isCast = false;	// Can't be a cast now		
-		return this;
-	}
-	
-	if ( delimiter == DelimiterQuote ) {
-		currentExpression = new StringLiteral();
-		isCast = false;	// Can't be a cast now		
-		return currentExpression;		
-	}
-	
-	if ( delimiter == DelimiterSingleQuote ) {
-		currentExpression = new CharLiteral();
-		isCast = false;	// Can't be a cast now		
-		return currentExpression;		
-	}	
-	
-	if (delimiter == DelimiterPeriod && token.length == 0 && currentExpression != null){
-		if (currentExpression instanceof StringLiteral){
-			//String s = "\"" + (String)(currentExpression.evaluate()) + "\"" ;
-			//return new Constructor(s);
-			isStringObject = true;
-			return this;
-		}
-	}
-	
-	if (isStringObject && (token.length > 0) && (delimiter == DelimiterOpenParen)){
-		return new Message(currentExpression, token,fClassLoader);
-	}
-	
-	//handle type casting
-	if ((token.length == 0) && (delimiter == DelimiterOpenParen)){
-		// If we are a already a cast then we must be a block.
-		if ( isCast ) {
-			currentExpression = new Block(fClassLoader);
-		} else {
-			isCast = true;	// Possibly a cast
-		}
-		return this;
-	}	
-	if (isCast && (delimiter == DelimiterCloseParen || token.length != 0)){
-		Static aStatic = new Static(fClassLoader);
-		Cast aCast = new Cast(aStatic,fClassLoader);
-		currentExpression = aCast.push(token,delimiter);
-		return currentExpression;
-	}
-	
-	if ( token.length != 0 ) {
-		currentExpression = new Static(fClassLoader).push(token,delimiter);
-		return currentExpression;
-	}
-	
-	// If we get a { then we are part of an array argument
-	if (delimiter == DelimiterOpenElipse){
-		currentExpression = new ArrayArguments();
-		return currentExpression;
-	}
-	
-	// If our expression is closed and we receive a . we are either a message or a field.  We won't know this until
-	// the next token we receive, which will be either be delimited by a ( in which case it is a message, else it is a field
-	if (currentExpression != null && currentExpression.isComplete() && delimiter == DelimiterPeriod){
-		messageOrFieldStarted = true;
-	}
-		
-	return this;
-}
-
-public String toString(){
-	StringBuffer buffer = new StringBuffer();
-	buffer.append("Statement{"); //$NON-NLS-1$
-	if ( currentExpression != null ) {
-		buffer.append(currentExpression.toString());
-	}
-	buffer.append('}');
-	return buffer.toString();
-}
-/**
- * Is this statement a primitive.
- */
-public boolean isPrimitive() throws Exception {
-	if ( currentExpression != null ) {
-		return currentExpression.isPrimitive();
-	} else {
-		throw new RuntimeException(ProxyInitParserMessages.getString(ProxyInitParserMessages.STATEMENT_UNEXPECTED_EXECUTION));
-	}
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Static.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Static.java
deleted file mode 100644
index 90e45a3..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/Static.java
+++ /dev/null
@@ -1,305 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: Static.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.io.*;
-import java.lang.reflect.Array;
-import java.util.*;
-
-public class Static extends Expression {
-	protected static final HashMap sPrimitiveTypes;
-	
-	static {
-		sPrimitiveTypes = new HashMap(10);
-		sPrimitiveTypes.put("byte", Byte.TYPE); //$NON-NLS-1$
-		sPrimitiveTypes.put("char", Character.TYPE); //$NON-NLS-1$
-		sPrimitiveTypes.put("short", Short.TYPE); //$NON-NLS-1$
-		sPrimitiveTypes.put("int", Integer.TYPE); //$NON-NLS-1$
-		sPrimitiveTypes.put("long", Long.TYPE); //$NON-NLS-1$
-		sPrimitiveTypes.put("float", Float.TYPE);		 //$NON-NLS-1$
-		sPrimitiveTypes.put("double", Double.TYPE); //$NON-NLS-1$
-	}
-
-	protected ArrayList arrayDimensions;
-	protected List fArrayArguments;
-	protected StringWriter typeWriter = new StringWriter();
-	protected boolean completedWithPeriod = false;
-	protected char[] completionToken;
-	public Class type;
-	protected boolean isComplete;
-
-	public boolean isProcessingArrayDimension;
-/**
- * Create an unknown expression
- */
-public Static(ClassLoader aClassLoader){
-	fClassLoader = aClassLoader;
-}
-public Static(char[] aToken,char delimiter,ClassLoader aClassLoader){
-	
-	fClassLoader = aClassLoader;
-	try { 
-		typeWriter.write(aToken);
-	} catch ( IOException exc ) {};
-	checkForValidType();
-	if ( type == null && delimiter == DelimiterPeriod ){
-		typeWriter.write(DelimiterPeriod);
-	}
-		
-}
-public Static(char[] aToken,char delimiter,ClassLoader aClassLoader,boolean isArray){
-	this(aToken,delimiter,aClassLoader);
-	isProcessingArrayDimension = true;
-	arrayDimensions = new ArrayList(1);
-	arrayDimensions.add(new Statement(aClassLoader));
-}
-
-public boolean isComplete(){
-	return isComplete;
-}
-public boolean isArray(){
-	return arrayDimensions != null;
-}
-/**
- * See whether or not we have a valid type
- * This uses the class loader given to us if one specified.  The reason for this
- * is that Eclipse uses a special plugin class loader and when we are running
- * in a VM inside eclipse ( e.g. for IDEVM proxy stuff ) we must have
- * reference to the plugin that is using us otherwise we can't load its classes
- */
-protected void checkForValidType(){
-
-	type = (Class) sPrimitiveTypes.get(typeWriter.toString());
-	if (type == null)
-		try {
-			if ( fClassLoader == null ) {
-				type = Class.forName(typeWriter.toString());
-			} else {
-				type = fClassLoader.loadClass(typeWriter.toString());
-			}
-		} catch ( ClassNotFoundException exc ) {
-			try {
-				type = Class.forName("java.lang." + typeWriter.toString()); //$NON-NLS-1$
-				StringWriter writer = new StringWriter();
-				writer.write(type.getName());
-				typeWriter = writer;
-			} catch ( ClassNotFoundException exc1 ) {}
-		} catch ( NoClassDefFoundError exc ) {
-			// A mismatch in some way. Found a class, probably different case. One possibility
-			// is found a class, but this was really a package. So class and package with same name
-			// but different case caused this to occur. [46376].
-		}
-	
-}
-/**
- * If we have any static methods return the result of evaluating them against the type
- */
-public Object evaluate() {
-
-	// If we are an array but haven't created it do so
-	if ( isArray() ) {
-		if ( array == null ) {
-			evaluateArray();
-		}
-		return array;
-	} else {
-		if ( type != null ) { 
-			return type;
-		} else { 
-			// If we have no type then we are some kind incomplete expression that cannot be evaluted
-			throw new RuntimeException();
-		}
-	}
-}
-/**
- * The type of us is either simply the class, or if we are an array then we must create the java.lang.reflect.Array
- * using the reflective APIs
- */
-protected Object array;
-public Class getTypeClass() {
-
-	if ( isArray() ) {
-		if ( array == null ) {
-			// Do not evaluate the array and return its class.  Instead just work out the class by our type
-			// and number of dimensions
-			Object result = Array.newInstance(type,getNumberOfDimensions());
-			return result.getClass();
-		} else { 
-			return array.getClass();
-		}
-	} else { 
-		return type;
-	}
-}
-
-protected String getTypeClassName() {
-	return typeWriter.toString();
-}
-public Class getPrimitiveTypeClass(){
-	return type;
-}
-protected int[] getNumberOfDimensions(){
-	List dimensions = new ArrayList(1);
-	dimensions.add(new Integer(fArrayArguments.size()));
-	((MessageArgument)fArrayArguments.get(0)).contributeArgumentNumber(dimensions);
-	// The total number of arguments is a set of Integer objects in the dimensions list
-	// convert this to an int[]
-	int[] intDimensions = new int[dimensions.size()];
-	for (int i = 0; i < dimensions.size(); i++) {
-		intDimensions[i] = ((Integer)dimensions.get(i)).intValue();
-	}
-	return intDimensions;
-}
-/**
- * Evaluate the array
- */
-protected void evaluateArray(){
-	if ( fArrayArguments != null ) { 
-		// If the array isn't declared with a size but this is supplied with argument these will be in the fArrayArguments
-		// new int[] { 2 ,3 } will have the constructor arguments supplied as two message arguments with 
-		if ( array == null ) {
-			// The size of the array arguments is our array size, however for a multi arg array we need
-			// to find the size of any nested arrays within arguments themselves, e.g. 
-			// new int[][] { {2,3} , {3,4} } then we have two array arguments, each of which is a MessageArgument
-			// whose statement is an ArrayArguments that has two arguments, etc...
-			// To find the number of arguments we create a list that we add our number of arguments to, and then
-			// pass this all the way up the arguments chain using contributeArgumentNumber(List) so that each element
-			// can add to the list the number of arguments ( if any ) that they have.  
-			array = Array.newInstance(type,getNumberOfDimensions());
-			// Set the elements in the array to be the result of evaluating the constructor arguments
-			for (int i = 0; i < fArrayArguments.size(); i++) {
-				Expression expression = (Expression)fArrayArguments.get(i);
-				try {	
-					Object element = expression.evaluate();
-					Array.set(array,i,element);
-				} catch ( Exception exc ) {
-					// Any evaluation exceptions should be thrown back
-					throw new RuntimeException();
-				}
-			}
-		}
-	} else if ( arrayDimensions != null ) {
-		// To get the class of a reflective array we must actually first create it and then ask it for its class
-		// The array Dimensions are present if the array was explicitly declared with a size, e.g. new int[2][3]
-		// will have to arrayDimensions that represent the expressions 2 and 3 ( as NumberLiteral instances )
-		if ( array == null ) {
-			// Evaluate all of the arrayDimensions.  These should be integers
-			int[] dimensionSizes = new int[arrayDimensions.size()];
-			for (int i = 0; i < dimensionSizes.length; i++) {
-				try { 
-					Integer dimensionSize = (Integer) ((Expression)arrayDimensions.get(i)).evaluate();
-					dimensionSizes[i] = dimensionSize.intValue();
-				} catch ( Exception exc ) {
-					throw new RuntimeException();
-				}
-			}
-			// For a multi arg array we need to create using the static method on array that takes an int[] that represents
-			// the number of dimensions, e.g. for new String[2][3] we do Array.newInstance(String.class,new int[] { 2 , 3 };
-			array = Array.newInstance(type,dimensionSizes);
-		}
-	}
-}
-/**
- * If the token is a period then it could either be part of the type or else a static method call
- */
-public Expression push(char[] token , char delimiter ) {
-
-	// If we don't yet have a valid type then see if we now do
-	if (type == null){
-		try { 
-			typeWriter.write(token);
-		} catch ( IOException exc ) {};
-		checkForValidType();
-		// If we got a valid type and a period then remember it
-		if ( delimiter == DelimiterPeriod ) {
-			if (type != null) {
-				completedWithPeriod = true;
-				return this;
-			}
-		}		
-	}
-	
-	if ( arrayDimensions != null && isProcessingArrayDimension ) {
-		Expression lastArrayDimension = (Expression)arrayDimensions.get(arrayDimensions.size()-1);
-		lastArrayDimension.push(token,delimiter);
-		if ( delimiter == DelimiterCloseSquareBrace && isProcessingArrayDimension ) {
-			isProcessingArrayDimension = false;
-		}
-		return this;
-	}
-	
-	if ( delimiter == DelimiterOpenSquareBrace && !isProcessingArrayDimension ) {
-		if ( arrayDimensions == null ) arrayDimensions = new ArrayList(1);
-		Statement statement = new Statement(fClassLoader);
-		arrayDimensions.add(statement);
-		isProcessingArrayDimension = true;
-		return this;		
-	}
-	
-	// If we have a type and the delimiter is a ( then it must be a message beginning
-	if ( type != null ) {
-		if (delimiter == DelimiterOpenParen) {
-			isComplete = true;
-			return new Message( this , token , fClassLoader );
-		} else if (completedWithPeriod){
-			isComplete = true;
-			Field field = new Field(this,token,fClassLoader);
-			// If our token is a ), ' ' or , then the field is completed,
-			// otherwise leave it open so it will process the remaining tokens
-//			if (delimiter == DelimiterCloseParen || delimiter == DelimiterSpace || delimiter == DelimiterComma) {
-			if (delimiter == DelimiterCloseParen || delimiter == DelimiterComma) {
-				field.isComplete = true;
-			}
-			return field;
-		}
-	}
-			
-	// We are still looking for a type so append a .
-	if ( type == null ) {
-		typeWriter.write('.');
-	}
-	return this;
-}
-public String toString(){
-
-	StringWriter writer = new StringWriter();
-	writer.write("Static "); //$NON-NLS-1$
-	if ( type == null ) { 
-		writer.write("(Incomplete) {"); //$NON-NLS-1$
-	} else {
-		writer.write("(Complete) {"); //$NON-NLS-1$
-	}
-	writer.write(typeWriter.toString());
-	writer.write("}"); //$NON-NLS-1$
-	if ( arrayDimensions != null ) {
-		writer.write(" array dimensions="); //$NON-NLS-1$
-		writer.write(new Integer(arrayDimensions.size()).toString());
-	}
-	if ( fArrayArguments != null ) {	
-		writer.write(" array dimensions="); //$NON-NLS-1$
-		writer.write(new Integer(fArrayArguments.size()).toString());
-	}
-	return writer.toString();
-
-}
-
-public boolean isPrimitive() {
-	return getTypeClass().isPrimitive();
-}
-public void setArrayArguments(List arguments) {
-	fArrayArguments = arguments;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/StringLiteral.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/StringLiteral.java
deleted file mode 100644
index 0555a84..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/StringLiteral.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser;
-/*
- *  $RCSfile: StringLiteral.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-
-public class StringLiteral extends Expression {
-	protected boolean isComplete;
-	public String value;
-	public StringBuffer valueBuffer = new StringBuffer();
-	protected boolean isEscaped = false;
-
-/**
- * constructor
- */
-public StringLiteral(){
-}
-	
-/**
- * evaluate method comment.
- */
-public Object evaluate() {
-	return valueBuffer.toString();
-}
-
-public boolean isComplete(){
-	return isComplete;
-}
-/**
- * We must evaluate ourself and return the type of the result
- */
- 
-public Class getTypeClass() {
-	return String.class;
-}
-
-protected String getTypeClassName() {
-	return String.class.getName();
-}
-
-/**
- *This string might be broken into a few tokens
- *so we need a StringBuffer.
- * 
- */
-public Expression push(char[] token , char delimiter){
-	int appendTokenStart = 0;
-	int appendTokenLength = token.length;
-	if (isEscaped) {
-		isEscaped = false;
-		if (token.length != 0) {
-			char c = token[0];
-			switch (c) {
-				case 'b':
-					valueBuffer.append('\b');
-					appendTokenStart = 1;
-					appendTokenLength--;
-					break;
-				case 't':
-					valueBuffer.append('\t');
-					appendTokenStart = 1;
-					appendTokenLength--;
-					break;
-				case 'n':
-					valueBuffer.append('\n');
-					appendTokenStart = 1;
-					appendTokenLength--;
-					break;
-				case 'r':
-					valueBuffer.append('\r');
-					appendTokenStart = 1;
-					appendTokenLength--;
-					break;
-				case 'u':
-					// Unicode, next four gather for text;
-					if (appendTokenLength>=5) {
-						valueBuffer.append((char) Integer.parseInt(new String(token, 1, 4), 16));
-						appendTokenStart=5;
-						appendTokenLength-=5;
-					}
-					break;
-			}
-			// If we didn't append anything, then not a true escape, so put the escape on.
-			if (appendTokenStart==0)
-				valueBuffer.append(DelimiterEscape);
-		} else {
-			if (delimiter == DelimiterQuote || delimiter == DelimiterEscape || delimiter == DelimiterSingleQuote)
-				valueBuffer.append(delimiter);	// It was a true escape.
-			else {
-				valueBuffer.append(DelimiterEscape);	// If wasn't a true escape
-				valueBuffer.append(delimiter);
-			}
-			return this;
-		}
-	}
-	
-	if (appendTokenLength > 0)
-		valueBuffer.append(token, appendTokenStart, appendTokenLength);
-	
-	if (delimiter == DelimiterQuote){		
-		isComplete =true;
-		return this;
-	}
-	
-	// If the delimiter is an escape character remember it so we can escape
-	// the next token, otherwise treat it as a literal
-	if (delimiter == DelimiterEscape ){
-		isEscaped = true;
-	} else {
-		valueBuffer.append(delimiter);
-	}
-	return this;
-}
-
-/**
- * Strings are not primitives.
- */
-public boolean isPrimitive() {
-	return false;
-}
-public String toString(){
-	StringBuffer buffer = new StringBuffer();
-	buffer.append("String(\""); //$NON-NLS-1$
-	if ( valueBuffer != null ) {
-		buffer.append(valueBuffer.toString());
-	}
-	buffer.append("\""); //$NON-NLS-1$
-	return buffer.toString();
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/messages.properties b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/messages.properties
deleted file mode 100644
index caa6923..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/messages.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/messages.properties,v $
-# $Revision: 1.6 $  $Date: 2005/08/24 20:39:07 $
-#
-
-
-#
-# Properties for the Proxy Base VM Support
-#
-UnexpectedToken_EXC_                = IWAV0127E Unexpected Token "{0}".
-Statement.UnexpectedExecution_EXC_  = IWAV0128E Statement was executed unexpectedly.
-Statement.UnexpectedEvaluation_EXC_ = IWAV0129E Statements should not be evaluated.
-CharTooComplicated_EXC_             = IWAV0130E Input text not a char that can be evaluated. Too complicated. \"{0}"
-PrimitiveOperation.Evaluate.InvalidOperator_EXC_=Invalid operator {0} between {1} and {2}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/AbstractEnum.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/AbstractEnum.java
deleted file mode 100644
index 010b0bc..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/AbstractEnum.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: AbstractEnum.java,v $
- *  $Revision: 1.1 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * Base abstract implementation of the enum.
- * @since 1.1.0
- */
-public abstract class AbstractEnum implements Enum {
-
-	/**
-	 * The name of the enumerator.
-	 */
-	private final String name;
-
-	/**
-	 * The <code>int</code> value of the enumerator.
-	 */
-	private final int value;
-
-	/**
-	 * Creates an initialized instance.
-	 * 
-	 * @param value
-	 *            the <code>int</code> value of the enumerator.
-	 * @param name
-	 *            the name of the enumerator.
-	 */
-	protected AbstractEnum(int value, String name) {
-		this.name = name;
-		this.value = value;
-	}
-
-	/**
-	 * Returns the name of the enumerator.
-	 * 
-	 * @return the name.
-	 */
-	public final String getName() {
-		return name;
-	}
-
-	/**
-	 * Returns the <code>int</code> value of the enumerator.
-	 * 
-	 * @return the value.
-	 */
-	public final int getValue() {
-		return value;
-	}
-
-	/**
-	 * Returns the name of the enumerator.
-	 * 
-	 * @return the name.
-	 */
-	public final String toString() {
-		return name;
-	}
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/Enum.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/Enum.java
deleted file mode 100644
index 7d2fb3e..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/Enum.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: Enum.java,v $
- *  $Revision: 1.1 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * TypeSafe enumerations for the IExpression processing.
- * 
- * @since 1.1.0
- */
-public interface Enum {
-
-	/**
-	 * Returns the name of the enumerator.
-	 * 
-	 * @return the name.
-	 */
-	String getName();
-
-	/**
-	 * Returns the <code>int</code> value of the enumerator.
-	 * 
-	 * @return the value.
-	 */
-	int getValue();
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/ExpressionProcesser.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/ExpressionProcesser.java
deleted file mode 100644
index a9b3950..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/ExpressionProcesser.java
+++ /dev/null
@@ -1,3364 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ExpressionProcesser.java,v $
- *  $Revision: 1.21 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-import java.lang.reflect.*;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.jem.internal.proxy.common.*;
-import org.eclipse.jem.internal.proxy.initParser.InitializationStringEvaluationException;
-import org.eclipse.jem.internal.proxy.initParser.InitializationStringParser;
- 
-/**
- * Expression processing. This does the actual expression processing with the live objects.
- * It is meant to be subclassed only to provide additional expression types. All of the
- * current expressions cannot be overridden. This is because the stack is very sensitive to 
- * call order.
- * 
- * @since 1.0.0
- */
-public class ExpressionProcesser {
-
-	/**
-	 * A variable reference for a field access.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static class FieldAccessReference extends VariableReference {
-		
-		private final Field field;
-		private final Object receiver;
-
-		/**
-		 * Use this to construct a FieldAccessReference. This will do checks to make sure
-		 * it is valid so that exceptions won't be thrown later when actually dereferenced.
-		 * 
-		 * @param field
-		 * @param receiver
-		 * @return
-		 * @throws IllegalArgumentException
-		 * 
-		 * @since 1.1.0
-		 */
-		public static FieldAccessReference createFieldAccessReference(Field field, Object receiver) throws IllegalArgumentException {
-			// If static, then receiver is ignored.
-			if (!Modifier.isStatic(field.getModifiers())) {
-				if (!field.getDeclaringClass().isInstance(receiver))
-					throw new IllegalArgumentException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.CreateFieldAccessReference.FieldsTypesNotMatching_EXC_"), new Object[]{field.getType(), (receiver!=null ? receiver.getClass() : null)})); //$NON-NLS-1$
-			}
-			field.setAccessible(true);	// Make it always accessible. Trust it. 
-			return new FieldAccessReference(field, receiver);
-		}
-		
-		protected FieldAccessReference(Field field, Object receiver) {
-			this.field = field;
-			this.receiver = receiver;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.ExpressionProcesser.VariableReference#dereference()
-		 */
-		public Object dereference() {
-			try {
-				return field.get(receiver);
-			} catch (IllegalArgumentException e) {
-				// Shouldn't occur. Already tested for this.
-				e.printStackTrace();
-			} catch (IllegalAccessException e) {
-				// Shouldn't occur. Already tested for this.
-				e.printStackTrace();
-			}
-			return null;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.ExpressionProcesser.VariableReference#set(java.lang.Object, java.lang.Class)
-		 */
-		public Object set(Object value, Class type) throws IllegalArgumentException, IllegalAccessException {
-			field.set(receiver, value);
-			return field.get(receiver);	// Just in case some conversion happened. Technically it is not the value set but the retrieved when in an assignment.
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Object#toString()
-		 */
-		public String toString() {
-			return "FieldAccess{"+field.toString()+"} on "+(receiver != null ? receiver.toString() : "<static access>"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-		}
-	}
-	
-	/**
-	 * A variable reference for an Array access. It will reference only the last indexed entry of the array.
-	 * For example if <code>x[3][4]</code> is the access, then what will be given to this reference will be
-	 * the array entry at x[3][4], not the x array itself.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static class ArrayAccessReference extends VariableReference {
-		
-		
-		private final Object array;
-		private final int index;
-
-		/**
-		 * Use this to construct an array access reference. This will do checks to make sure
-		 * it is valid so that exceptions won't be thrown later when actually dereferenced.
-		 * 
-		 * @param array
-		 * @param index
-		 * @return
-		 * @throws IllegalArgumentException
-		 * 
-		 * @since 1.1.0
-		 */
-		public static ArrayAccessReference createArrayAccessReference(Object array, int index) throws IllegalArgumentException, ArrayIndexOutOfBoundsException {
-			int len = Array.getLength(array);
-			if (index < 0 || len <= index)
-				throw new ArrayIndexOutOfBoundsException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.CreateArrayAccessReference.OutOfBounds_EXC_"), new Object[]{new Integer(index), new Integer(len)})); //$NON-NLS-1$
-			return new ArrayAccessReference(array, index);
-		}
-		/**
-		 * Construct the reference with the array and the index of the entry being referenced.
-		 * @param array
-		 * @param index
-		 * 
-		 * @since 1.1.0
-		 */
-		protected ArrayAccessReference(Object array, int index) {
-			this.array = array;
-			this.index = index;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.VariableReference#dereference()
-		 */
-		public Object dereference() {
-			return Array.get(array, index);
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.VariableReference#set(java.lang.Object, java.lang.Class)
-		 */
-		public Object set(Object value, Class type) throws IllegalArgumentException {
-			Array.set(array, index, value);
-			return Array.get(array, index);	// In case there was some conversion applied. Technically it is not the value set but the retrieved when in an assignment.
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Object#toString()
-		 */
-		public String toString() {
-			return "ArrayAccess["+index+"]: "+array.toString(); //$NON-NLS-1$ //$NON-NLS-2$
-		}
-	}
-	
-	/**
-	 * The expression result stack and the expression result type stack.
-	 * The type stack is used to be expected type of the corresponding
-	 * expression result. This is needed for converting to primitives
-	 * and for finding correct method call from the argument types. In
-	 * this case, it is not the true value, but the value expected, e.g.
-	 * <code>Object getObject()</code> returns something of type Object.
-	 * This needs to be maintained so that if it goes into another method
-	 * we don't accidently return a more specific method instead of the
-	 * one that takes Object as an argument. 
-	 * 
-	 * expressionStack has result of the expression.
-	 * expressionTypeStack has the computed type of the expression i.e.
-	 * the type that the expression returns, not the type of the value.
-	 * These can be different because the expression (e.g. method) may
-	 * return an Object, but the expression value will be some specific
-	 * subclass. So the expressionTypeStack would have a <code>java.lang.Object.class</code>
-	 * on it in that case.
-	 * Note: if the expressionStack has a <code>null</code> on it, then the type stack
-	 * may either have a specific type in it, or it may be <code>MethodHelper.NULL_TYPE</code>. It
-	 * would be this if it was explicitly pushed in and not as the
-	 * result of a computation. If the result of a computation, it would have the
-	 * true value.
-	 * Note: if the expressionStack has a <code>Void.type</code> on it, then that
-	 * means the previous expression had no result. This is an error if trying to
-	 * use the expression in another expression.
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.initParser.MethodHelper#NULL_TYPE
-	 */
-	private List expressionStack = new ArrayList(10);
-	private List expressionTypeStack = new ArrayList(10);
-	
-	/**
-	 * List of the expression proxies. The index into the list is the
-	 * same as the expression proxy id. 
-	 */
-	private ArrayList expressionProxies;	// It is array list because we want to call ensureCapacity and that is not available on List.
-	
-	/**
-	 * An error has occurred. At this point all subcommands will simply make sure they flush the input stream
-	 * correctly, but they do not process it.
-	 * 
-	 * @since 1.0.0
-	 */
-	private boolean errorOccurred = false;
-	private boolean novalueException = false;
-	
-	private Throwable exception = null;	// Was there another kind of exception that was caught.
-	
-	/**
-	 * Process all other exceptions then the NoExpressionValueException. This can be called from usage code so that if there was an error
-	 * in setting up for a call to the processer it can be logged.
-	 * 
-	 * @param e
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void processException(Throwable e) {
-		// Process all other exceptions.
-		novalueException = false;
-		while (e.getCause() != null)
-			e = e.getCause();
-		if (traceOn) {
-			System.out.println();
-			System.out.print("***** >>>\tException: "); //$NON-NLS-1$
-			System.out.println(e);
-		}
-		throwException(e);	// Treat as a throw to let try/catches expressions handle it.
-	}
-	
-	/**
-	 * This is a syntax exception. This means data coming across is corrupted in
-	 * some way so no further processing should occur. 
-	 * @param e
-	 * 
-	 * @since 1.1.0
-	 */
-	protected final void processSyntaxException(Throwable e) {
-		errorOccurred = true;
-		novalueException = false;
-		exception = e;		
-	}
-		
-	/**
-	 * Process a NoExpressionValueException. Don't wrapper these.
-	 * @param e
-	 * 
-	 * @since 1.1.0
-	 */
-	protected final void processSyntaxException(NoExpressionValueException e) {
-		if (traceOn) {
-			// This can happen at any time, so make sure we are on a new line.
-			System.out.println();
-			printTrace("Expression has no value", false); //$NON-NLS-1$
-		}
-		try {
-			errorOccurred = true;
-			novalueException = true;
-			exception = e;
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Return whether there are any errors.
-	 * 
-	 * @return <code>true</code> if no errors.
-	 * 
-	 * @since 1.0.0
-	 */
-	public boolean noErrors() {
-		return !errorOccurred;
-	}
-	
-	/**
-	 * Return whether the error is a NoExpressionValueException or not.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isNoExpressionValue() {
-		return novalueException;
-	}
-	
-	/**
-	 * Return the throwable if a Throwable was caught.
-	 * 
-	 * @return The throwable, or <code>null</code> if not set.
-	 * 
-	 * @since 1.0.0
-	 */
-	public Throwable getErrorThrowable() {
-		return exception;
-	}
-
-	/**
-	 * Push the expression value and its expected type.
-	 * @param o
-	 * @param type
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final void pushExpressionValue(Object o, Class type) {
-		expressionStack.add(o);
-		expressionTypeStack.add(type);
-	}
-
-	/**
-	 * Pop just the expression value. It is imperitive that the expression type
-	 * is popped immediately following. Separated the methods so that we
-	 * don't need to create an array to return two values. This will dereference
-	 * any variable references.
-	 * 
-	 * @return The value.
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final Object popExpression() throws NoExpressionValueException {
-		return popExpression(true);
-	}
-	
-	/**
-	 * Pop just the expression value. It is imperitive that the expression type
-	 * is popped immediately following. Separated the methods so that we
-	 * don't need to create an array to return two values.
-	 * 
-	 * @param deReference If the top expression is a Reference, then dereference it.
-	 * @return The value.
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final Object popExpression(boolean deReference) throws NoExpressionValueException {
-		try {
-			// Do not pop above the current subexpression pos, if any.
-			if (topSubexpression != -1)
-				if (expressionStack.size() == subexpressionStackPos[topSubexpression])
-					throw new NoExpressionValueException();
-			
-			Object result = expressionStack.remove(expressionStack.size()-1);
-			if (deReference && result instanceof VariableReference)
-				result = ((VariableReference) result).dereference();
-			return result;
-		} catch (IndexOutOfBoundsException e) {
-			throw new NoExpressionValueException();
-		}
-	}
-
-	/**
-	 * Get the expression at <code>fromTop</code> down from the top. This is
-	 * need for when multi-operators happen and they are stored in reverse of 
-	 * what is needed. They would normally be stored left to right, with the
-	 * rightmost one on top. But they need to be processed left to right, so
-	 * to get the left most one requires digging down in the stack.
-	 * <p>
-	 * When done, <code>popExpressions(int count)</code> must be called to
-	 * clean them out since they were processed.
-	 * <p>
-	 * This will not dereference the expression. It is the job of the caller to do this. 
-	 *  
-	 * @param fromTop <code>1</code> is the top one, <code>2</code> is the next one down.
-	 * @return The entry from the top that was requested.
-	 * @throws NoExpressionValueException
-	 * 
-	 * @see IDEExpression#popExpressions(int)
-	 * @since 1.0.0
-	 */
-	protected final Object getExpression(int fromTop) throws NoExpressionValueException {
-		try {
-			// Do not pull above the current subexpression pos, if any.			
-			if (topSubexpression != -1)
-				if (expressionStack.size()-fromTop < subexpressionStackPos[topSubexpression])
-					throw new NoExpressionValueException();
-			
-			return expressionStack.get(expressionStack.size()-fromTop);
-		} catch (IndexOutOfBoundsException e) {
-			throw new NoExpressionValueException();
-		}
-	}
-	
-	/**
-	 * Remove the top <code>count</code> items. This will not cause dereferencing to occur. It
-	 * removes the corresponding type stack entries.
-	 * 
-	 * @param count
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final void popExpressions(int count) throws NoExpressionValueException {
-		try {
-			// Do not pop above the current subexpression pos, if any.
-			int stop = topSubexpression != -1 ? subexpressionStackPos[topSubexpression] : -1;
-			int remove = expressionStack.size()-1;
-			while (count-- > 0) {
-				if (expressionStack.size() <= stop)
-					throw new NoExpressionValueException();	// Try to go above the current subexpression.
-				expressionStack.remove(remove);
-				expressionTypeStack.remove(remove--);
-			}
-		} catch (IndexOutOfBoundsException e) {
-			throw new NoExpressionValueException();
-		}
-	}
-	
-	/**
-	 * Pop just the expression type. It is imperitive that the expression type
-	 * is popped immediately following popExpression. Separated the methods so that we
-	 * don't need to create an array to return two values.
-	 * <p>
-	 * If the allowVoid is false and type is void, then a NoExpressionValueException will be thrown.
-	 * This is for the case where the expression was trying to be used in a different
-	 * expression. This will be set to void only on expressions that return no value (only
-	 * method's do this for now).
-	 * 
-	 * @param allowVoid Allow void types if <code>true</code>
-	 * @return The type.
-	 * @throws NoExpressionValueException
-	 * @since 1.0.0
-	 */
-	protected final Class popExpressionType(boolean allowVoid) throws NoExpressionValueException {
-		try {
-			Class result = (Class) expressionTypeStack.remove(expressionTypeStack.size()-1);
-			if (!allowVoid && result == Void.TYPE)
-				throw new NoExpressionValueException(InitparserTreeMessages.getString("ExpressionProcesser.PopExpressionType.ExpressionVoid_EXC_")); //$NON-NLS-1$
-			return result;
-				
-		} catch (IndexOutOfBoundsException e) {
-			throw new NoExpressionValueException();
-		}
-	}
-
-	/**
-	 * Get the expression type at <code>fromTop</code> down from the top. This is
-	 * need for when multi-operators happen and they are stored in reverse of 
-	 * what is needed. They would normally be stored left to right, with the
-	 * rightmost one on top. But they need to be processed left to right, so
-	 * to get the left most one requires digging down in the stack.
-	 * <p>
-	 * When done, <code>popExpressionTypes(int count)</code> must be called to
-	 * clean them out since they were processed.
-
-	 * @param fromTop <code>1</code> is the top one, <code>2</code> is the next one down.
-	 * @param allowVoid Allow void types if <code>true</code>
-	 * @return The type from the top that was requested.
-	 * @throws ThrowableProxy
-	 * @throws NoExpressionValueException
-	 * 
-	 * @see IDEExpression#popExpressionTypes(int)
-	 * @since 1.0.0
-	 */
-	protected final Class getExpressionType(int fromTop, boolean allowVoid) throws NoExpressionValueException {
-		try {
-			Class result = (Class) expressionTypeStack.get(expressionTypeStack.size()-fromTop);
-			if (!allowVoid && result == Void.TYPE)
-				throw new NoExpressionValueException();
-			return result;
-		} catch (IndexOutOfBoundsException e) {
-			throw new NoExpressionValueException();
-		}
-	}
-	
-	/**
-	 * Flag indicating expression should be ignored and not processed.
-	 * This happens because of few cases, like conditional and, that
-	 * if one returns false, the rest of the expressions in that conditional and
-	 * expression should be ignored and not processed.
-	 * <p>
-	 * It is an Object that acts as an enum for the type of expression that initiated the ignore. 
-	 * If it is <code>null</code> then no one is ignoring. 
-	 * <p>
-	 * All of the pushTo...Proxy methods must test this for this to work correctly.
-	 * Each expression has some way of testing that their particular nesting of 
-	 * expressions is complete and they can turn off the ignore flag.
-	 * <p>
-	 * Only one type of ignore can exist at a time.
-	 */
-	protected Object ignoreExpression = null;	
-	
-	
-	private List saveStates;
-	
-	/**
-	 * Are we tracing or not.
-	 */
-	protected final boolean traceOn;
-	private final long thresholdTime;
-	private long startExpressionStepTime;
-	private long startExpressionTime;
-	private long lastExpressionEndTime;
-	
-	/**
-	 * Trace head of this expression. So that traces from different expressions can be distinquished.
-	 * It is simply an monotonically increasing counter. It is the header string for any trace output.
-	 */
-	protected final String traceHeader;
-	
-	private int indent = 0;	// Indented for certain block expressions.
-	
-	/*
-	 * Trace counter. It is incremented once for each expression and assigned to the traceId of the expression.
-	 */
-	private static int TRACE_COUNTER;
-	
-	/**
-	 * Create the Expression without tracing.
-	 * @param registry
-	 * 
-	 * @since 1.0.0
-	 */
-	public ExpressionProcesser() {
-		this(false, -1);
-	}
-	
-	/**
-	 * Create the expression, and set the tracing mode and threshold time. Use -1
-	 * for default time of 100ms.
-	 * @param traceOn
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProcesser(boolean traceOn, long threshold) {
-		this.traceOn = traceOn;
-		if (traceOn) {
-			traceHeader = "**"+(++TRACE_COUNTER)+':'; //$NON-NLS-1$
-			System.out.print(traceHeader);
-			System.out.println(" Start expression"); //$NON-NLS-1$
-			this.thresholdTime = threshold != -1 ? threshold : 100;
-			lastExpressionEndTime = startExpressionTime = System.currentTimeMillis();
-		} else {
-			traceHeader = null;
-			thresholdTime = 100;
-		}
-	}
-	
-	/**
-	 * Trace msg helper. Should only be called if traceOn is true. This method is only used to start a new trace message.
-	 * The caller is must call printTraceEnd at the end.
-	 *  
-	 * @param msg message to print
-	 * @param ignore are we ignoring the expression, or is it being processed (this just alters the trace output slightly).
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void printTrace(String msg, boolean ignore) {
-		startExpressionStepTime = System.currentTimeMillis();
-		long sinceLastExpression = startExpressionStepTime - lastExpressionEndTime;
-		System.out.print(traceHeader);
-		if (sinceLastExpression > 0) {
-			System.out.print('(');
-			if (sinceLastExpression > thresholdTime)
-				System.out.print("***"); //$NON-NLS-1$
-			System.out.print(sinceLastExpression);
-			System.out.print("ms)"); //$NON-NLS-1$
-		}
-		System.out.print('\t');
-		if (!ignore)
-			System.out.print("\t"); //$NON-NLS-1$
-		else
-			System.out.print("##\t"); //$NON-NLS-1$
-		
-		printIndent();
-		System.out.print(msg);
-	}
-	
-	/**
-	 * print the indent. It will not do a new line before nor after.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void printIndent() {
-		for(int i=indent; i>0; i--) {
-			System.out.print("  "); //$NON-NLS-1$
-		}
-	}
-
-	protected void printTraceEnd() {
-		long stop = System.currentTimeMillis()-startExpressionStepTime;
-		if (stop > 0) {
-			System.out.print(" ("); //$NON-NLS-1$
-			if (stop > thresholdTime)
-				System.out.print("***"); //$NON-NLS-1$
-			System.out.print(stop);
-			System.out.print("ms)"); //$NON-NLS-1$
-		}
-		System.out.println();
-		lastExpressionEndTime = System.currentTimeMillis();
-	}
-	
-	/**
-	 * Do an indent (undent) according to indent flag.
-	 * @param indent <code>true</code> to increment indent, or otherwise decrement.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void indent(boolean indent) {
-		this.indent += (indent ? 1 : -1);
-		if (this.indent < 0)
-			this.indent = 0;
-	}
-	
-	/**
-	 * Print the object and type. It will not end with a newline char, so one will be needed afterwards.
-	 * 
-	 * @param o
-	 * @param t
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void printObjectAndType(Object o, Class t) {
-		System.out.print(' ');
-		System.out.print("Object-"); //$NON-NLS-1$
-		System.out.print(o);
-		System.out.print(" Type-"); //$NON-NLS-1$
-		System.out.print(t);
-		System.out.print(' ');
-	}
-	
-	/**
-	 * Close the exception processing
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void close() {
-		boolean firstClose = expressionStack != null;
-		if (firstClose && traceOn) {
-			printTrace("End expression", false); //$NON-NLS-1$
-			long totalTime = System.currentTimeMillis()-startExpressionTime;
-			System.out.print(" Total expression evaluation time: "); //$NON-NLS-1$
-			System.out.print(totalTime);
-			System.out.print("ms."); //$NON-NLS-1$
-		}
-		try {
-			expressionStack = null;
-			expressionTypeStack = null;
-			expressionProxies = null;
-			exception = null;
-			catchThrowable = null;
-			saveStates = null;
-		} finally {
-			if (firstClose && traceOn)
-				printTraceEnd();
-		}
-	}
-
-	/**
-	 * Pull the value. The value will be placed into the array passed in.
-	 * It will be stored as value[0] = value value[1] = valuetype(Class).
-	 * 
-	 * @param value The value array to store the value and type into.
-	 * @throws NoExpressionValueException
-	 * @since 1.0.0
-	 */
-	public final void pullValue(Object[] value) throws NoExpressionValueException {
-		if (traceOn)
-			printTrace("Pull value:", false); //$NON-NLS-1$
-		try {
-			value[0] = popExpression();
-			value[1] = popExpressionType(false);
-		} finally {
-			if (traceOn) {
-				printObjectAndType(value[0], (Class) value[1]);
-				printTraceEnd();
-			}
-		}
-		close();
-	}
-	
-	/**
-	 * Pull the value of the expression proxy, dereferencing it if necessary. This is for resolution only purposes at the
-	 * end of the expression being processed. Not meant for general access to the value of expression proxy. Use 
-	 * {@link ExpressionProcesser#getExpressionProxyValue(int, Object[])} instead for general access to the value.
-	 * 
-	 * @param proxyid
-	 * @param value
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pullExpressionProxyValue(int proxyid, Object[] value) throws NoExpressionValueException {
-		getExpressionProxyValue(proxyid, value, true, true);
-	}
-	
-	/**
-	 * Get the expression proxy value. If the expression has not yet been evaluated it will
-	 * return false. If it has it will return true.
-	 * @param proxyid
-	 * @param value put value into value[0] and the type into value[1].
-	 * @return <code>true</code> if successful, or <code>false</code> if the expression proxy was never resolved or doesn't exist.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean getExpressionProxyValue(int proxyid, Object[] value) {
-		try {
-			return getExpressionProxyValue(proxyid, value, true, false);
-		} catch (NoExpressionValueException e) {
-			return false;
-		}
-	}
-	
-	/**
-	 * Get the expression proxy value, or the NoExpressionValueException if not resolved. This
-	 * is useful for callers that need to handle the proxy itself for failed calls.
-	 * 
-	 * @param proxyid
-	 * @param value
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void getExpressionProxy(int proxyid, Object[] value) throws NoExpressionValueException {
-		getExpressionProxyValue(proxyid, value, true, false);
-	}
-	
-	/*
-	 * Internal method use to actually get the value, but to distinquish between pull and get of the public interface.
-	 * Get will process the errors as normal execution errors, while pull will throw the errors. finalTrace is when
-	 * this is the final call to return the values to the client. We will trace the results in that case.
-	 * Return true if successful.
-	 */
-	private boolean getExpressionProxyValue(int proxyid, Object[] value, boolean pull, boolean finalTrace) throws NoExpressionValueException {
-		// Note: This will throw the exceptions right away since this is called from outside to fill in the value and
-		// so we are holding such exceptions.
-		boolean doTrace = finalTrace && traceOn;
-		try {
-			if (expressionProxies != null && expressionProxies.size() > proxyid) {
-				InternalExpressionProxy proxy = (InternalExpressionProxy) expressionProxies.get(proxyid);
-				if (proxy != null && proxy.isSet()) {
-					value[0] = proxy.getValue();
-					if (value[0] instanceof VariableReference)
-						value[0] = ((VariableReference) value[0]).dereference(); // Here we want the final current value.
-					value[1] = proxy.getType();
-					if (doTrace)
-						if (value[1] != Void.TYPE) {
-							printTrace("Return Proxy #" + proxyid + " Resolved to", false); //$NON-NLS-1$ //$NON-NLS-2$
-							printObjectAndType(value[0], (Class) value[1]);
-						} else
-							printTrace("Return Proxy #" + proxyid + " Resolved to void.", false); //$NON-NLS-1$ //$NON-NLS-2$
-					return true;
-
-				} else {
-					if (doTrace)
-						printTrace("Return Proxy #" + proxyid + ": Not resolved", false); //$NON-NLS-1$ //$NON-NLS-2$
-					NoExpressionValueException e = new NoExpressionValueException(InitparserTreeMessages.getString("ExpressionProcesser.GetExpressionProxyValue.ExpressionProxyNotSet_EXC_"), proxy); //$NON-NLS-1$
-					if (pull)
-						throw e;
-					else
-						processSyntaxException(e);
-					return false;
-				}
-			} else {
-				if (doTrace)
-					printTrace("Return Proxy #" + proxyid + ": Never created.", false); //$NON-NLS-1$ //$NON-NLS-2$
-				NoExpressionValueException e = new NoExpressionValueException(InitparserTreeMessages.getString("ExpressionProcesser.GetExpressionProxyValue.ExpressionProxyDoesntExist_EXC_")); //$NON-NLS-1$
-				if (pull)
-					throw e;
-				else
-					processSyntaxException(e);
-				return false;
-			}
-		} finally {
-			if (doTrace)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Push the expression (just a value) onto the stack.
-	 * 
-	 * @param o
-	 * @param t
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushExpression(Object o, Class t) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		if (traceOn) {
-			printTrace("Push: ", ignore); //$NON-NLS-1$
-			printObjectAndType(o, t);
-		}
-		try {
-			if (ignore)
-				return;
-			pushExpressionValue(o, t);
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Get the value of the expression proxy (from proxy id), and push the value onto the stack.
-	 *  
-	 * @param proxyid The proxy id of the ExpressionProxy to push as a value.
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushExpressionProxy(int proxyid) {
-		boolean ignore =(ignoreExpression != null || errorOccurred);
-		if (traceOn)
-			printTrace("Push Expression Proxy #"+proxyid, ignore); //$NON-NLS-1$
-		try {
-			if (ignore)
-				return;
-			if (expressionProxies != null && expressionProxies.size() > proxyid) {
-				InternalExpressionProxy proxy = (InternalExpressionProxy) expressionProxies.get(proxyid);
-				if (proxy != null && proxy.isSet()) {
-					if (traceOn)
-						printObjectAndType(proxy.getValue(), proxy.getType());
-					pushExpressionValue(proxy.getValue(), proxy.getType());	// Can push a VariableReference. This is ok. When used it will then deref with the current value.
-				} else
-					processSyntaxException(new NoExpressionValueException("Proxy id: "+proxyid)); //$NON-NLS-1$
-			} else
-				processSyntaxException(new NoExpressionValueException("Proxy id: "+proxyid)); //$NON-NLS-1$
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Push a cast onto stack. The type passed in is either a String (with classname to cast to) or the
-	 * type to cast to.
-	 * @param type To cast to. If <code>String</code> then convert to type (using something like <code>Class.forName()</code>) or it is a Class
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushCast(Class type) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		if (traceOn)
-			printTrace("Cast to: "+type, ignore); //$NON-NLS-1$
-		try {
-			if (ignore)
-				return;
-			
-			try {
-				Object exp = popExpression();
-				Class exptype = popExpressionType(false);
-				
-				pushExpressionValue(castBean(type, exp, exptype), type);
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-	
-	/**
-	 * Cast a bean into the return type. If the return type is not primitive, then
-	 * the bean is left alone, however it is checked to be an instance of
-	 * the return type. If the return type is primitive, then the
-	 * correct primitive wrapper is created from the bean (bean must be a number or character or boolean primitve so
-	 * that cast will work).
-	 * <p>
-	 * However if can't be cast for primitive or if not an instance of the
-	 * returntype for objects, a ClassCastException will be raised.
-	 * <p>
-	 * This is a helper method for expression processer to cast a bean. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-	 * 
-	 * @param returnType
-	 * @param bean
-	 * @param beanType The type that bean is supposed to be (e.g. even though it is a Number, it actually represents a primitive).
-	 * @return The cast bean (either to the appropriate primitive wrapper type or bean)
-	 * 
-	 * @throws ClassCastException
-	 * @since 1.0.0
-	 */
-	protected final Object castBean(Class returnType, Object bean, Class beanType) throws ClassCastException {
-		// Cast uses true value and true class of bean, not expected type (i.e. not beanType).
-		if (bean == null)
-			if (!returnType.isPrimitive())
-				return bean;	// bean is null, and return type is not primitive, so this is a valid cast.
-			else 
-				throwClassCast(returnType, bean);
-		else if (returnType.equals(bean.getClass()))
-			return bean;	// They are already the same.
-		else if (!returnType.isPrimitive()) {
-			if (!beanType.isPrimitive() && returnType.isInstance(bean))
-				return bean;
-			else
-				throwClassCast(returnType, bean);	// Either bean type was wrappering primitive or not instanceof returntype.
-		} else {
-			if (!beanType.isPrimitive())
-				throwClassCast(returnType, bean);	// bean type was not wrappering a primitive. Can't cast to primitive.
-			// It is return type of primitive. Now convert to correct primitive.
-			if (returnType == Boolean.TYPE)
-				if (bean instanceof Boolean)
-					return bean;
-				else
-					throwClassCast(returnType, bean);
-			else {
-				if (bean instanceof Number) {
-					if (returnType == Integer.TYPE)
-						if (bean instanceof Integer)
-							return bean;
-						else
-							return new Integer(((Number) bean).intValue());
-					else if (returnType == Byte.TYPE)
-						if (bean instanceof Byte)
-							return bean;
-						else
-							return new Byte(((Number) bean).byteValue());
-					else if (returnType == Character.TYPE)
-						if (bean instanceof Character)
-							return bean;
-						else
-							return new Character((char) ((Number) bean).intValue());
-					else if (returnType == Double.TYPE)
-						if (bean instanceof Double)
-							return bean;
-						else
-							return new Double(((Number) bean).doubleValue());
-					else if (returnType == Float.TYPE)
-						if (bean instanceof Float)
-							return bean;
-						else
-							return new Float(((Number) bean).floatValue());
-					else if (returnType == Long.TYPE)
-						if (bean instanceof Long)
-							return bean;
-						else
-							return new Long(((Number) bean).longValue());
-					else if (returnType == Short.TYPE)
-						if (bean instanceof Short)
-							return bean;
-						else
-							return new Short(((Number) bean).shortValue());	
-					else
-						throwClassCast(returnType, bean);
-				} else if (bean instanceof Character) {
-					if (returnType == Character.TYPE)
-						return bean;
-					else if (returnType == Integer.TYPE)
-						return new Integer(((Character) bean).charValue());
-					else if (returnType == Byte.TYPE)
-						return new Byte((byte) ((Character) bean).charValue());
-					else if (returnType == Double.TYPE)
-						return new Double(((Character) bean).charValue());
-					else if (returnType == Float.TYPE)
-						return new Float(((Character) bean).charValue());
-					else if (returnType == Long.TYPE)
-						return new Long(((Character) bean).charValue());
-					else if (returnType == Short.TYPE)
-						return new Short((short) ((Character) bean).charValue());	
-					else
-						throwClassCast(returnType, bean);
-				} else
-					throwClassCast(returnType, bean);
-			}
-			
-		}
-		return null;	// It should never get here;
-	}
-	
-	private void throwClassCast(Class returnType, Object bean) throws ClassCastException {
-		throw new ClassCastException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.CannotCastXToY_EXC_"), new Object[] {bean != null ? bean.getClass().getName() : null, returnType.getName()})); //$NON-NLS-1$
-	}
-
-	/**
-	 * Return the primitive type that the wrapper bean represents (i.e. Boolean instance returns Boolean.TYPE) 
-	 * <p>
-	 * This is a helper method for expression processer to get the primitive type. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-
-	 * @param bean
-	 * @return the primitive type class of the given bean.
-	 * @throws IllegalArgumentException if bean is <code>null</code> or not of the type that can be converted to a primitive.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final Class getPrimitiveType(Object bean) throws IllegalArgumentException {
-		if (bean instanceof Boolean)
-			return Boolean.TYPE;
-		else if (bean instanceof Integer)
-			return Integer.TYPE;
-		else if (bean instanceof Byte)
-			return Byte.TYPE;
-		else if (bean instanceof Character)
-			return Character.TYPE;
-		else if (bean instanceof Double)
-			return Double.TYPE;
-		else if (bean instanceof Float)
-			return Float.TYPE;
-		else if (bean instanceof Long)
-			return Long.TYPE;
-		else if (bean instanceof Short)
-			return Short.TYPE;
-		else
-			throw new IllegalArgumentException(bean != null ? bean.getClass().getName() : "null"); //$NON-NLS-1$
-	}
-	
-	private static final Object IFELSE_IGNORE = "IF/ELSE IGNORE";	// Flag for if/else in ingore //$NON-NLS-1$
-	private int ifElseNesting = 0;	// Nesting of if/else expressions.
-	private int ifElseIgnoreNestCount = 0;	// When ignoring if/else expressions, ignore until this nest count.
-	private boolean ifElseSkipTruePart;
-
-	
-	/**
-	 * Push an if test expression.
-	 * @param hasElseClause
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushIfElse() {
-		try {
-			boolean ignore = true;
-			try {
-				if (errorOccurred)
-					return;
-				// Slightly different here in that if an ignoring occurred we still need to process at least part of it so that
-				// we can get the expression grouping correct.
-				ifElseNesting++;	// We have the test.
-	
-				if (ignoreExpression != null)
-					return;
-				ignore = false;
-			} finally {
-				if (traceOn)
-					printTrace("If test condition", ignore); //$NON-NLS-1$
-			}
-					
-			try {
-				Object condition = popExpression();
-				Class type = popExpressionType(false);
-				if (type != Boolean.TYPE)
-					throwClassCast(Boolean.TYPE, condition);
-				if (traceOn) {
-					System.out.print(" Test Result="+condition); //$NON-NLS-1$
-					printTraceEnd();
-					indent(true);
-					printTrace("Begin True Expression.", ignore); //$NON-NLS-1$
-					printTraceEnd();
-					indent(true);
-				}				
-				if (((Boolean) condition).booleanValue()) {
-					// Condition was true.
-					// Do nothing. Let true condition be processed.
-				} else {
-					// Condition was false.
-					ifElseSkipTruePart = true;	// Tell the true condition should be ignored.
-					ignoreExpression = IFELSE_IGNORE;
-					ifElseIgnoreNestCount = ifElseNesting;
-				}
-				// We don't put anything back on the stack because the condition test is not ever returned.
-				// The appropriate true or false condition evaluation will be left on the stack.
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-
-	/**
-	 * Push an if/else clause. It can be any clause of the if (true, or false clause).
-	 * @param clauseType
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushIfElse(InternalIfElseOperandType clauseType) {
-		try {
-			boolean ignore = true;
-			if (errorOccurred)
-				return;
-			// Slightly different here in that if an ignoring occurred we still need to process at least part of it so that
-			// we can get the expression grouping correct.
-			switch (clauseType.getValue()) {
-			case InternalIfElseOperandType.TRUE_CLAUSE_VALUE:
-					if (traceOn) {
-						indent(false);
-						printTrace("Begin False Expression.", ignore); //$NON-NLS-1$
-						printTraceEnd();
-						indent(true);
-					}
-					if (ifElseSkipTruePart && ignoreExpression == IFELSE_IGNORE && ifElseIgnoreNestCount == ifElseNesting) {
-						// stop ignoring, we've ignored the true condition of interest.
-						ignoreExpression = null;
-						return; // However, leave because since this condition was ignored.
-					}
-					break;
-				case InternalIfElseOperandType.ELSE_CLAUSE_VALUE:
-					if (traceOn) {
-						indent(false);
-						indent(false);
-						printTrace("End IF/ELSE Expression.", ignore); //$NON-NLS-1$
-						printTraceEnd();
-					}					
-					int currentNesting = ifElseNesting--;
-					if (ignoreExpression == IFELSE_IGNORE && ifElseIgnoreNestCount == currentNesting) {
-						// stop ignoring, we've ignored the false condition of interest.
-						ignoreExpression = null;
-						return; // However, leave because since this condition was ignored.
-					}
-			}
-	
-				if (ignoreExpression != null)
-					return;
-				ignore = false;
-
-					
-			try {
-				switch (clauseType.getValue()) {
-					case InternalIfElseOperandType.TRUE_CLAUSE_VALUE:
-						ifElseSkipTruePart = false;	// Tell the false condition should be ignored.
-						ignoreExpression = IFELSE_IGNORE;
-						ifElseIgnoreNestCount = ifElseNesting;
-						break;
-					case InternalIfElseOperandType.ELSE_CLAUSE_VALUE:
-						// There's nothing to do, if it was ignored due to true, we wouldn't of gotton here.
-						// If it wasn't ignored, then the result of the false expression is on the stack, which is what it should be.
-						break;
-				}
-			} catch (RuntimeException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-
-	/**
-	 * Push the instanceof expression.  The type passed in is either a String (with classname to test against) or the
-	 * type to test against.
-	 * @param type To test against.
-	 * @since 1.0.0
-	 */
-	public final void pushInstanceof(Class type) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		if (traceOn)
-			printTrace("Instanceof type: "+type, ignore); //$NON-NLS-1$
-		try {
-			if (ignore)
-				return;
-			
-			try {
-				Object exp = popExpression();
-				Class exptype = popExpressionType(false);
-				pushExpressionValue(Boolean.valueOf(isInstance(type, exp, exptype)), Boolean.TYPE);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (RuntimeException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Test if instance of. It will make sure that primitive to non-primitive is not permitted.
-	 * This is a true instance of, which means null IS NOT AN instance of any type. This is
-	 * different then assignable from, in that case null can be assigned to any class type.
-	 * <p>
-	 * This is a helper method for expression processer to do isInstance. Since it is a helper method it doesn't
-	 * check nor process exceptions.
-
-	 * @param type
-	 * @param bean
-	 * @param beanType
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final boolean isInstance(Class type, Object bean, Class beanType) {
-		if (type.isPrimitive())
-			return beanType.isPrimitive() && type == beanType;	// Can't use isInstance because for a primitive type isInstance returns false.
-		else 
-			return type.isInstance(bean);
-	}
-	
-	/**
-	 * Push new instance from string.
-	 * @param initializationString
-	 * @param resultType expected result type. If it isn't of that type, a classcast will be processed. 
-	 * @param classloader classloader to use for finding classes, or <code>null</code> to use classloader of InitializationStringParser.class.
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushNewInstanceFromString(String initializationString, Class resultType, ClassLoader classloader) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		if (traceOn)
-			printTrace("New instance from string: \""+initializationString+"\" Type="+resultType, ignore); //$NON-NLS-1$ //$NON-NLS-2$
-		try {
-			if (ignore)
-				return;
-			
-			try {
-				InitializationStringParser parser = InitializationStringParser.createParser(initializationString, classloader);
-				Object newValue = parser.evaluate();
-				newValue = castBean(resultType, newValue, parser.getExpectedType());
-				pushExpressionValue(newValue, resultType);
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (InitializationStringEvaluationException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-
-	}
-
-	/**
-	 * Push prefix expression.
-	 * @param operator 
-	 * @since 1.0.0
-	 */
-	public final void pushPrefix(PrefixOperator operator) {
-		try {
-			if (ignoreExpression != null || errorOccurred) {
-				if (traceOn)
-					printTrace("Prefix: \'"+operator+"\'", true); //$NON-NLS-1$ //$NON-NLS-2$
-				return;
-			}
-			
-			if (operator == PrefixOperator.PRE_PLUS)
-				return;	// Do nothing. "+" doesn't affect the result of the current top expression.
-	
-			if (traceOn)
-				printTrace("Prefix: \'"+operator+"\' ", false); //$NON-NLS-1$ //$NON-NLS-2$
-	
-			try {
-				Object exp = popExpression();
-				Class exptype = popExpressionType(false);
-				if (!exptype.isPrimitive())
-					throwInvalidPrefix(operator, exp);
-				
-				int primTypeEnum = getEnumForPrimitive(exptype);
-				switch (operator.getValue()) {
-					case PrefixOperator.PRE_MINUS_VALUE:
-						switch (primTypeEnum) {
-							case BOOLEAN:
-								throwInvalidPrefix(operator, exp);						
-							case BYTE:
-								exp = new Integer(-((Number) exp).byteValue());
-								break;
-							case CHAR:
-								exp = new Integer(-((Character) exp).charValue());
-								break;
-							case DOUBLE:
-								exp = new Double(-((Number) exp).doubleValue());
-								break;
-							case FLOAT:
-								exp = new Float(-((Number) exp).floatValue());
-								break;
-							case INT:
-								exp = new Integer(-((Number) exp).intValue());
-								break;
-							case LONG:
-								exp = new Long(-((Number) exp).longValue());
-								break;
-							case SHORT:
-								exp = new Integer(-((Number) exp).shortValue());
-								break;
-						}
-						exptype = getPrimitiveType(exp);	// It can actually change the type.				
-						break;
-						
-					case PrefixOperator.PRE_COMPLEMENT_VALUE:
-						switch (primTypeEnum) {
-							case BOOLEAN:
-							case DOUBLE:
-							case FLOAT:
-								throwInvalidPrefix(operator, exp);						
-							case BYTE:
-								exp = new Integer(~((Number) exp).byteValue());
-								break;
-							case CHAR:
-								exp = new Integer(~((Character) exp).charValue());
-								break;
-							case INT:
-								exp = new Integer(~((Number) exp).intValue());
-								break;
-							case LONG:
-								exp = new Long(~((Number) exp).longValue());
-								break;
-							case SHORT:
-								exp = new Integer(~((Number) exp).shortValue());
-								break;
-						}
-						exptype = getPrimitiveType(exp);	// It can actually change the type.
-						break;
-					case PrefixOperator.PRE_NOT_VALUE:
-						switch (primTypeEnum) {
-							case BOOLEAN:
-								exp = !((Boolean) exp).booleanValue() ? Boolean.TRUE : Boolean.FALSE;
-								break;
-							case BYTE:
-							case CHAR:
-							case DOUBLE:
-							case FLOAT:
-							case INT:
-							case LONG:
-							case SHORT:
-								throwInvalidPrefix(operator, exp);						
-						}				
-						break;
-					}
-				
-				if (traceOn)
-					printObjectAndType(exp, exptype);
-				pushExpressionValue(exp, exptype);	// Push the result back on the stack.
-	
-			} catch (IllegalArgumentException e) {
-				processSyntaxException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (RuntimeException e) {
-				processException(e);
-			} 
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-	
-	/**
-	 * Assign the right expression to the left expression.
-	 * @since 1.1.0
-	 */
-	public final void pushAssignment() {
-		if (ignoreExpression != null || errorOccurred) {
-			if (traceOn) {
-				printTrace("Assignment", true); //$NON-NLS-1$
-				printTraceEnd();
-			}
-			return;
-		}
-		
-		try {
-			// KLUDGE: The only reason leftValue/refType are outside of try/finally is because
-			// of tracing. pushExpression() does its own trace statements, so we need to end
-			// our trace before calling pushExpression. 
-			Object leftValue;
-			Class refType;
-			try {
-				if (traceOn)
-					printTrace("Assignment: ", false);			 //$NON-NLS-1$	
-				// The order on the stack is right then left operand.
-				// First the right operand
-				Object value = popExpression();
-				Class type = popExpressionType(false);
-
-				// Next the left operand, should be a reference.
-				VariableReference left = (VariableReference) popExpression(false); // Don't dereference it.
-				refType = popExpressionType(false);
-
-				if (traceOn)
-					printObjectAndType(left, refType);
-
-				leftValue = left.set(value, type);
-			} finally {
-				if (traceOn)
-					printTraceEnd();
-			}
-			
-			// Now do assignment and return the value to the stack.
-			pushExpression(leftValue, refType);	// The type of the result is the type of the reference.
-
-		} catch (IllegalArgumentException e) {
-			processException(e);
-		} catch (NoExpressionValueException e) {
-			processSyntaxException(e);
-		} catch (IllegalAccessException e) {
-			processException(e);
-		} catch (RuntimeException e) {
-			processException(e);
-		}
-			
-	}
-	
-	/**
-	 * Assign the expression proxy to the top expression value.
-	 * 
-	 * @param proxy
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushAssignment(InternalExpressionProxy proxy) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		try {
-			if (traceOn) {
-				printTrace("Assign to Proxy #"+proxy.getProxyID(), ignore); //$NON-NLS-1$
-			}
-			if (ignore)
-				return;
-			
-			try {
-				assignToExpressionProxyFromTopStackEntry(proxy);
-				if (traceOn)
-					printObjectAndType(proxy.getValue(), proxy.getType());
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (RuntimeException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-
-	}
-
-	/**
-	 * Assign the top stack entry to the new expression proxy and allocate it for callback later.
-	 * @param proxy
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void assignToExpressionProxyFromTopStackEntry(InternalExpressionProxy proxy) throws NoExpressionValueException {
-		Object value = getExpression(1);
-		Class type = getExpressionType(1, true);
-		if (value instanceof VariableReference)
-			value = ((VariableReference) value).dereference();	// Here we want the final current value.
-
-		proxy.setProxy(value, type);
-		allocateExpressionProxy(proxy);
-	}
-
-	/**
-	 * Allocate an expression proxy. This is used to make an expression proxy known to the processor. The expression proxy must
-	 * have been setProxy() at this point. This is used to assign from the top of the stack or to add from outside an evaluated proxy
-	 * to be used later by others.
-	 * 
-	 * @param proxy
-	 * 
-	 * @since 1.1.0
-	 */
-	public void allocateExpressionProxy(InternalExpressionProxy proxy) {
-		int minSize = proxy.getProxyID()+1;
-		if (expressionProxies == null)
-			expressionProxies = new ArrayList(minSize+10);	// Allow room to grow ten more.
-		else if (expressionProxies.size() < minSize)
-			expressionProxies.ensureCapacity(minSize+10);	// Allow room to grow ten more.
-		int fill = minSize-expressionProxies.size();	// Number of "null" fill entries needed. Probably shouldn't occur, but to be safe.
-		if (fill > 0) {
-			while (--fill > 0)
-				expressionProxies.add(null);
-			expressionProxies.add(proxy);
-		} else
-			expressionProxies.set(proxy.getProxyID(), proxy);	// Already large enough, replace entry.
-
-	}
-
-	/**
-	 * The primitive enums. 
-	 * NOTE: Their order must not changed. They are in order of permitted widening.
-	 * 
-	 */
-	protected static final int
-		BOOLEAN = 0,
-		BYTE = 1,
-		SHORT = 2,	
-		CHAR = 3,
-		INT = 4,
-		LONG = 5,
-		FLOAT = 6,
-		DOUBLE = 7;
-		
-		
-	
-	/**
-	 * Get the enum constant for the type of primitive passed in.
-	 * <p>
-	 * This is a helper method for expression processer to get the enum for the primitive type. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-
-	 * @param primitiveType
-	 * @return
-	 * @throws IllegalArgumentException if type is not a primitive.
-	 * 
-	 * @see ExpressionProcesser#BOOLEAN
-	 * @since 1.0.0
-	 */
-	protected final int getEnumForPrimitive(Class primitiveType) throws IllegalArgumentException {
-		if (primitiveType == Boolean.TYPE)
-			return BOOLEAN;
-		else if (primitiveType == Integer.TYPE)
-			return INT;
-		else if (primitiveType == Byte.TYPE)
-			return BYTE;
-		else if (primitiveType == Character.TYPE)
-			return CHAR;
-		else if (primitiveType == Double.TYPE)
-			return DOUBLE;
-		else if (primitiveType == Float.TYPE)
-			return FLOAT;
-		else if (primitiveType == Long.TYPE)
-			return LONG;
-		else if (primitiveType == Short.TYPE)
-			return SHORT;
-		else
-			throw new IllegalArgumentException(primitiveType != null ? primitiveType.getName() : "null"); //$NON-NLS-1$
-	}
-	
-	private void throwInvalidPrefix(PrefixOperator operator, Object exp) throws IllegalArgumentException {
-		throw new IllegalArgumentException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.InvalidOperandOfPrefixOperator_EXC_"), new Object[] {exp != null ? exp.toString() : null, operator.toString()})); //$NON-NLS-1$
-	}		
-	
-	private static final Object INFIX_IGNORE = "INFIX IGNORE";	// Flag for infix in ingore //$NON-NLS-1$
-	private int infixNesting = 0;	// Nesting of infix expressions.
-	private int infixIgnoreNestCount = 0;	// When ignoring infix expressions, ignore until this nest count.
-	/**
-	 * Push the infix expression onto the stack.
-	 * @param operator
-	 * @param operandType The operator type. Left, right, other.
-	 * @since 1.0.0
-	 */
-	public final void pushInfix(InfixOperator operator, InternalInfixOperandType operandType) {
-		try {
-			boolean ignore = true;
-			try {
-				if (errorOccurred) {
-					return;
-				}
-				// Slightly different here in that if an ignored occurred we still need to process at least part of it so that
-				// we can get the expression grouping correct.
-				if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-					infixNesting++;
-				else if (operandType == InternalInfixOperandType.INFIX_LAST_OPERAND) {
-					int currentNest = infixNesting--;
-					if (ignoreExpression == INFIX_IGNORE && currentNest == infixIgnoreNestCount) {
-						// We were ignoring, and it was this expression that was being ignore.
-						// We have received the last operand of the nested expression that was being ignored,
-						// so we can stop ignoring. But we still leave since the value of the expression is on the
-						// top of the stack.
-						ignoreExpression = null;
-						return;
-					}
-				}
-	
-				if (ignoreExpression != null)
-					return;
-				ignore = false;
-			} finally {
-				if (traceOn)
-					printTrace("Infix: "+operator, ignore); //$NON-NLS-1$
-			}
-			
-			try {
-				Object right = null;
-				Class rightType = null;
-				if (operandType != InternalInfixOperandType.INFIX_LEFT_OPERAND) {
-					// We are not the left operand, so the stack has the right on the top, followed by the left.
-					right = popExpression();
-					rightType = popExpressionType(false);
-				} 
-				
-				Object value = popExpression();
-				Class valueType = popExpressionType(false);
-	
-				switch (operator.getValue()) {
-					case InfixOperator.IN_AND_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidBitType(valueType, InfixOperator.IN_AND);
-						testValidBitType(rightType, InfixOperator.IN_AND);
-						if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) & getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it is int. (even two shorts together produce an int).
-							value = new Integer(getInt(value) & getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_CONDITIONAL_AND_VALUE:
-						// This is tricky.
-						// First if this is left type, then just continue.
-						// Else if this other or last, then need to make it the new value.
-						if (operandType != InternalInfixOperandType.INFIX_LEFT_OPERAND) {
-							value = right;
-							valueType = rightType;
-						}
-							
-						//If the value is now false, we need to ignore the rest.
-						if (valueType != Boolean.TYPE)
-							throwInvalidInfix(operator, value);
-						if (!((Boolean) value).booleanValue() && operandType != InternalInfixOperandType.INFIX_LAST_OPERAND)
-							startInfixIgnore();	// Start ignoring because we know the value of the expression at this point. It is false.
-						break;
-					case InfixOperator.IN_CONDITIONAL_OR_VALUE:
-						// This is tricky.
-						// First if this is left type, then just continue.
-						// Else if this other or last, then need to make it the new value.
-						if (operandType != InternalInfixOperandType.INFIX_LEFT_OPERAND) {
-							value = right;
-							valueType = rightType;
-						}
-						
-						//If the value is now true, we need to ignore the rest.
-						if (valueType != Boolean.TYPE)
-							throwInvalidInfix(operator, value);
-						if (((Boolean) value).booleanValue() && operandType != InternalInfixOperandType.INFIX_LAST_OPERAND)
-							startInfixIgnore(); // Start ignoring because we know the value of the expression at this point. It is true.
-						break;
-					case InfixOperator.IN_DIVIDE_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_DIVIDE);
-						testValidArithmeticType(rightType, InfixOperator.IN_DIVIDE);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, the result will be double.
-							value = new Double(getDouble(value) / getDouble(right));
-							valueType = Double.TYPE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, the result will be float.
-							value = new Float(getFloat(value) / getFloat(right));
-							valueType = Float.TYPE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) / getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it will result in an int, even if both sides are short.
-							value = new Integer(getInt(value) / getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_EQUALS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						// We should never get extended operator for this, but we'll ignore the possibility.
-						if (valueType.isPrimitive() && rightType.isPrimitive()) {
-							// Primitives require more testing than just ==. boolean primitives 
-							if (valueType == Boolean.TYPE || rightType == Boolean.TYPE) {
-								// If either side is a boolean, then the other side needs to be boolean for it to even try to be true.
-								if (valueType != Boolean.TYPE || valueType != Boolean.TYPE)
-									value = Boolean.FALSE;
-								else
-									value = (((Boolean) value).booleanValue() == ((Boolean) right).booleanValue()) ? Boolean.TRUE : Boolean.FALSE;
-							} else {
-								// Now do number tests since not boolean primitive, only numbers are left
-								if (valueType == Double.TYPE || rightType == Double.TYPE) {
-									// If either side is double, compare as double.
-									value = (getDouble(value) == getDouble(right)) ? Boolean.TRUE : Boolean.FALSE;
-								} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-									// If either side is float, compare as float.
-									value = (getFloat(value) == getFloat(right)) ? Boolean.TRUE : Boolean.FALSE;
-								} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-									// If either side is long, the compare as long.
-									value = (getLong(value) == getLong(right)) ? Boolean.TRUE : Boolean.FALSE;
-								} else {
-									// Else it will compare as int, even if both sides are short.
-									value = (getInt(value) == getInt(right)) ? Boolean.TRUE : Boolean.FALSE;
-								}
-							}
-						} else if (valueType.isPrimitive() || rightType.isPrimitive())
-							value = Boolean.FALSE;	// Can't be true if one side prim and the other isn't
-						else {
-							// Just do object ==
-							value = (value == right) ? Boolean.TRUE : Boolean.FALSE;
-						}
-						valueType = Boolean.TYPE;	// We know result will be a boolean.
-						break;
-					case InfixOperator.IN_GREATER_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_GREATER);
-						testValidArithmeticType(rightType, InfixOperator.IN_GREATER);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, compare will be double.
-							value = (getDouble(value) > getDouble(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, compare will be float.
-							value = (getFloat(value) > getFloat(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, compare will be long.
-							value = (getLong(value) > getLong(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else {
-							// Else compare will be int, even if both sides are short.
-							value = (getInt(value) > getInt(right)) ? Boolean.TRUE : Boolean.FALSE;
-						}
-						valueType = Boolean.TYPE;	// We know result will be a boolean.
-						break;
-					case InfixOperator.IN_GREATER_EQUALS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_GREATER_EQUALS);
-						testValidArithmeticType(rightType, InfixOperator.IN_GREATER_EQUALS);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, compare will be double.
-							value = (getDouble(value) >= getDouble(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, compare will be float.
-							value = (getFloat(value) >= getFloat(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, compare will be long.
-							value = (getLong(value) >= getLong(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else {
-							// Else compare will be int, even if both sides are short.
-							value = (getInt(value) >= getInt(right)) ? Boolean.TRUE : Boolean.FALSE;
-						}
-						valueType = Boolean.TYPE;	// We know result will be a boolean.
-						break;
-					case InfixOperator.IN_LEFT_SHIFT_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidBitType(valueType, InfixOperator.IN_LEFT_SHIFT);
-						testValidBitType(rightType, InfixOperator.IN_LEFT_SHIFT);
-						if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) << getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it is int. (even two shorts together produce an int).
-							value = new Integer(getInt(value) << getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_LESS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_LESS);
-						testValidArithmeticType(rightType, InfixOperator.IN_LESS);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, compare will be double.
-							value = (getDouble(value) < getDouble(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, compare will be float.
-							value = (getFloat(value) < getFloat(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, compare will be long.
-							value = (getLong(value) < getLong(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else {
-							// Else compare will be int, even if both sides are short.
-							value = (getInt(value) < getInt(right)) ? Boolean.TRUE : Boolean.FALSE;
-						}
-						valueType = Boolean.TYPE;	// We know result will be a boolean.
-						break;
-					case InfixOperator.IN_LESS_EQUALS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_LESS_EQUALS);
-						testValidArithmeticType(rightType, InfixOperator.IN_LESS_EQUALS);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, compare will be double.
-							value = (getDouble(value) <= getDouble(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, compare will be float.
-							value = (getFloat(value) <= getFloat(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, compare will be long.
-							value = (getLong(value) <= getLong(right)) ? Boolean.TRUE : Boolean.FALSE;
-						} else {
-							// Else compare will be int, even if both sides are short.
-							value = (getInt(value) <= getInt(right)) ? Boolean.TRUE : Boolean.FALSE;
-						}
-						valueType = Boolean.TYPE;	// We know result will be a boolean.
-						break;
-					case InfixOperator.IN_MINUS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_MINUS);
-						testValidArithmeticType(rightType, InfixOperator.IN_MINUS);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, the result will be double.
-							value = new Double(getDouble(value) - getDouble(right));
-							valueType = Double.TYPE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, the result will be float.
-							value = new Float(getFloat(value) - getFloat(right));
-							valueType = Float.TYPE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) - getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it will result in an int, even if both sides are short.
-							value = new Integer(getInt(value) - getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_NOT_EQUALS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						// We should never get extended operator for this, but we'll ignore the possibility.
-						if (valueType.isPrimitive() && rightType.isPrimitive()) {
-							// Primitives require more testing than just ==. boolean primitives 
-							if (valueType == Boolean.TYPE || rightType == Boolean.TYPE) {
-								// If either side is a boolean, then the other side needs to be boolean for it to even try to be true.
-								if (valueType != Boolean.TYPE || valueType != Boolean.TYPE)
-									value = Boolean.TRUE;
-								else
-									value = (((Boolean) value).booleanValue() != ((Boolean) right).booleanValue()) ? Boolean.TRUE : Boolean.FALSE;
-							} else {
-								// Now do number tests since not boolean primitive, only numbers are left
-								if (valueType == Double.TYPE || rightType == Double.TYPE) {
-									// If either side is double, compare as double.
-									value = (getDouble(value) != getDouble(right)) ? Boolean.TRUE : Boolean.FALSE;
-								} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-									// If either side is float, compare as float.
-									value = (getFloat(value) != getFloat(right)) ? Boolean.TRUE : Boolean.FALSE;
-								} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-									// If either side is long, the compare as long.
-									value = (getLong(value) != getLong(right)) ? Boolean.TRUE : Boolean.FALSE;
-								} else {
-									// Else it will compare as int, even if both sides are short.
-									value = (getInt(value) != getInt(right)) ? Boolean.TRUE : Boolean.FALSE;
-								}
-							}
-						} else if (valueType.isPrimitive() || rightType.isPrimitive())
-							value = Boolean.TRUE;	// Must be true if one side prim and the other isn't
-						else {
-							// Just do object !=
-							value = (value != right) ? Boolean.TRUE : Boolean.FALSE;
-						}
-						valueType = Boolean.TYPE;	// We know result will be a boolean.
-						break;
-					case InfixOperator.IN_OR_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidBitType(valueType, InfixOperator.IN_OR);
-						testValidBitType(rightType, InfixOperator.IN_OR);
-						if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) | getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it is int. (even two shorts together produce an int).
-							value = new Integer(getInt(value) | getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_PLUS_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND) {
-							if (valueType == String.class) {
-								// Special. left argument is a string, so we want to store a string buffer instead
-								// since we know we will be appending to it. 
-								value = new StringBuffer((String) value);
-							}	
-							break;	// Do nothing with first operand
-						}
-						
-						testValidPlusType(valueType, rightType);
-						if (valueType == String.class || rightType == String.class) {
-							// Special we have a string on one side. Need to do it as strings instead.
-							// We are going to be tricky in that we will store a StringBuffer on the stack (if not last operand)
-							// but call it a string.
-							StringBuffer sb = null;
-							if (valueType == String.class) {
-								sb = (StringBuffer) value;	// We know that if the value (left) is string type, we've already converted it to buffer.
-							} else {
-								// The right is the one that introduces the string, so we change the value over to a string buffer.
-								sb = new StringBuffer(((String) right).length()+16);	// We can't put the value in yet, need to get left into it.
-								appendToBuffer(sb, value, valueType);	// Put the left value in now
-								value = sb;
-								valueType = String.class;	// Make it a string class
-							}
-							appendToBuffer(sb, right, rightType);
-							// Now if we are the last operand, we should get rid of the buffer and put a true string back in.
-							if (operandType == InternalInfixOperandType.INFIX_LAST_OPERAND)
-								value = sb.toString();
-						} else if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, the result will be double.
-							value = new Double(getDouble(value) + getDouble(right));
-							valueType = Double.TYPE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, the result will be float.
-							value = new Float(getFloat(value) + getFloat(right));
-							valueType = Float.TYPE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) + getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it will result in an int, even if both sides are short.
-							value = new Integer(getInt(value) + getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_REMAINDER_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_REMAINDER);
-						testValidArithmeticType(rightType, InfixOperator.IN_REMAINDER);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, the result will be double.
-							value = new Double(getDouble(value) % getDouble(right));
-							valueType = Double.TYPE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, the result will be float.
-							value = new Float(getFloat(value) % getFloat(right));
-							valueType = Float.TYPE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) % getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it will result in an int, even if both sides are short.
-							value = new Integer(getInt(value) % getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_RIGHT_SHIFT_SIGNED_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidBitType(valueType, InfixOperator.IN_RIGHT_SHIFT_SIGNED);
-						testValidBitType(rightType, InfixOperator.IN_RIGHT_SHIFT_SIGNED);
-						if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) >> getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it is int. (even two shorts together produce an int).
-							value = new Integer(getInt(value) >> getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_RIGHT_SHIFT_UNSIGNED_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidBitType(valueType, InfixOperator.IN_RIGHT_SHIFT_UNSIGNED);
-						testValidBitType(rightType, InfixOperator.IN_RIGHT_SHIFT_UNSIGNED);
-						if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) >>> getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it is int. (even two shorts together produce an int).
-							value = new Integer(getInt(value) >>> getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_TIMES_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidArithmeticType(valueType, InfixOperator.IN_TIMES);
-						testValidArithmeticType(rightType, InfixOperator.IN_TIMES);
-						if (valueType == Double.TYPE || rightType == Double.TYPE) {
-							// If either side is double, the result will be double.
-							value = new Double(getDouble(value) * getDouble(right));
-							valueType = Double.TYPE;
-						} else if (valueType == Float.TYPE || rightType == Float.TYPE) {
-							// If either side is float, the result will be float.
-							value = new Float(getFloat(value) * getFloat(right));
-							valueType = Float.TYPE;
-						} else if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) * getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it will result in an int, even if both sides are short.
-							value = new Integer(getInt(value) * getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					case InfixOperator.IN_XOR_VALUE:
-						if (operandType == InternalInfixOperandType.INFIX_LEFT_OPERAND)
-							break;	// Do nothing with first operand
-						
-						testValidBitType(valueType, InfixOperator.IN_XOR);
-						testValidBitType(rightType, InfixOperator.IN_XOR);
-						if (valueType == Long.TYPE || rightType == Long.TYPE) {
-							// If either side is long, the result will be long.
-							value = new Long(getLong(value) ^ getLong(right));
-							valueType = Long.TYPE;
-						} else {
-							// Else it is int. (even two shorts together produce an int).
-							value = new Integer(getInt(value) ^ getInt(right));
-							valueType = Integer.TYPE;
-						}
-						break;
-					} 
-				
-				if (traceOn)
-					printObjectAndType(value, valueType);
-				pushExpressionValue(value, valueType);	// Push the result back on the stack.
-	
-			} catch (IllegalArgumentException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (RuntimeException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-
-	/**
-	 * Start ignoring rest of the current infix expression.
-	 * 
-	 * @since 1.1.0
-	 */
-	private void startInfixIgnore() {
-		ignoreExpression = INFIX_IGNORE;
-		infixIgnoreNestCount = infixNesting;	// Ignore until we get back to the current nesting.
-
-	}
-
-	/**
-	 * Get int value of the primitive wrapper bean passed in (must be either a <code>Number/code> or <code>Character</code>.
-	 * Anything else will cause a class cast error.
-	 * <p>
-	 * This is a helper method for expression processer to get the int value of the object. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-	 * @param bean
-	 * @return the int value of the number/character
-	 * @throws ClassCastException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final int getInt(Object bean) throws ClassCastException {
-		return (bean instanceof Number) ? ((Number) bean).intValue() : ((Character) bean).charValue();
-	}
-	
-	/**
-	 * Get float value of the primitive wrapper bean passed in (must be either a <code>Number/code> or <code>Character</code>.
-	 * Anything else will cause a class cast error.
-	 * <p>
-	 * This is a helper method for expression processer to get the float value of the object. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-	 * @param bean 
-	 * @return float value of the Number/character
-	 * @throws ClassCastException
-	 * @since 1.0.0
-	 */
-	protected final float getFloat(Object bean) throws ClassCastException {
-		return (bean instanceof Number) ? ((Number) bean).floatValue() : ((Character) bean).charValue();
-	}
-
-	/**
-	 * Get double value of the primitive wrapper bean passed in (must be either a <code>Number/code> or <code>Character</code>.
-	 * Anything else will cause a class cast error.
-	 * <p>
-	 * This is a helper method for expression processer to get the float value of the object. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-	 * 
-	 * @param bean
-	 * @return double value of the Number/Character.
-	 * @throws ClassCastException
-	 * @since 1.0.0
-	 */
-	protected final double getDouble(Object bean) throws ClassCastException {
-		return (bean instanceof Number) ? ((Number) bean).doubleValue() : ((Character) bean).charValue();
-	}
-	
-	/**
-	 * Get long value of the primitive wrapper bean passed in (must be either a <code>Number/code> or <code>Character</code>.
-	 * Anything else will cause a class cast error.
-	 * <p>
-	 * This is a helper method for expression processer to get the float value of the object. Since it is a helper method it doesn't
-	 * check nor process the exception. It throws it. Callers must handle it as they see fit.
-	 * 
-	 * @param bean
-	 * @return
-	 * @throws ClassCastException
-	 * @since 1.0.0
-	 */
-	protected final long getLong(Object bean) throws ClassCastException {
-		return (bean instanceof Number) ? ((Number) bean).longValue() : ((Character) bean).charValue();
-	}
-	
-	private void throwInvalidInfix(InfixOperator operator, Object value) throws IllegalArgumentException {
-		throw new IllegalArgumentException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.InvalidOperandOfOperator_EXC_"), new Object[] {value != null ? value.toString() : null, operator.toString()})); //$NON-NLS-1$
-	}
-	
-	private void testValidBitType(Class type, InfixOperator operator) {
-		if (!type.isPrimitive() || type == Boolean.TYPE || type == Double.TYPE|| type == Float.TYPE)
-			throwInvalidInfix(operator, type);
-	}
-	
-	private void testValidArithmeticType(Class type, InfixOperator operator) {
-		if (!type.isPrimitive() || type == Boolean.TYPE)
-			throwInvalidInfix(operator, type);
-	}
-
-	private void testValidPlusType(Class left, Class right) {
-		// Plus is special in that string objects are also valid.
-		if (left == String.class || right == String.class)
-			return;	// As long as one side is string. Anything is valid.
-		// If neither is string, then standard arithmetic test.
-		testValidArithmeticType(left, InfixOperator.IN_PLUS);
-		testValidArithmeticType(right, InfixOperator.IN_PLUS);
-	}
-	
-	private void appendToBuffer(StringBuffer sb, Object value, Class valueType) {
-		if (value == null)
-			sb.append((Object)null);
-		else if (valueType == String.class)
-			sb.append((String) value);
-		else if (valueType.isPrimitive()) {
-			switch (getEnumForPrimitive(valueType)) {
-				case BOOLEAN:
-					sb.append(((Boolean) value).booleanValue());
-					break;
-				case BYTE:
-					sb.append(((Number) value).byteValue());
-					break;
-				case CHAR:
-					sb.append(((Character) value).charValue());
-					break;
-				case DOUBLE:
-					sb.append(((Number) value).doubleValue());
-					break;
-				case FLOAT:
-					sb.append(((Number) value).floatValue());
-					break;
-				case INT:
-					sb.append(((Number) value).intValue());
-					break;
-				case LONG:
-					sb.append(((Number) value).longValue());
-					break;
-				case SHORT:
-					sb.append(((Number) value).shortValue());
-					break;		
-			}
-		} else {
-			// Just an object.
-			sb.append(value);
-		}
-	}
-	
-	/**
-	 * Push the array access expression.
-	 * 
-	 * @param indexCount Number of dimensions being accessed
-	 * @since 1.0.0
-	 */
-	public final void pushArrayAccess(int indexCount) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		
-		if (traceOn) {
-			printTrace("Array Access["+indexCount+']', ignore); //$NON-NLS-1$
-		}
-		try {
-			if (ignore)
-				return;
-			
-			try {
-				// We need to pop off the args. The topmost will be the rightmost index, and the bottom most will be the array itself.
-				int[] arguments = new int[indexCount];
-				// Fill the arg array in reverse order.
-				for(int i=indexCount-1; i >= 0; i--) {
-					Object index = popExpression();
-					Class indexType = popExpressionType(false);
-					if (indexType.isPrimitive() && (indexType == Integer.TYPE || indexType == Short.TYPE || indexType == Character.TYPE || indexType == Byte.TYPE)) {
-						arguments[i] = getInt(index);
-					} else
-						throwClassCast(Integer.TYPE, index);
-				}
-				
-				Object array = popExpression();
-				Class arrayType = popExpressionType(false);
-				if (arrayType.isArray()) {
-					// First figure out how many dimensions are available. Stop when we hit indexcount because we won't be going further.
-					int dimcount = 0;
-					Class[] componentTypes = new Class[indexCount];	// 
-					Class componentType = arrayType;
-					while (dimcount < indexCount && componentType.isArray()) {
-						componentTypes[dimcount++] = componentType = componentType.getComponentType();
-					}
-					
-					if (dimcount < indexCount)
-						throw new IllegalArgumentException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.XIsGreaterThanNumberOfDimensionsInArray_EXC_"), new Object[] {new Integer(indexCount), new Integer(dimcount)})); //$NON-NLS-1$
-					
-					// Now start accessing one index at a time, stop just before the last one. The last one will be turned into an ArrayAccessReference.
-					Object value = array;	// Final value, start with full array.
-					int pullCount = indexCount-1;
-					for(int i=0; i<pullCount; i++) {
-						value = Array.get(value, arguments[i]);
-					}
-					ArrayAccessReference arrayValue = ArrayAccessReference.createArrayAccessReference(value, arguments[pullCount]);
-					if (traceOn)
-						printObjectAndType(arrayValue, componentTypes[pullCount]);
-					pushExpressionValue(arrayValue, componentTypes[pullCount]);
-				}  else
-					 throw new IllegalArgumentException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.NotAnArray_EXC_"), new Object[] {arrayType})); //$NON-NLS-1$
-	
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (RuntimeException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Push the array creation request.
-	 * 
-	 * @param arrayType The type of the array
-	 * @param dimensionCount The number of dimensions being initialized. Zero if using an initializer.
-	 * @since 1.0.0
-	 */
-	public final void pushArrayCreation(Class arrayType, int dimensionCount) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		if (traceOn)
-			printTrace("Array Creation: "+arrayType.getName()+'['+dimensionCount+']', ignore); //$NON-NLS-1$
-		
-		try {
-			if (ignore)
-				return;
-			
-			try {
-				if (dimensionCount == 0) {
-					// The top value is the array itself, from the array initializer.
-					// So we do nothing.
-				} else {
-					// Strip off dimensionCounts from the array type, e.g.
-					// ArrayType is int[][][]
-					// Dimensioncount is 2
-					// Then we need to strip two componenttypes off of the array type
-					// wind up with int[]
-					// This is necessary because Array.new will add those dimensions back
-					// on through the dimension count.
-					Class componentType = arrayType;
-					for(int i=0; i < dimensionCount && componentType != null; i++)
-						componentType = componentType.getComponentType();
-					if (componentType == null)
-						throw new IllegalArgumentException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.ArraytypeHasFewerDimensionsThanRequested_EXC_"), new Object[] {arrayType, new Integer(dimensionCount)})); //$NON-NLS-1$
-					
-					// We need to pull in the dimension initializers. They are stacked in reverse order.
-					int[] dimInit = new int[dimensionCount];
-					for(int i=dimensionCount-1; i >= 0; i--) {
-						Object index = popExpression();
-						Class dimType = popExpressionType(false);
-						if (dimType.isPrimitive() && (dimType == Integer.TYPE || dimType == Short.TYPE || dimType == Character.TYPE || dimType == Byte.TYPE)) {
-							dimInit[i] = getInt(index);
-						} else
-							throwClassCast(Integer.TYPE, index);
-					}
-					
-					// Finally create the array.
-					Object array = Array.newInstance(componentType, dimInit);
-					pushExpressionValue(array, arrayType);
-				}
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-
-	/**
-	 * Push the array initializer request.
-	 * 
-	 * @param arrayType The original type of the array to create.
-	 * @param stripCount the count of how many dimensions to strip to get the type needed for this initializer.
-	 * @param expressionCount
-	 * @since 1.0.0
-	 */
-	public final void pushArrayInitializer(Class arrayType, int stripCount, int expressionCount) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		
-		if (traceOn)
-			printTrace("Initialize Array: "+arrayType.getName()+'{'+expressionCount+'}', ignore); //$NON-NLS-1$
-		
-		try {
-			if (ignore)
-				return;
-	
-			try {
-				if (!arrayType.isArray()) {
-					// It is not an array type.
-					throw new ClassCastException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.CannotCastXToY_EXC_"), new Object[] {arrayType, "array"})); //$NON-NLS-1$ //$NON-NLS-2$
-				} 
-				// Strip off the number of dimensions specified.
-				while(stripCount-->0) {
-					arrayType = arrayType.getComponentType();
-				}
-				Object[] dimValues = null;
-				if (expressionCount > 0) {
-					// We need to pull in the initializers. They are stacked in reverse order.
-					dimValues = new Object[expressionCount];
-					for (int i = expressionCount - 1; i >= 0; i--) {
-						Object dimValue = dimValues[i] = popExpression();
-						Class dimType = popExpressionType(false);
-						if (arrayType.isPrimitive()) {
-							if (dimValue == null || !dimType.isPrimitive())
-								throwClassCast(arrayType, dimType);
-							// A little trickier. Can assign short to an int, but can't assign long to an int. Widening is permitted.
-							if (arrayType != dimType) {
-								int compEnum = getEnumForPrimitive(arrayType);
-								int dimEnum = getEnumForPrimitive(dimType);
-								if (compEnum == BOOLEAN || dimEnum == BOOLEAN)
-									throwClassCast(arrayType, dimType);
-								int dimValueAsInt = getInt(dimValue);
-								switch (compEnum) {
-									case BYTE :
-										// Can accept byte, short, char, or int as long as value is <= byte max. Can't accept long, double, float at all.
-										// Note: This isn't actually true. The max/min test is only valid if the value is a literal, not an expression,
-										// however, at this point in time we no longer know this. So we will simply allow it.
-										if (dimEnum > INT || dimValueAsInt > Byte.MAX_VALUE || dimValueAsInt < Byte.MIN_VALUE)
-											throwClassCast(arrayType, dimType);
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Byte((byte)dimValueAsInt);
-										break;
-									case SHORT :								
-										// Can accept byte, short, char, or int as long as value is <= byte max. Can't accept long, double, float at all.
-										// Note: This isn't actually true. The max/min test is only valid if the value is a literal, not an expression,
-										// however, at this point in time we no longer know this. So we will simply allow it.
-										if (dimEnum > INT || dimValueAsInt > Short.MAX_VALUE || dimValueAsInt < Short.MIN_VALUE)
-											throwClassCast(arrayType, dimType);
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Short((short)dimValueAsInt);
-										break;
-									case CHAR :
-										// Can accept byte, short, char, or int as long as value is <= byte max. Can't accept long, double, float at all.
-										// Note: This isn't actually true. The max/min test is only valid if the value is a literal, not an expression,
-										// however, at this point in time we no longer know this. So we will simply allow it.
-										if (dimEnum > INT || dimValueAsInt > Character.MAX_VALUE || dimValueAsInt < Character.MIN_VALUE)
-											throwClassCast(arrayType, dimType);
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Character((char)dimValueAsInt);
-										break;
-									case INT :
-										// Can accept byte, short, char, or int. Can't accept long, double, float at all.
-										if (dimEnum > INT)
-											throwClassCast(arrayType, dimType);
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Integer(dimValueAsInt);
-										break;
-									case LONG :
-										// Can accept byte, short, char, int, or long. Can't accept double, float at all.
-										if (dimEnum > LONG)
-											throwClassCast(arrayType, dimType);
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Long(getLong(dimValue));
-										break;
-									case FLOAT :
-										// Can accept byte, short, char, int, long, or float. Can't accept double at all.
-										if (dimEnum > FLOAT)
-											throwClassCast(arrayType, dimType);
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Float(getFloat(dimValue));
-										break;
-									case DOUBLE :
-										// But need to be changed to appropriate type for the array.set to work.									
-										dimValues[i] = new Double(getDouble(dimValue));
-										break;
-	
-								}
-							}
-							// Compatible, so ok.
-						} else if (dimType != MethodHelper.NULL_TYPE && !arrayType.isAssignableFrom(dimType)) {
-							// If it is NULL_TYPE, then this is a pushed null. This is always assignable to a non-primitive.
-							// So we don't enter here in that case. However, a null that was returned from some expression
-							// won't have a NULL_TYPE, it will instead have the expected return type. That must be used
-							// in the assignment instead. That is because in java it uses the expected type to determine
-							// compatibility, not the actual type.
-							throwClassCast(arrayType, dimType);
-						}
-					}
-					
-				}
-				
-				// Now we finally create the array.
-				Object array = Array.newInstance(arrayType, new int[] {expressionCount});
-				for (int i = 0; i < expressionCount; i++) {
-					Array.set(array, i, dimValues[i]);
-				}
-				
-				pushExpressionValue(array, array.getClass());	// Adjust to true array type, not the incoming type (which is one dimension too small).
-	
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-
-	/**
-	 * Push the class instance creation request.
-	 * 
-	 * @param type The type to create an instance of
-	 * @param argumentCount The number of arguments (which are stored on the stack).	 * @throws NoExpressionValueException
-	 * @since 1.0.0
-	 */
-	public final void pushClassInstanceCreation(Class type, int argumentCount) {
-		boolean ignore = (ignoreExpression != null || errorOccurred);
-		
-		if (traceOn)
-			printTrace("Create Class: "+type+" (", ignore); //$NON-NLS-1$ //$NON-NLS-2$
-		try {
-			if (ignore)
-				return;
-						
-			try {
-				// We need to pull in the arguments. They are stacked in reverse order.
-				Object value = null;	// The new instance.
-				if (argumentCount > 0) {
-					Object[]  args = new Object[argumentCount];
-					Class[] argTypes = new Class[argumentCount];
-					for (int i = argumentCount - 1; i >= 0; i--) {
-						args[i] = popExpression();
-						argTypes[i] = popExpressionType(false);
-					}
-					
-					// Now we need to find the appropriate constructor.
-					Constructor ctor;
-					ctor = MethodHelper.findCompatibleConstructor(type, argTypes);
-					if (traceOn) {
-						System.out.print(ctor);
-						System.out.print(')');
-					}
-					value = ctor.newInstance(args);
-				} else {
-					// No args, just do default ctor.
-					if (traceOn) {
-						System.out.print("Default ctor)"); //$NON-NLS-1$
-					}
-					value = type.newInstance();
-				}
-				
-				pushExpressionValue(value, type);
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (InstantiationException e) {
-				processException(e);
-			} catch (IllegalAccessException e) {
-				processException(e);
-			} catch (InvocationTargetException e) {
-				processException(e);
-			} catch (NoSuchMethodException e) {
-				processException(e);
-			} catch (AmbiguousMethodException e) {
-				processException(e);
-			} catch (LinkageError e) {
-				processException(e);
-			} catch (Error e) {
-				if (e.getClass() == Error.class) {
-					// If exactly Error.class, then process it. This is hopefully just a "unresolved compilation error".
-					processException(new UnresolvedCompilationError(e));
-				} else
-					throw e;	// All subclasses we throw on out.
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-
-	/**
-	 * Push the field access expression.
-	 * @param field String for fieldname, or a java.lang.reflect.Field.
-	 * @param fieldIsString <code>true</code> if field is a string name, and not a java.lang.reflect.Field.
-	 * @param hasReceiver
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushFieldAccess(Object field, boolean fieldIsString, boolean hasReceiver) {
-		try {
-			if (ignoreExpression != null || errorOccurred) {
-				if (traceOn)
-					printTrace("Field Access", true); //$NON-NLS-1$
-				return;
-			}
-		
-			if (traceOn)
-				printTrace("Field Access: ", false); //$NON-NLS-1$
-			try {
-				// Get the receiver off of the stack.
-				Object receiver = null;
-				Class receiverType = null;
-				if (hasReceiver) {
-					receiver = popExpression();
-					receiverType = popExpressionType(false);
-				}
-				
-				// Find the field.
-				Field reflectField = fieldIsString ? receiverType.getField((String) field) : (Field) field;
-				// Access the field.
-				Object value = FieldAccessReference.createFieldAccessReference(reflectField, receiver);
-				Class valueType = reflectField.getType();
-				if (traceOn) {
-					System.out.print("Field: "); //$NON-NLS-1$
-					if (fieldIsString)
-						System.out.print("(looked up) "); //$NON-NLS-1$
-					System.out.print(reflectField);
-					System.out.print(">"); //$NON-NLS-1$
-					printObjectAndType(value, valueType);
-				}
-					
-				pushExpressionValue(value, valueType);
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (NoSuchFieldException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-
-	/**
-	 * Push the method invocation expression.
-	 * @param method
-	 * @param methodIsString <code>true</code> if method is a string (so string name) or else it is a java.lang.reflect.Method.
-	 * @param hasReceiver
-	 * @param argCount
-	 * @since 1.0.0
-	 */
-	public final void pushMethodInvocation(Object method, boolean methodIsString, boolean hasReceiver, int argCount) {
-		try {
-			if (ignoreExpression != null || errorOccurred) {
-				if (traceOn)
-					printTrace("Invoke", true); //$NON-NLS-1$
-				return;
-			}
-			
-			if (traceOn)
-				printTrace("Invoke: ", false); //$NON-NLS-1$
-			
-			Method reflectMethod = null;
-			try {
-				// We need to pull in the arguments. They are stacked in reverse order.
-				Object[]  args = new Object[argCount];
-				Class[] argTypes = new Class[argCount];
-				for (int i = argCount - 1; i >= 0; i--) {
-					args[i] = popExpression();
-					argTypes[i] = popExpressionType(false);
-				}
-				
-				// Now get receiver
-				Object receiver = null;
-				Class receiverType = null;
-				if (hasReceiver) {
-					receiver = popExpression();
-					receiverType = popExpressionType(false);
-				}
-				
-				// Now we need to find the appropriate method. If it is a string then there must be a receiver, otherwise no way to know.
-				if (methodIsString) {
-					reflectMethod = MethodHelper.findCompatibleMethod(receiverType, (String) method, argTypes);
-				} else
-					reflectMethod = (Method) method;
-				
-				if (traceOn && reflectMethod != null) {
-					System.out.print("Method: "); //$NON-NLS-1$
-					if (methodIsString)
-						System.out.print("(looked up) "); //$NON-NLS-1$
-					System.out.print(reflectMethod);					
-				}
-				
-				if (!Modifier.isStatic(reflectMethod.getModifiers()) && receiver == null)
-					throw new NullPointerException("No receiver for non-static method: "+reflectMethod.toString()); //$NON-NLS-1$
-					
-				Object value = reflectMethod.invoke(receiver, args);
-				
-				if (traceOn) {
-					System.out.print(" returns: "); //$NON-NLS-1$
-					printObjectAndType(value, reflectMethod.getReturnType());
-				}
-				pushExpressionValue(value, reflectMethod.getReturnType());
-			} catch (RuntimeException e) {
-				processException(fixUpMethodException(e, reflectMethod));
-			} catch (NoExpressionValueException e) {
-				processException(fixUpMethodException(e, reflectMethod));
-			} catch (IllegalAccessException e) {
-				processException(fixUpMethodException(e, reflectMethod));
-			} catch (InvocationTargetException e) {
-				processException(fixUpMethodException(e.getCause(), reflectMethod));
-			} catch (NoSuchMethodException e) {
-				processException(e);
-			} catch (AmbiguousMethodException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-			
-	}
-	
-	/*
-	 * Many of the exceptions don't add in what method had the error, so we
-	 * will do that here.
-	 */
-	private Throwable fixUpMethodException(Throwable e, Method method) {
-		if (method == null)
-			return e;
-		try {
-			String msg = e.getMessage();
-			Constructor eWithStringCtor = e.getClass().getConstructor(new Class[] {String.class});
-			String newMsg;
-			if (msg == null) {
-				newMsg = method.toString();
-			} else {
-				newMsg = method.toString()+": \""+msg+'\"'; //$NON-NLS-1$
-			}
-			Exception fixedupE = (Exception) eWithStringCtor.newInstance(new Object[] {newMsg});
-			fixedupE.setStackTrace(e.getStackTrace());
-			return fixedupE;
-		} catch (Exception e1) {
-			return e;
-		}
-  
-	}
-
-	private static final Object CONDITIONAL_IGNORE = "CONDITIONAL IGNORE";	// Flag for conditional in ingore //$NON-NLS-1$
-	private int conditionalNesting = 0;	// Nesting of conditional expressions.
-	private int conditionalIgnoreNestCount = 0;	// When ignoring conditional expressions, ignore until this nest count.
-	private boolean skipTruePart;
-
-	/**
-	 * Push a conditional expression. It can be any clause of the conditional (test, true, or false clause).
-	 * @param expressionType
-	 * 
-	 * @since 1.0.0
-	 */
-	public final void pushConditional(InternalConditionalOperandType expressionType) {
-		try {
-			boolean ignore = true;
-			try {
-				if (errorOccurred)
-					return;
-				// Slightly different here in that if an ignoring occurred we still need to process at least part of it so that
-				// we can get the expression grouping correct.
-				switch (expressionType.getValue()) {
-					case InternalConditionalOperandType.CONDITIONAL_TEST_VALUE:
-						conditionalNesting++;
-						break;
-					case InternalConditionalOperandType.CONDITIONAL_TRUE_VALUE:
-						if (skipTruePart && ignoreExpression == CONDITIONAL_IGNORE && conditionalIgnoreNestCount == conditionalNesting) {
-							// stop ignoring, we've ignored the true condition of interest.
-							ignoreExpression = null;
-							return; // However, leave because since this condition was ignored.
-						}
-						break;
-					case InternalConditionalOperandType.CONDITIONAL_FALSE_VALUE:
-						int currentNesting = conditionalNesting--;
-						if (ignoreExpression == CONDITIONAL_IGNORE && conditionalIgnoreNestCount == currentNesting) {
-							// stop ignoring, we've ignored the false condition of interest.
-							ignoreExpression = null;
-							return; // However, leave because since this condition was ignored.
-						}
-				}
-	
-				if (ignoreExpression != null)
-					return;
-				ignore = false;
-			} finally {
-				if (traceOn)
-					printTrace("Conditional "+expressionType, ignore); //$NON-NLS-1$
-			}
-					
-			try {
-				switch (expressionType.getValue()) {
-					case InternalConditionalOperandType.CONDITIONAL_TEST_VALUE:
-						Object condition = popExpression();
-						Class type = popExpressionType(false);
-						if (type != Boolean.TYPE)
-							throwClassCast(Boolean.TYPE, condition);
-						if (((Boolean) condition).booleanValue()) {
-							// Condition was true.
-							// Do nothing. Let true condition be processed.
-						} else {
-							// Condition was false.
-							skipTruePart = true;	// Tell the true condition should be ignored.
-							ignoreExpression = CONDITIONAL_IGNORE;
-							conditionalIgnoreNestCount = conditionalNesting;
-						}
-						// We don't put anything back on the stack because the condition test is not ever returned.
-						// The appropriate true or false condition evaluation will be left on the stack.
-						break;
-					case InternalConditionalOperandType.CONDITIONAL_TRUE_VALUE:
-						skipTruePart = false;	// Tell the false condition should be ignored.
-						ignoreExpression = CONDITIONAL_IGNORE;
-						conditionalIgnoreNestCount = conditionalNesting;
-						break;
-					case InternalConditionalOperandType.CONDITIONAL_FALSE_VALUE:
-						// There's nothing to do, if it was ignored due to true, we wouldn't of gotton here.
-						// If it wasn't ignored, then the result of the false expression is on the stack, which is what it should be.
-						break;
-				}
-			} catch (RuntimeException e) {
-				processException(e);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	private static final Object BLOCK_IGNORE = "BLOCK IGNORE"; //$NON-NLS-1$
-	private int[] blocks;	// Stack of block numbers currently evaluating.
-	private int topBlock = -1;	// Top block index.
-	private int breakBlock = -1;	// Block number we are breaking to.
-	
-	/**
-	 * Push a begin block.
-	 * @param blockNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushBlockBegin(int blockNumber) {
-		if (traceOn) {
-			printTrace("Begin Block #"+blockNumber, errorOccurred); //$NON-NLS-1$
-			indent(true);
-		}
-		try {
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (blocks == null)
-				blocks = new int[10];
-			if (++topBlock >= blocks.length) {
-				int[] newList = new int[blocks.length*2];
-				System.arraycopy(blocks, 0, newList, 0, blocks.length);
-				blocks = newList;
-			}
-			blocks[topBlock] = blockNumber;
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Push a block end. The current block must be the given number, or it is an error.
-	 * 
-	 * @param blockNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushBlockEnd(int blockNumber) {
-		try {
-			if (traceOn) {
-				indent(false);
-				printTrace("End Block #"+blockNumber, errorOccurred); //$NON-NLS-1$
-			}
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (blocks == null || topBlock < 0 || blocks[topBlock] != blockNumber) {
-				processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushBlockEnd.ReceivedEndBlocksOutOfOrder_EXC_"))); //$NON-NLS-1$
-			} else {
-				topBlock--;
-				if (ignoreExpression == BLOCK_IGNORE && blockNumber == breakBlock) {
-					ignoreExpression = null;
-				}
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}			
-	}
-	
-	/**
-	 * Skip all following until we hit the requested block number.
-	 * @param blockNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushBlockBreak(int blockNumber) {
-		try {
-			if (traceOn)
-				printTrace("Break Block #"+blockNumber, errorOccurred); //$NON-NLS-1$
-			if (errorOccurred)
-				return;
-			if (ignoreExpression == null) {
-				ignoreExpression = BLOCK_IGNORE;	// Start ignoring expressions until we hit the block number end block.
-				breakBlock = blockNumber;
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	private static final Object TRY_THROW_IGNORE = "TRY THROW IGNORE"; //$NON-NLS-1$
-	private static final Object TRY_FINAL_IGNORE = "TRY FINAL IGNORE"; //$NON-NLS-1$
-	private int[] trys;	// Stack of try numbers currently evaluating.
-	// Stack of trys in catch clause (i.e. starting executing a catch/final clause for the try). Corresponds with try from same index in trys. Contains the throwable for the catch.
-	// This is used to know we are executing a catch (entry not null) and for the rethrow short-hand to rethrow the same exception within the catch.
-	private Throwable[] trysInCatch;	
-	private int topTry = -1;	// Top try index.
-	private int breakTry = -1;	// Try number we are breaking to.
-	private Throwable catchThrowable;	// The throwable to check catches against.
-	
-	/**
-	 * Push a try statement.
-	 * @param tryNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushTryBegin(int tryNumber) {
-		try {
-			if (traceOn) {
-				printTrace("Begin Try #"+tryNumber, errorOccurred); //$NON-NLS-1$
-				indent(true);
-			}
-	
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (trys == null) {
-				trys = new int[10];
-				trysInCatch = new Throwable[10];
-			}
-			if (++topTry >= trys.length) {
-				int[] newList = new int[trys.length*2];
-				System.arraycopy(trys, 0, newList, 0, trys.length);
-				trys = newList;
-				Throwable[] newCatches = new Throwable[trys.length];
-				System.arraycopy(trysInCatch, 0, newCatches, 0, trysInCatch.length);
-				trysInCatch = newCatches;
-			}
-			trys[topTry] = tryNumber;
-			trysInCatch[topTry] = null;
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-
-	/**
-	 * Throw the top stack entry. It must be an exception.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushThrowException() {
-		try {
-			boolean ignore = (ignoreExpression != null || errorOccurred);
-			if (traceOn)
-				printTrace("Throw exception: ", ignore); //$NON-NLS-1$
-			
-			if (ignore)
-				return;
-	
-			try {
-				Object t = popExpression();
-				popExpressionType(false);
-				if (traceOn) {
-					System.out.print(t);
-				}
-				throwException((Throwable) t);
-			} catch (NoExpressionValueException e) {
-				processSyntaxException(e);
-			} catch (ClassCastException e) {
-				processException(e);
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}			
-	}
-	
-	/**
-	 * Throw this exception (means throw through the expression being processed, not throw for this thread).
-	 * @param exception
-	 * 
-	 * @since 1.1.0
-	 */
-	protected final void throwException(Throwable exception) {
-		if (topTry == -1) {
-			// There are no tries, so treat this as a syntax error.
-			processSyntaxException(exception);
-		} else if (trysInCatch[topTry] == null) {
-			// We are not in a catch clause of the top try. So do a throw ignore for toptry.
-			ignoreExpression = TRY_THROW_IGNORE;
-			breakTry = trys[topTry];
-			catchThrowable = exception;
-		} else {
-			// We are in a catch of the top try. So do a throw to finally instead.
-			ignoreExpression = TRY_FINAL_IGNORE;
-			trysInCatch[topTry] = FINAL_CATCH;
-			breakTry = trys[topTry];
-			catchThrowable = exception;
-		}
-	}
-	
-	/**
-	 * Push a catch clause
-	 * @param tryNumber
-	 * @param exceptionType
-	 * @param expressionProxy
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushTryCatchClause(int tryNumber, Class exceptionType, InternalExpressionProxy expressionProxy) {
-		try {
-			if (traceOn) {
-				indent(false);
-				if (expressionProxy == null)
-					printTrace("Catch Try #"+tryNumber+" ("+exceptionType+')', errorOccurred); //$NON-NLS-1$ //$NON-NLS-2$
-				else
-					printTrace("Catch Try #"+tryNumber+" ("+exceptionType+") Return exception in proxy #"+expressionProxy.getProxyID(), errorOccurred); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-				indent(true);
-			}
-			
-			if (errorOccurred)
-				return;
-			
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (trys == null || topTry < 0 || trys[topTry] != tryNumber) {
-				processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushTryCatchClause.CatchReceivedOutOfOrder_EXC_"))); //$NON-NLS-1$
-			} else {
-				if (ignoreExpression == null) {
-					// Normal flow, no throw in progress, so just ignore now until the finally or end try reached.
-					ignoreExpression = TRY_FINAL_IGNORE;
-					breakTry = tryNumber;
-				} else if (ignoreExpression == TRY_THROW_IGNORE && tryNumber == breakTry) {
-					// We are here due to a throw occuring in this try block, see if for us, and if it is, stop ignoring.
-					// Else just continue ignoring.
-					if (exceptionType.isInstance(catchThrowable)) {
-						// For us, so just turn everything back on, except mark that we are in the catch phase.
-						ignoreExpression = null;
-						trysInCatch[topTry] = catchThrowable; // This is so that we know if we throw again that we should not catch anything.
-						breakTry = -1;
-						if (expressionProxy != null) {
-							expressionProxy.setProxy(catchThrowable, catchThrowable.getClass());
-							allocateExpressionProxy(expressionProxy);
-						}
-						if (traceOn) {
-							System.out.print(" Caught: "); //$NON-NLS-1$
-							System.out.print(catchThrowable);
-						}
-						catchThrowable = null;
-					}
-				}
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}			
-	}
-	
-	// This is used only so that finally clause can indicate it was executing so that end expression knows this.
-	private static final Throwable FINAL_CATCH = new RuntimeException();
-
-	/**
-	 * Push the try finally clause.
-	 * @param tryNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushTryFinallyClause(int tryNumber) {
-		try {
-			if (traceOn) {
-				indent(false);
-				printTrace("Finally Try #"+tryNumber, errorOccurred); //$NON-NLS-1$
-				indent(true);
-			}
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (trys == null || topTry < 0 || trys[topTry] != tryNumber) {
-				processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushTryFinallyClause.FinallyReceivedOutOfOrder_EXC_"))); //$NON-NLS-1$
-			} else {
-				if (tryNumber == breakTry && (ignoreExpression == TRY_THROW_IGNORE || ignoreExpression == TRY_FINAL_IGNORE)) {
-					// We are here due to a throw occuring in this try block or a catch was reached (in which case all intervening catch's were ignored).
-					// Now do a normal execution. If we are here due to a throw that wasn't cleared (either no catch or another throw occured within the catch)
-					// then we leave it uncleared so that try/end may rethrow it.
-					ignoreExpression = null;
-					trysInCatch[topTry] = FINAL_CATCH; // We are in the finally clause of a exception being thrown within this try.
-					breakTry = -1;
-					if (traceOn)
-						System.out.print(" Executing finally."); //$NON-NLS-1$
-				}
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}			
-	}
-	
-	/**
-	 * Rethrow the caught exception. This is a shortcut for:
-	 * } catch (Exception e) {
-	 *   ... do stuff ...
-	 *   throw e;
-	 * }
-	 * @param tryNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushTryRethrow(int tryNumber) {
-		if (traceOn)
-			printTrace("Rethrow Try #"+tryNumber, errorOccurred  || ignoreExpression != null); //$NON-NLS-1$
-		
-		try {
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because we need to make sure this is not called out of order.
-			if (trys == null || topTry < 0 || trys[topTry] != tryNumber) {
-				processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushTryRethrow.RethrowReceivedOutOfOrder_EXC_"))); //$NON-NLS-1$
-			} else if (ignoreExpression == null) {
-				if (trysInCatch[topTry] == null || trysInCatch[topTry] == FINAL_CATCH)
-					processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushTryRethrow.RetryReceivedOutOfExecutingCatchClause_EXC_"))); //$NON-NLS-1$
-				else {
-					throwException(trysInCatch[topTry]);
-				}
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}		
-	}
-	
-	public final void pushTryEnd(int tryNumber) {
-		if (traceOn) {
-			indent(false);
-			printTrace("End Try #"+tryNumber, errorOccurred); //$NON-NLS-1$
-		}
-		try {
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (trys == null || topTry < 0 || trys[topTry] != tryNumber) {
-				processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushTryEnd.TryEndReceivedOutOfOrder_EXC_"))); //$NON-NLS-1$
-			} else {
-				boolean inCatch = trysInCatch[topTry] != null;
-				trysInCatch[topTry] = null;
-				topTry--;
-				if (inCatch || (tryNumber == breakTry && (ignoreExpression == TRY_THROW_IGNORE || ignoreExpression == TRY_FINAL_IGNORE))) {
-					// We are here due to a throw or normal flow through a catch. Either way if there is a throwable still pending, we rethrow.
-					ignoreExpression = null;
-					breakTry = -1;
-					if (catchThrowable != null)
-						throwException(catchThrowable);
-				} 
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}			
-	}
-	
-	/**
-	 * Class used to save the state at time of mark. It will
-	 * be used to restore state if error.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected class SaveState {
-		public int markID;
-		
-		// Block state
-		public int topBlock;
-		public int breakBlock;
-
-		// Subexpression state
-		public int topSubexpression;
-
-		// Try state
-		public int topTry;
-		public int breakTry;
-		public Throwable catchThrowable;
-		
-		// Error state
-		public boolean errorOccurred;
-		public boolean novalueException;
-		public Throwable exception;
-		public Object ignoreExpression;
-		
-		// Expression stack state
-		public int expressionStackPos;
-		
-		// If/else state
-		public int ifElseNesting;
-		public int ifElseIgnoreNestCount;
-		public boolean ifElseSkipTruePart;
-		
-		// Other
-		public int indent;
-		public int expressionProxyPos;
-		
-		/**
-		 * Construct and save the state.
-		 * 
-		 * @param markNumber
-		 * 
-		 * @since 1.1.0
-		 */
-		public SaveState(int markID) {
-			this.markID = markID;
-			
-			ExpressionProcesser ep = ExpressionProcesser.this;
-			this.topBlock = ep.topBlock;
-			this.breakBlock = ep.breakBlock;
-			
-			this.topSubexpression = ep.topSubexpression;
-			
-			this.topTry = ep.topTry;
-			this.breakTry = ep.breakTry;
-			this.catchThrowable = ep.catchThrowable;
-			
-			this.errorOccurred = ep.errorOccurred;
-			this.novalueException = ep.novalueException;
-			this.exception = ep.exception;
-			this.ignoreExpression = ep.ignoreExpression;
-			
-			this.expressionStackPos = expressionStack.size()-1;
-			
-			this.ifElseNesting = ep.ifElseNesting;
-			this.ifElseIgnoreNestCount = ep.ifElseIgnoreNestCount;
-			this.ifElseSkipTruePart = ep.ifElseSkipTruePart;
-			
-			this.indent = ep.indent;
-			this.expressionProxyPos = expressionProxies != null ? expressionProxies.size()-1 : -1;
-		}
-		
-		/**
-		 * Restore the state.
-		 * 
-		 * 
-		 * @since 1.1.0
-		 */
-		public void restoreState() {
-			ExpressionProcesser ep = ExpressionProcesser.this;
-			ep.topBlock = this.topBlock;
-			ep.breakBlock = this.breakBlock;
-
-			ep.topSubexpression = this.topSubexpression;
-			
-			ep.topTry = this.topTry;
-			ep.breakTry = this.breakTry;
-			ep.catchThrowable = this.catchThrowable;
-			if (trysInCatch != null) {
-				for (int i = topTry + 1; i < ep.trysInCatch.length; i++) {
-					ep.trysInCatch[i] = null;
-				}
-			}
-
-			ep.errorOccurred = this.errorOccurred;
-			ep.novalueException = ep.novalueException;
-			ep.exception = this.exception;
-			ep.ignoreExpression = this.ignoreExpression;
-			
-			// Pop stack down to saved state.
-			for (int i = expressionStack.size()-1; i > this.expressionStackPos; i--) {
-				expressionStack.remove(i);
-				expressionTypeStack.remove(i);
-			}
-			
-			ep.ifElseNesting = this.ifElseNesting;
-			ep.ifElseIgnoreNestCount = this.ifElseIgnoreNestCount;
-			ep.ifElseSkipTruePart = this.ifElseSkipTruePart;
-			
-			ep.indent = this.indent;
-			
-			if (expressionProxies != null) {
-				for (int i = expressionProxies.size() - 1; i > this.expressionProxyPos; i--) {
-					expressionProxies.remove(i);
-				}
-			}
-			
-			// These settings can't cross mark boundaries, so reset them to not set. This is in case we were in this state somewhere
-			// in the mark when the restore occurred.
-			ep.conditionalIgnoreNestCount = 0;
-			ep.conditionalNesting = 0;
-			ep.skipTruePart = false;
-			
-			ep.infixIgnoreNestCount = 0;
-			ep.infixNesting = 0;
-		}
-	}
-	
-	/**
-	 * Create the save state with the given id.
-	 * @param markID
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected SaveState createSaveState(int markID) {
-		return new SaveState(markID);
-	}
-	
-	/**
-	 * Push the start of a mark.
-	 * @param markNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushMark(int markNumber) {
-		if (traceOn)
-			printTrace("Mark#"+markNumber, false); //$NON-NLS-1$
-		
-		if (saveStates == null)
-			saveStates = new ArrayList();
-		saveStates.add(createSaveState(markNumber));
-		
-		if (traceOn)
-			printTraceEnd();
-	}
-	
-	/**
-	 * Push the end mark. If there is no error, it will simply
-	 * remove it and all save states in the map after it. If there
-	 * is an error it will do this plus it will restore the state.
-	 * <p>
-	 * It is assumed that the calls are coming in correct order from
-	 * the server so we won't check validity.
-	 * 
-	 * @param markID
-	 * @param restore
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushEndmark(int markID, boolean restore) {
-		if (traceOn)
-			printTrace("End Mark#"+markID+" Restored="+restore, false); //$NON-NLS-1$ //$NON-NLS-2$
-		
-		try {
-			if (saveStates != null) {
-				// Start from the end (since that is where it most likely will be) and start
-				// search, removing the end one until we reach the markID.
-				for (int i = saveStates.size() - 1; i >= 0; i--) {
-					SaveState state = (SaveState) saveStates.remove(i);
-					if (state.markID == markID) {
-						// We found it.
-						if (restore)
-							state.restoreState();
-						return;
-					}
-				}
-				// But to be safe, if we got here, this is bad. We tried restore a mark we didn't have.
-				processSyntaxException(new IllegalStateException(MessageFormat.format(InitparserTreeMessages.getString("ExpressionProcesser.PushEndmark.EndMarkOnNonExistingID_EXC_"), new Object[]{new Integer(markID)}))); //$NON-NLS-1$
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	private int[] subexpressions;	// Stack of subexpression numbers currently evaluating.
-	private int[] subexpressionStackPos;	// Stack of the expression stack positions (next entry index) for currently evaluating expressions. The evaluation stack cannot be popped beyond the current top. And at end it will be cleaned up to the position.
-	private int topSubexpression = -1;	// Top subexpression index.
-
-	
-	/**
-	 * Push a begin subexpression.
-	 * @param subexpressionNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushSubexpressionBegin(int subexpressionNumber) {
-		if (traceOn) {
-			printTrace("Begin Subexpression #"+subexpressionNumber, errorOccurred); //$NON-NLS-1$
-			indent(true);
-		}
-		try {
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (subexpressions == null) {
-				subexpressions = new int[10];
-				subexpressionStackPos = new int[10];
-			}
-			if (++topSubexpression >= subexpressions.length) {
-				int[] newList = new int[subexpressions.length*2];
-				System.arraycopy(subexpressions, 0, newList, 0, subexpressions.length);
-				subexpressions = newList;
-				newList = new int[subexpressionStackPos.length*2];
-				System.arraycopy(subexpressionStackPos, 0, newList, 0, subexpressionStackPos.length);
-				subexpressionStackPos = newList;				
-			}
-			subexpressions[topSubexpression] = subexpressionNumber;
-			subexpressionStackPos[topSubexpression] = expressionStack.size();
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}
-	}
-	
-	/**
-	 * Push a subexpression end. The current subexpression must be the given number, or it is an error.
-	 * 
-	 * @param subexpressionNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void pushSubexpressionEnd(int subexpressionNumber) {
-		try {
-			if (traceOn) {
-				indent(false);
-				printTrace("End Subexpression #"+subexpressionNumber, errorOccurred); //$NON-NLS-1$
-			}
-			if (errorOccurred)
-				return;
-			// We are not checking ignore because this is a structural concept instead of executable expressions, so we need to keep track of these.
-			if (subexpressions == null || topSubexpression < 0 || subexpressions[topSubexpression] != subexpressionNumber) {
-				processSyntaxException(new IllegalStateException(InitparserTreeMessages.getString("ExpressionProcesser.PushSubexpressionEnd.ReceivedEndSubexpressionsOutOfOrder_EXC_"))); //$NON-NLS-1$
-			} else {
-				try {
-					popExpressions(expressionStack.size()-subexpressionStackPos[topSubexpression]);
-					topSubexpression--;
-				} catch (NoExpressionValueException e) {
-					processSyntaxException(e);
-				}
-			}
-		} finally {
-			if (traceOn)
-				printTraceEnd();
-		}			
-	}
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/ForExpression.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/ForExpression.java
deleted file mode 100644
index f6346fe..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/ForExpression.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ForExpression.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * Enum for the forExpression parameters.
- * <p>
- * This is not meant to be subclassed by customers.
- * @since 1.1.0
- */
-public class ForExpression extends AbstractEnum {
-
-	/**
-	 * forExpression: Creating a root expression
-	 */
-	public static final int ROOTEXPRESSION_VALUE = 0;
-
-	public static final ForExpression ROOTEXPRESSION = new ForExpression(ROOTEXPRESSION_VALUE, "Root"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the array expression for an array access (i.e. the array to access)
-	 */
-	public static final int ARRAYACCESS_ARRAY_VALUE = 1;
-
-	public static final ForExpression ARRAYACCESS_ARRAY = new ForExpression(ARRAYACCESS_ARRAY_VALUE, "Array Access: Array Operand"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating an index expression for an array access (i.e. one of the expressions within the <code>[]</code>).
-	 */
-	public static final int ARRAYACCESS_INDEX_VALUE = 2;
-
-	public static final ForExpression ARRAYACCESS_INDEX = new ForExpression(ARRAYACCESS_INDEX_VALUE, "Array Access: Index"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating an dimension expression for an array creation (i.e. one of the expressions within the <code>[]</code>).
-	 */
-	public static final int ARRAYCREATION_DIMENSION_VALUE = 3;
-
-	public static final ForExpression ARRAYCREATION_DIMENSION = new ForExpression(ARRAYCREATION_DIMENSION_VALUE, "Array Access: Dimension"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating an expression for an array initializer (i.e. one of the expressions with the <code>{}</code>). Special case is that
-	 * array initializers are valid as an expression within an array initializer and it doesn't use a for expression.
-	 */
-	public static final int ARRAYINITIALIZER_EXPRESSION_VALUE = 4;
-
-	public static final ForExpression ARRAYINITIALIZER_EXPRESSION = new ForExpression(ARRAYINITIALIZER_EXPRESSION_VALUE, "Array Initializer"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the expression for the cast (i.e. the expresion after the <code>(type)</code>).
-	 */
-	public static final int CAST_EXPRESSION_VALUE = 5;
-
-	public static final ForExpression CAST_EXPRESSION = new ForExpression(CAST_EXPRESSION_VALUE, "Cast"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the argument expression for the new instance.
-	 */
-	public static final int CLASSINSTANCECREATION_ARGUMENT_VALUE = 6;
-
-	public static final ForExpression CLASSINSTANCECREATION_ARGUMENT = new ForExpression(CLASSINSTANCECREATION_ARGUMENT_VALUE,
-			"Class Instance Creation: Argument"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the condition for a conditional expression.
-	 */
-	public static final int CONDITIONAL_CONDITION_VALUE = 7;
-
-	public static final ForExpression CONDITIONAL_CONDITION = new ForExpression(CONDITIONAL_CONDITION_VALUE, "Conditional: Condition"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the true (then) expression for a conditional expression.
-	 */
-	public static final int CONDITIONAL_TRUE_VALUE = 8;
-
-	public static final ForExpression CONDITIONAL_TRUE = new ForExpression(CONDITIONAL_TRUE_VALUE, "Conditional: True"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the false (else) condition for a conditional expression.
-	 */
-	public static final int CONDITIONAL_FALSE_VALUE = 9;
-
-	public static final ForExpression CONDITIONAL_FALSE = new ForExpression(CONDITIONAL_FALSE_VALUE, "Conditional: False"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the receiver for a field access (i.e. the expression before the ".")
-	 */
-	public static final int FIELD_RECEIVER_VALUE = 10;
-
-	public static final ForExpression FIELD_RECEIVER = new ForExpression(FIELD_RECEIVER_VALUE, "Field Access: Receiver"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the left operand of an infix expression.
-	 */
-	public static final int INFIX_LEFT_VALUE = 11;
-
-	public static final ForExpression INFIX_LEFT = new ForExpression(INFIX_LEFT_VALUE, "Infix: Left"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the right operand of an infix expression.
-	 */
-	public static final int INFIX_RIGHT_VALUE = 12;
-
-	public static final ForExpression INFIX_RIGHT = new ForExpression(INFIX_RIGHT_VALUE, "Infix: Right"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating an extended operand of an infix expression.
-	 */
-	public static final int INFIX_EXTENDED_VALUE = 13;
-
-	public static final ForExpression INFIX_EXTENDED = new ForExpression(INFIX_EXTENDED_VALUE, "Infix: Extended"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the value expression of an instanceof.
-	 */
-	public static final int INSTANCEOF_VALUE_VALUE = 14;
-
-	public static final ForExpression INSTANCEOF_VALUE = new ForExpression(INSTANCEOF_VALUE_VALUE, "Instanceof"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating a receiver expression for a method invocation.
-	 */
-	public static final int METHOD_RECEIVER_VALUE = 15;
-
-	public static final ForExpression METHOD_RECEIVER = new ForExpression(METHOD_RECEIVER_VALUE, "Method Invoke: Receiver"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating an argument for a method invocation.
-	 */
-	public static final int METHOD_ARGUMENT_VALUE = 16;
-
-	public static final ForExpression METHOD_ARGUMENT = new ForExpression(METHOD_ARGUMENT_VALUE, "Method Invoke: Argument"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the operand expression for a prefix operator.
-	 */
-	public static final int PREFIX_OPERAND_VALUE = 17;
-
-	public static final ForExpression PREFIX_OPERAND = new ForExpression(PREFIX_OPERAND_VALUE, "Prefix: Operand"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the right operand of an assignment operator.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final int ASSIGNMENT_RIGHT_VALUE = 18;
-
-	public static final ForExpression ASSIGNMENT_RIGHT = new ForExpression(ASSIGNMENT_RIGHT_VALUE, "Assignment: Right"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the left operand of an assignment operator.
-	 * <p>
-	 * Note: The left expression can only be a FieldAccess or ArrayAccess.
-	 */
-	public static final int ASSIGNMENT_LEFT_VALUE = 19;
-
-	public static final ForExpression ASSIGNMENT_LEFT = new ForExpression(ASSIGNMENT_LEFT_VALUE, "Assignment: Left"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the throw operand of the throw expression.
-	 */
-	public static final int THROW_OPERAND_VALUE = 20;
-
-	public static final ForExpression THROW_OPERAND = new ForExpression(THROW_OPERAND_VALUE, "Throw operand"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the if conditional operand of the if expression.
-	 */
-	public static final int IF_CONDITION_VALUE = 21;
-
-	public static final ForExpression IF_CONDITION = new ForExpression(IF_CONDITION_VALUE, "If condition"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the if true clause of the if expression.
-	 */
-	public static final int IF_TRUE_VALUE = 22;
-
-	public static final ForExpression IF_TRUE = new ForExpression(IF_TRUE_VALUE, "If true clause"); //$NON-NLS-1$
-
-	/**
-	 * forExpression: Creating the if else clause of the if expression.
-	 */
-	public static final int IF_ELSE_VALUE = 23;
-
-	public static final ForExpression IF_ELSE = new ForExpression(IF_ELSE_VALUE, "If else clause"); //$NON-NLS-1$
-
-	
-	/**
-	 * This is not private, but protected only so that proxy core can add an internal ForExpression enum.
-	 * <p>
-	 * This is not meant to be subclassed by customers.
-	 * @param value
-	 * @param name
-	 * 
-	 * @since 1.1.0
-	 */
-	protected ForExpression(int value, String name) {
-		super(value, name);
-	}
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/IExpressionConstants.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/IExpressionConstants.java
deleted file mode 100644
index 49edd72..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/IExpressionConstants.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IExpressionConstants.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
- 
-/**
- * These are constants needed by IExpression that will be common between
- * the vm and the IDE. They are also available to users of the IExpression
- * interface.
- * 
- * @since 1.0.0
- */
-public interface IExpressionConstants {
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InfixOperator.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InfixOperator.java
deleted file mode 100644
index 9fbe003..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InfixOperator.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InfixOperator.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * Enum for Infix operator
- * 
- * @since 1.1.0
- */
-public class InfixOperator extends AbstractEnum {
-
-	/**
-	 * Infix times "*"
-	 */
-	public static final int IN_TIMES_VALUE = 0;
-
-	public static final InfixOperator IN_TIMES = new InfixOperator(IN_TIMES_VALUE, "Infix *"); //$NON-NLS-1$
-
-	/**
-	 * Infix divide "/"
-	 */
-	public static final int IN_DIVIDE_VALUE = 1;
-
-	public static final InfixOperator IN_DIVIDE = new InfixOperator(IN_DIVIDE_VALUE, "Infix /"); //$NON-NLS-1$
-
-	/**
-	 * Infix remainder "%"
-	 */
-	public static final int IN_REMAINDER_VALUE = 2;
-
-	public static final InfixOperator IN_REMAINDER = new InfixOperator(IN_REMAINDER_VALUE, "Infix %"); //$NON-NLS-1$
-
-	/**
-	 * Infix plus "+"
-	 */
-	public static final int IN_PLUS_VALUE = 3;
-
-	public static final InfixOperator IN_PLUS = new InfixOperator(IN_PLUS_VALUE, "Infix +"); //$NON-NLS-1$
-
-	/**
-	 * Infix minus "-"
-	 */
-	public static final int IN_MINUS_VALUE = 4;
-
-	public static final InfixOperator IN_MINUS = new InfixOperator(IN_MINUS_VALUE, "Infix -"); //$NON-NLS-1$
-
-	/**
-	 * Infix left shift " < <"
-	 */
-	public static final int IN_LEFT_SHIFT_VALUE = 5;
-
-	public static final InfixOperator IN_LEFT_SHIFT = new InfixOperator(IN_LEFT_SHIFT_VALUE, "Infix <<"); //$NON-NLS-1$
-
-	/**
-	 * Infix right shift signed ">>"
-	 */
-	public static final int IN_RIGHT_SHIFT_SIGNED_VALUE = 6;
-
-	public static final InfixOperator IN_RIGHT_SHIFT_SIGNED = new InfixOperator(IN_RIGHT_SHIFT_SIGNED_VALUE, "Infix >>"); //$NON-NLS-1$
-
-	/**
-	 * Infix right shift unsigned ">>>"
-	 */
-	public static final int IN_RIGHT_SHIFT_UNSIGNED_VALUE = 7;
-
-	public static final InfixOperator IN_RIGHT_SHIFT_UNSIGNED = new InfixOperator(IN_RIGHT_SHIFT_UNSIGNED_VALUE, "Infix >>>"); //$NON-NLS-1$
-
-	/**
-	 * Infix less " <"
-	 */
-	public static final int IN_LESS_VALUE = 8;
-
-	public static final InfixOperator IN_LESS = new InfixOperator(IN_LESS_VALUE, "Infix <"); //$NON-NLS-1$
-
-	/**
-	 * Infix greater ">"
-	 */
-	public static final int IN_GREATER_VALUE = 9;
-
-	public static final InfixOperator IN_GREATER = new InfixOperator(IN_GREATER_VALUE, "Infix >"); //$NON-NLS-1$
-
-	/**
-	 * Infix less than or equals " <="
-	 */
-	public static final int IN_LESS_EQUALS_VALUE = 10;
-
-	public static final InfixOperator IN_LESS_EQUALS = new InfixOperator(IN_LESS_EQUALS_VALUE, "Infix <="); //$NON-NLS-1$
-
-	/**
-	 * Infix Greater than or equlas ">="
-	 */
-	public static final int IN_GREATER_EQUALS_VALUE = 11;
-
-	public static final InfixOperator IN_GREATER_EQUALS = new InfixOperator(IN_GREATER_EQUALS_VALUE, "Infix >="); //$NON-NLS-1$
-
-	/**
-	 * Infix equals "=="
-	 */
-	public static final int IN_EQUALS_VALUE = 12;
-
-	public static final InfixOperator IN_EQUALS = new InfixOperator(IN_EQUALS_VALUE, "Infix =="); //$NON-NLS-1$
-
-	/**
-	 * Infix not equals "!="
-	 */
-	public static final int IN_NOT_EQUALS_VALUE = 13;
-
-	public static final InfixOperator IN_NOT_EQUALS = new InfixOperator(IN_NOT_EQUALS_VALUE, "Infix !="); //$NON-NLS-1$
-
-	/**
-	 * Infix exclusive or "^"
-	 */
-	public static final int IN_XOR_VALUE = 14;
-
-	public static final InfixOperator IN_XOR = new InfixOperator(IN_XOR_VALUE, "Infix ^"); //$NON-NLS-1$
-
-	/**
-	 * Infix bitwise and "&"
-	 */
-	public static final int IN_AND_VALUE = 15;
-
-	public static final InfixOperator IN_AND = new InfixOperator(IN_AND_VALUE, "Infix &"); //$NON-NLS-1$
-
-	/**
-	 * Infix bitwise or "|"
-	 */
-	public static final int IN_OR_VALUE = 16;
-
-	public static final InfixOperator IN_OR = new InfixOperator(IN_OR_VALUE, "Infix |"); //$NON-NLS-1$
-
-	/**
-	 * Infix Conditional logical and "&&"
-	 */
-	public static final int IN_CONDITIONAL_AND_VALUE = 17;
-
-	public static final InfixOperator IN_CONDITIONAL_AND = new InfixOperator(IN_CONDITIONAL_AND_VALUE, "Infix &&"); //$NON-NLS-1$
-
-	/**
-	 * Infix Conditional logical or "||"
-	 */
-	public static final int IN_CONDITIONAL_OR_VALUE = 18;
-
-	public static final InfixOperator IN_CONDITIONAL_OR = new InfixOperator(IN_CONDITIONAL_OR_VALUE, "Ifnix ||"); //$NON-NLS-1$
-
-	/**
-	 * Return the infix operator for the given enum value.
-	 * @param value
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static InfixOperator get(int value) {
-		switch (value) {
-			case IN_TIMES_VALUE:
-				return IN_TIMES;
-			case IN_DIVIDE_VALUE:
-				return IN_DIVIDE;
-			case IN_REMAINDER_VALUE:
-				return IN_REMAINDER;
-			case IN_PLUS_VALUE:
-				return IN_PLUS;
-			case IN_MINUS_VALUE:
-				return IN_MINUS;
-			case IN_LEFT_SHIFT_VALUE:
-				return IN_LEFT_SHIFT;
-			case IN_RIGHT_SHIFT_SIGNED_VALUE:
-				return IN_RIGHT_SHIFT_SIGNED;
-			case IN_RIGHT_SHIFT_UNSIGNED_VALUE:
-				return IN_RIGHT_SHIFT_UNSIGNED;
-			case IN_LESS_VALUE:
-				return IN_LESS;
-			case IN_GREATER_VALUE:
-				return IN_GREATER;
-			case IN_LESS_EQUALS_VALUE:
-				return IN_LESS_EQUALS;
-			case IN_GREATER_EQUALS_VALUE:
-				return IN_GREATER_EQUALS;
-			case IN_EQUALS_VALUE:
-				return IN_EQUALS;
-			case IN_NOT_EQUALS_VALUE:
-				return IN_NOT_EQUALS;
-			case IN_XOR_VALUE:
-				return IN_XOR;
-			case IN_AND_VALUE:
-				return IN_AND;
-			case IN_OR_VALUE:
-				return IN_OR;
-			case IN_CONDITIONAL_AND_VALUE:
-				return IN_CONDITIONAL_AND;
-			case IN_CONDITIONAL_OR_VALUE:
-				return IN_CONDITIONAL_OR;
-		}
-		return null;
-	}
-
-	private InfixOperator(int value, String name) {
-		super(value, name);
-	}
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InitparserTreeMessages.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InitparserTreeMessages.java
deleted file mode 100644
index 69c30b6..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InitparserTreeMessages.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InitparserTreeMessages.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-/**
- * @author sri
- *
- * TODO To change the template for this generated type comment go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
-public class InitparserTreeMessages {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.proxy.initParser.tree.messages";//$NON-NLS-1$
-
-	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);
-
-	private InitparserTreeMessages() {
-	}
-
-	public static String getString(String key) {
-		// TODO Auto-generated method stub
-		try {
-			return RESOURCE_BUNDLE.getString(key);
-		} catch (MissingResourceException e) {
-			return '!' + key + '!';
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalConditionalOperandType.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalConditionalOperandType.java
deleted file mode 100644
index 406a205..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalConditionalOperandType.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InternalConditionalOperandType.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * Internal class for the Conditional operand type. Not meant to be used by customers.
- * 
- * @since 1.1.0
- */
-public class InternalConditionalOperandType extends AbstractEnum {
-
-	/**
-	 * Used in Conditional processing. False operand on expression stack
-	 */
-	public final static int CONDITIONAL_FALSE_VALUE = 0;
-
-	public final static InternalConditionalOperandType CONDITIONAL_FALSE = new InternalConditionalOperandType(CONDITIONAL_FALSE_VALUE,
-			"Conditional False Operand Flag"); //$NON-NLS-1$
-
-	/**
-	 * Used in Conditional processing. True operand on expression stack
-	 */
-	public final static int CONDITIONAL_TRUE_VALUE = 1;
-
-	public final static InternalConditionalOperandType CONDITIONAL_TRUE = new InternalConditionalOperandType(CONDITIONAL_TRUE_VALUE,
-			"Conditional True Operand Flag"); //$NON-NLS-1$
-
-	/**
-	 * Used in Conditional processing. Test operand on expression stack
-	 */
-	public final static int CONDITIONAL_TEST_VALUE = 2;
-
-	public final static InternalConditionalOperandType CONDITIONAL_TEST = new InternalConditionalOperandType(CONDITIONAL_TEST_VALUE,
-			"Conditional Test Operand Flag"); //$NON-NLS-1$
-
-	/**
-	 * Return the enum for the given value.
-	 * @param value
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static InternalConditionalOperandType get(int value) {
-		switch (value) {
-			case CONDITIONAL_FALSE_VALUE:
-				return CONDITIONAL_FALSE;
-			case CONDITIONAL_TRUE_VALUE:
-				return CONDITIONAL_TRUE;
-			case CONDITIONAL_TEST_VALUE:
-				return CONDITIONAL_TEST;
-		}
-		return null;
-	}
-
-	private InternalConditionalOperandType(int value, String name) {
-		super(value, name);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalExpressionProxy.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalExpressionProxy.java
deleted file mode 100644
index 1f7d3f6..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalExpressionProxy.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InternalExpressionProxy.java,v $
- *  $Revision: 1.2 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
- 
-
-/**
- * This interface is used for expression proxies in the evaluation side (in {@link org.eclipse.jem.internal.proxy.initParser.tree.ExpressionProcesser}).
- * <p>
- * It is meant to be implemented only by users of the ExpressionProcessor.
- * 
- * @since 1.1.0
- */
-public interface InternalExpressionProxy {
-	
-	/**
-	 * Get the id of the proxy.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public int getProxyID();
-	
-	/**
-	 * Called by ExpressionProcesser to give the expression proxy its value and type, i.e. it has been evaluated.
-	 * <p>
-	 * The type may not be the actual type of the value, it may be a superclass of it. It is the type that the proxy
-	 * represents from the return of the expression. For instance it may of returned null but it is supposed to be
-	 * java.lang.String. Or it is supposed to be a primitive int, since we can't store that, we need to store
-	 * an Integer value with the type indicating it is Interger.TYPE.
-	 * 
-	 * @param value
-	 * @param type
-	 * 
-	 * @since 1.1.0
-	 */
-	public void setProxy(Object value, Class type);
-	
-	/**
-	 * Get the value of the proxy. 
-	 * <p>
-	 * Note: The value may be a {@link VariableReference}, in which
-	 * case further dereferencing may be with the returned value.
-	 * @return the value of the proxy, it may be an ExpressionProcesser.VariableReference.
-	 * 
-	 * @since 1.1.0
-	 */
-	public Object getValue();
-	
-	/**
-	 * Get the type of the proxy.
-	 * @return
-	 * 
-	 * @see InternalExpressionProxy#setProxy(Object, Class) for what type means.
-	 * @since 1.1.0
-	 */
-	public Class getType();
-
-	/**
-	 * Return whether the proxy has had a value/class set into it yet.
-	 * @return <code>true</code> if it has been set.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isSet();
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalExpressionTypes.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalExpressionTypes.java
deleted file mode 100644
index d1a35ed..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalExpressionTypes.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * These constants are for communicating between the IDE and the proxy side for expression evaluation. It is not meant to be used by customers.
- * 
- * @since 1.0.0
- */
-public class InternalExpressionTypes extends AbstractEnum {
-
-	/**
-	 * ARRAY ACCESS Expression
-	 */
-	public final static int ARRAY_ACCESS_EXPRESSION_VALUE = 1;
-
-	public final static InternalExpressionTypes ARRAY_ACCESS_EXPRESSION = new InternalExpressionTypes(ARRAY_ACCESS_EXPRESSION_VALUE,
-			"Array Access Expression"); //$NON-NLS-1$
-
-	/**
-	 * ARRAY CREATION Expression
-	 */
-	public final static int ARRAY_CREATION_EXPRESSION_VALUE = 2;
-
-	public final static InternalExpressionTypes ARRAY_CREATION_EXPRESSION = new InternalExpressionTypes(ARRAY_CREATION_EXPRESSION_VALUE,
-			"Array Creation Expression"); //$NON-NLS-1$
-
-	/**
-	 * ARRAY INITIALIZER expression
-	 */
-	public final static int ARRAY_INITIALIZER_EXPRESSION_VALUE = 3;
-
-	public final static InternalExpressionTypes ARRAY_INITIALIZER_EXPRESSION = new InternalExpressionTypes(ARRAY_INITIALIZER_EXPRESSION_VALUE,
-			"Array Initializer Expression"); //$NON-NLS-1$
-
-	/**
-	 * CAST Expression.
-	 */
-	public final static int CAST_EXPRESSION_VALUE = 4;
-
-	public final static InternalExpressionTypes CAST_EXPRESSION = new InternalExpressionTypes(CAST_EXPRESSION_VALUE, "Cast Expression"); //$NON-NLS-1$
-
-	/**
-	 * CONDITIONAL expression
-	 */
-	public final static int CONDITIONAL_EXPRESSION_VALUE = 5;
-
-	public final static InternalExpressionTypes CONDITIONAL_EXPRESSION = new InternalExpressionTypes(CONDITIONAL_EXPRESSION_VALUE,
-			"Conditional Expression"); //$NON-NLS-1$
-
-	/**
-	 * CLASS INSTANCE CREATION expression
-	 */
-	public final static int CLASS_INSTANCE_CREATION_EXPRESSION_VALUE = 6;
-
-	public final static InternalExpressionTypes CLASS_INSTANCE_CREATION_EXPRESSION = new InternalExpressionTypes(
-			CLASS_INSTANCE_CREATION_EXPRESSION_VALUE, "Class Instance Creation Expression"); //$NON-NLS-1$
-
-	/**
-	 * FIELD ACCESS expression.
-	 */
-	public final static int FIELD_ACCESS_EXPRESSION_VALUE = 7;
-
-	public final static InternalExpressionTypes FIELD_ACCESS_EXPRESSION = new InternalExpressionTypes(FIELD_ACCESS_EXPRESSION_VALUE,
-			"Field Access Expression"); //$NON-NLS-1$
-
-	/**
-	 * INSTANCEOF Expression.
-	 */
-	public final static int INSTANCEOF_EXPRESSION_VALUE = 8;
-
-	public final static InternalExpressionTypes INSTANCEOF_EXPRESSION = new InternalExpressionTypes(INSTANCEOF_EXPRESSION_VALUE,
-			"Instanceof Expression"); //$NON-NLS-1$
-
-	/**
-	 * Infix expression
-	 */
-	public final static int INFIX_EXPRESSION_VALUE = 9;
-
-	public final static InternalExpressionTypes INFIX_EXPRESSION = new InternalExpressionTypes(INFIX_EXPRESSION_VALUE, "Infix Expression"); //$NON-NLS-1$
-
-	/**
-	 * Method expression.
-	 */
-	public final static int METHOD_EXPRESSION_VALUE = 10;
-
-	public final static InternalExpressionTypes METHOD_EXPRESSION = new InternalExpressionTypes(METHOD_EXPRESSION_VALUE, "Method Invoke Expression"); //$NON-NLS-1$
-
-	/**
-	 * Prefix expression
-	 */
-	public final static int PREFIX_EXPRESSION_VALUE = 11;
-
-	public final static InternalExpressionTypes PREFIX_EXPRESSION = new InternalExpressionTypes(PREFIX_EXPRESSION_VALUE, "Prefix Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push to proxy expression.
-	 */
-	public final static int PUSH_TO_PROXY_EXPRESSION_VALUE = 12;
-
-	public final static InternalExpressionTypes PUSH_TO_PROXY_EXPRESSION = new InternalExpressionTypes(PUSH_TO_PROXY_EXPRESSION_VALUE,
-			"Push to Proxy Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push BeanType expression proxy expression.
-	 */
-	public final static int PUSH_BEANTYPE_EXPRESSIONPROXY_EXPRESSION_VALUE = 13;
-	
-	public final static InternalExpressionTypes PUSH_BEANTYPE_EXPRESSIONPROXY_EXPRESSION = new InternalExpressionTypes(PUSH_BEANTYPE_EXPRESSIONPROXY_EXPRESSION_VALUE,
-			"Push BeanType ExpressionProxy Expression"); //$NON-NLS-1$
-
-	
-	/**
-	 * Type receiver expression.
-	 */
-	public final static int TYPERECEIVER_EXPRESSION_VALUE = 14;
-
-	public final static InternalExpressionTypes TYPERECEIVER_EXPRESSION = new InternalExpressionTypes(TYPERECEIVER_EXPRESSION_VALUE,
-			"Type Receiver Expression"); //$NON-NLS-1$
-
-	/**
-	 * Assignment to an ExpressionProxy expression.
-	 */
-	public final static int ASSIGNMENT_PROXY_EXPRESSION_VALUE = 15;
-
-	public final static InternalExpressionTypes ASSIGNMENT_PROXY_EXPRESSION = new InternalExpressionTypes(ASSIGNMENT_PROXY_EXPRESSION_VALUE,
-			"Assignment to Proxy Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push expression proxy value expression.
-	 */
-	public final static int PUSH_TO_EXPRESSION_PROXY_EXPRESSION_VALUE = 16;
-
-	public final static InternalExpressionTypes PUSH_TO_EXPRESSION_PROXY_EXPRESSION = new InternalExpressionTypes(
-			PUSH_TO_EXPRESSION_PROXY_EXPRESSION_VALUE, "Push to Expression Proxy Expression"); //$NON-NLS-1$
-
-	/**
-	 * Assignment expression.
-	 */
-	public final static int ASSIGNMENT_EXPRESSION_VALUE = 17;
-
-	public final static InternalExpressionTypes ASSIGNMENT_EXPRESSION = new InternalExpressionTypes(ASSIGNMENT_EXPRESSION_VALUE,
-			"Assignment Expression"); //$NON-NLS-1$
-
-	/**
-	 * Block End expression.
-	 */
-	public final static int BLOCK_BEGIN_EXPRESSION_VALUE = 18;
-	
-	public final static InternalExpressionTypes BLOCK_BEGIN_EXPRESSION = new InternalExpressionTypes(BLOCK_BEGIN_EXPRESSION_VALUE,
-			"Begin block Expression"); //$NON-NLS-1$
-
-	/**
-	 * Block End expression.
-	 */
-	public final static int BLOCK_BREAK_EXPRESSION_VALUE = 19;
-	
-	public final static InternalExpressionTypes BLOCK_BREAK_EXPRESSION = new InternalExpressionTypes(BLOCK_BREAK_EXPRESSION_VALUE,
-			"Break block Expression"); //$NON-NLS-1$
-
-	/**
-	 * Block End expression.
-	 */
-	public final static int BLOCK_END_EXPRESSION_VALUE = 20;
-	
-	public final static InternalExpressionTypes BLOCK_END_EXPRESSION = new InternalExpressionTypes(BLOCK_END_EXPRESSION_VALUE,
-			"End block Expression"); //$NON-NLS-1$
-
-	/**
-	 * Try Begin expression.
-	 */
-	public final static int TRY_BEGIN_EXPRESSION_VALUE = 21;
-	
-	public final static InternalExpressionTypes TRY_BEGIN_EXPRESSION = new InternalExpressionTypes(TRY_BEGIN_EXPRESSION_VALUE,
-			"Begin try Expression"); //$NON-NLS-1$
-
-	/**
-	 * Try Catch expression.
-	 */
-	public final static int TRY_CATCH_EXPRESSION_VALUE = 22;
-	
-	public final static InternalExpressionTypes TRY_CATCH_EXPRESSION = new InternalExpressionTypes(TRY_CATCH_EXPRESSION_VALUE,
-			"Try catch Expression"); //$NON-NLS-1$
-	
-	/**
-	 * Try Finally expression.
-	 */
-	public final static int TRY_FINALLY_EXPRESSION_VALUE = 23;
-	
-	public final static InternalExpressionTypes TRY_FINALLY_EXPRESSION = new InternalExpressionTypes(TRY_FINALLY_EXPRESSION_VALUE,
-			"Try finally Expression"); //$NON-NLS-1$
-
-	/**
-	 * Try End expression.
-	 */
-	public final static int TRY_END_EXPRESSION_VALUE = 24;
-	
-	public final static InternalExpressionTypes TRY_END_EXPRESSION = new InternalExpressionTypes(TRY_END_EXPRESSION_VALUE,
-			"End try Expression"); //$NON-NLS-1$
-	
-	/**
-	 * Throw expression.
-	 */
-	public final static int THROW_EXPRESSION_VALUE = 25;
-	
-	public final static InternalExpressionTypes THROW_EXPRESSION = new InternalExpressionTypes(THROW_EXPRESSION_VALUE,
-			"Throw Expression"); //$NON-NLS-1$
-
-	/**
-	 * Rethrow expression.
-	 */
-	public final static int RETHROW_EXPRESSION_VALUE = 26;
-	
-	public final static InternalExpressionTypes RETHROW_EXPRESSION = new InternalExpressionTypes(RETHROW_EXPRESSION_VALUE,
-			"Rethrow Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push Method Lookup expression proxy expression.
-	 */
-	public final static int PUSH_METHOD_EXPRESSIONPROXY_EXPRESSION_VALUE = 27;
-	
-	public final static InternalExpressionTypes PUSH_METHOD_EXPRESSIONPROXY_EXPRESSION = new InternalExpressionTypes(PUSH_METHOD_EXPRESSIONPROXY_EXPRESSION_VALUE,
-			"Push Method ExpressionProxy Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push Field Lookup expression proxy expression.
-	 */
-	public final static int PUSH_FIELD_EXPRESSIONPROXY_EXPRESSION_VALUE = 28;
-	
-	public final static InternalExpressionTypes PUSH_FIELD_EXPRESSIONPROXY_EXPRESSION = new InternalExpressionTypes(PUSH_FIELD_EXPRESSIONPROXY_EXPRESSION_VALUE,
-			"Push Field ExpressionProxy Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push If/else (the clauses) expression proxy expression.
-	 */
-	public final static int IF_ELSE_EXPRESSION_VALUE = 29;
-	
-	public final static InternalExpressionTypes IF_ELSE_EXPRESSION = new InternalExpressionTypes(IF_ELSE_EXPRESSION_VALUE,
-			"Push If/else Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push If/else condition test expression proxy expression.
-	 */
-	public final static int IF_TEST_EXPRESSION_VALUE = 30;
-	
-	public final static InternalExpressionTypes IF_TEST_EXPRESSION = new InternalExpressionTypes(IF_TEST_EXPRESSION_VALUE,
-			"Push If Test Expression"); //$NON-NLS-1$
-
-
-	/**
-	 * Push new instance from init string proxy expression.
-	 */
-	public final static int NEW_INSTANCE_VALUE = 31;
-	
-	public final static InternalExpressionTypes NEW_INSTANCE = new InternalExpressionTypes(NEW_INSTANCE_VALUE,
-			"Push New Instance Expression"); //$NON-NLS-1$
-
-
-	/**
-	 * Push mark proxy expression.
-	 */
-	public final static int MARK_VALUE = 32;
-	
-	public final static InternalExpressionTypes MARK = new InternalExpressionTypes(MARK_VALUE,
-			"Push Mark Expression"); //$NON-NLS-1$
-
-	/**
-	 * Push end mark proxy expression.
-	 */
-	public final static int ENDMARK_VALUE = 33;
-	
-	public final static InternalExpressionTypes ENDMARK = new InternalExpressionTypes(ENDMARK_VALUE,
-			"Push End Mark Expression"); //$NON-NLS-1$
-
-	/**
-	 * Subexpression End expression.
-	 */
-	public final static int SUBEXPRESSION_BEGIN_EXPRESSION_VALUE = 34;
-	
-	public final static InternalExpressionTypes SUBEXPRESSION_BEGIN_EXPRESSION = new InternalExpressionTypes(SUBEXPRESSION_BEGIN_EXPRESSION_VALUE,
-			"Begin Subexpression Expression"); //$NON-NLS-1$
-
-	/**
-	 * Subexpression End expression.
-	 */
-	public final static int SUBEXPRESSION_END_EXPRESSION_VALUE = 35;
-	
-	public final static InternalExpressionTypes SUBEXPRESSION_END_EXPRESSION = new InternalExpressionTypes(SUBEXPRESSION_END_EXPRESSION_VALUE,
-			"End Subexpression Expression"); //$NON-NLS-1$
-	
-	
-	private InternalExpressionTypes(int value, String name) {
-		super(value, name);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalIfElseOperandType.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalIfElseOperandType.java
deleted file mode 100644
index c048a4d..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalIfElseOperandType.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InternalIfElseOperandType.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * Internal class for the If/else operand type. Not meant to be used by customers.
- * 
- * @since 1.1.0
- */
-public class InternalIfElseOperandType extends AbstractEnum {
-
-	/**
-	 * Used in If/else processing. False clause on expression stack
-	 */
-	public final static int ELSE_CLAUSE_VALUE = 0;
-
-	public final static InternalIfElseOperandType ELSE_CLAUSE = new InternalIfElseOperandType(ELSE_CLAUSE_VALUE,
-			"Else Clause Flag"); //$NON-NLS-1$
-
-	/**
-	 * Used in If/else processing. If operand on expression stack
-	 */
-	public final static int TRUE_CLAUSE_VALUE = 1;
-
-	public final static InternalIfElseOperandType TRUE_CLAUSE = new InternalIfElseOperandType(TRUE_CLAUSE_VALUE,
-			"If True Clause Flag"); //$NON-NLS-1$
-
-	/**
-	 * Return the enum for the given value.
-	 * @param value
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static InternalIfElseOperandType get(int value) {
-		switch (value) {
-			case ELSE_CLAUSE_VALUE:
-				return ELSE_CLAUSE;
-			case TRUE_CLAUSE_VALUE:
-				return TRUE_CLAUSE;
-		}
-		return null;
-	}
-
-	private InternalIfElseOperandType(int value, String name) {
-		super(value, name);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalInfixOperandType.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalInfixOperandType.java
deleted file mode 100644
index bef20d5..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/InternalInfixOperandType.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InternalInfixOperandType.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
- 
-
-/**
- * Internal class for the Prefix operand type. Not meant to be used by customers.
- * @since 1.1.0
- */
-public class InternalInfixOperandType extends AbstractEnum {
-
-	/**
-	 * Used in Infix processing. Left operand on expression stack
-	 */
-	public final static int INFIX_LEFT_OPERAND_VALUE = 0;
-	public final static InternalInfixOperandType INFIX_LEFT_OPERAND = new InternalInfixOperandType(INFIX_LEFT_OPERAND_VALUE, "Infix Left Operand Flag"); //$NON-NLS-1$
-	/**
-	 * Used in Infix processing. Other operand (but not last) on expression stack
-	 */
-	public final static int INFIX_OTHER_OPERAND_VALUE = 1;
-	public final static InternalInfixOperandType INFIX_OTHER_OPERAND = new InternalInfixOperandType(INFIX_OTHER_OPERAND_VALUE,
-	"Infix Other Operand Flag"); //$NON-NLS-1$
-	/**
-	 * Used in Infix processing. Rightmost (last) operand on expression stack
-	 */
-	public final static int INFIX_LAST_OPERAND_VALUE = 2;
-	public final static InternalInfixOperandType INFIX_LAST_OPERAND = new InternalInfixOperandType(INFIX_LAST_OPERAND_VALUE, "Infix Last Operand Flag"); //$NON-NLS-1$
-
-	/**
-	 * Return the enum for the given value.
-	 * @param value
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static InternalInfixOperandType get(int value) {
-		switch (value) {
-			case INFIX_LAST_OPERAND_VALUE:
-				return INFIX_LAST_OPERAND;
-			case INFIX_LEFT_OPERAND_VALUE:
-				return INFIX_LEFT_OPERAND;
-			case INFIX_OTHER_OPERAND_VALUE:
-				return INFIX_OTHER_OPERAND;
-		}
-		return null;
-	}
-	
-	private InternalInfixOperandType(int value, String name) {
-		super(value, name);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/NoExpressionValueException.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/NoExpressionValueException.java
deleted file mode 100644
index 41e6a77..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/NoExpressionValueException.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: NoExpressionValueException.java,v $
- *  $Revision: 1.3 $  $Date: 2005/07/20 19:27:25 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
- 
-
-/**
- * The expression (or some nested expression) did not return a value. I.e. it was <code>void</code>.
- * This would occur only if the value of expression was being retrieved through getExpressionValue,
- * or if a nested expression was used, since in that case the value would of been used as an
- * argument or receiver to another expression.
- * 
- * @since 1.0.0
- */
-public class NoExpressionValueException extends Exception {
-	
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -7953101867782417964L;
-	
-	private InternalExpressionProxy proxy;
-
-	/**
-	 * Construct with no arguments.
-	 * 
-	 * @since 1.0.0
-	 */
-	public NoExpressionValueException() {
-		super();
-	}
-	
-	public NoExpressionValueException(Throwable e) {
-		super(e);
-	}
-
-	/**
-	 * Construct with a message.
-	 * 
-	 * @param message
-	 * 
-	 * @since 1.0.0
-	 */
-	public NoExpressionValueException(String message) {
-		this(message, null);
-	}
-	
-	/**
-	 * Construct with a message and a proxy. This is only used from {@link ExpressionProcesser#getExpressionProxyValue(int, Object[])} when
-	 * the proxy existed but it was not set.
-	 * 
-	 * @param message
-	 * @param proxy
-	 * 
-	 * @since 1.1.0
-	 */
-	public NoExpressionValueException(String message, InternalExpressionProxy proxy) {
-		super (message);
-		this.proxy = proxy;
-	}
-	
-	/**
-	 * Get the proxy if there is one. It will be a proxy if {@link ExpressionProcesser#getExpressionProxyValue(int, Object[])}
-	 * was for an existing proxy but that proxy was not set. Otherwise it will be null. This is here for callers to
-	 * put special info in the proxy for the not set condition and report better info.
-	 * 
-	 * @return the proxy (if not set) or <code>null</code> if no proxy available.
-	 * 
-	 * @since 1.1.0
-	 */
-	public InternalExpressionProxy getProxy() {
-		return proxy;
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/PrefixOperator.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/PrefixOperator.java
deleted file mode 100644
index a1e0a30..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/PrefixOperator.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PrefixOperator.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
-
-/**
- * Enum for prefix operator.
- * 
- * @since 1.1.0
- */
-public class PrefixOperator extends AbstractEnum {
-
-	/**
-	 * Prefix plus "+"
-	 */
-	public static final int PRE_PLUS_VALUE = 0;
-
-	public static final PrefixOperator PRE_PLUS = new PrefixOperator(PRE_PLUS_VALUE, "Prefix +"); //$NON-NLS-1$
-
-	/**
-	 * Prefix minus "-"
-	 */
-	public static final int PRE_MINUS_VALUE = 1;
-
-	public static final PrefixOperator PRE_MINUS = new PrefixOperator(PRE_MINUS_VALUE, "Prefix -"); //$NON-NLS-1$
-
-	/**
-	 * Prefix bitwise complement "~"
-	 */
-	public static final int PRE_COMPLEMENT_VALUE = 2;
-
-	public static final PrefixOperator PRE_COMPLEMENT = new PrefixOperator(PRE_COMPLEMENT_VALUE, "Prefix ~"); //$NON-NLS-1$
-
-	/**
-	 * Prefix logical not "!"
-	 */
-	public static final int PRE_NOT_VALUE = 3;
-
-	public static final PrefixOperator PRE_NOT = new PrefixOperator(PRE_NOT_VALUE, "Prefix !"); //$NON-NLS-1$
-
-	/**
-	 * Return the prefix operator for the given enum value.
-	 * @param value
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static PrefixOperator get(int value) {
-		switch (value) {
-			case PRE_PLUS_VALUE:
-				return PRE_PLUS;
-			case PRE_MINUS_VALUE:
-				return PRE_MINUS;
-			case PRE_COMPLEMENT_VALUE:
-				return PRE_COMPLEMENT;
-			case PRE_NOT_VALUE:
-				return PRE_NOT;
-		}
-		return null;
-	}
-
-	private PrefixOperator(int value, String name) {
-		super(value, name);
-	}
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/VariableReference.java b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/VariableReference.java
deleted file mode 100644
index 645f2b3..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/VariableReference.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: VariableReference.java,v $
- *  $Revision: 1.2 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.initParser.tree;
- 
-
-/**
- * This represents a Variable Reference value. A variable reference value can be on the left
- * side of an assignment (e.g. field or array access) or on any side
- * of any expression. When on the left side of an assignment, then the
- * value can assigned to. Such as <code>x[3] = 4</code>. Or it is value
- * that can be used in expressions, such as <code>x[3] + 2</code>.
- * <p>
- * When dereferenced, the value is given (see {@link VariableReference#dereference()}) as
- * the result or it is set with a value and then deferenced (see {@link VariableReference#set(Object, Class)}).
- * <p>
- * The type of the reference is the type stored in the corresponding expressionTypeStack entry. This is the type
- * for assignment, and the type for dereferenced.
- * @since 1.1.0
- */
-public abstract class VariableReference {
-
-	/**
-	 * Dereference the value. 
-	 * @return the dereferenced value. Such as the result of <code>x[3]</code>. The type of the reference 
-	 * is the type stored in the corresponding expressionTypeStack entry for this reference.
-	 * @throws IllegalAccessException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.1.0
-	 */
-	public abstract Object dereference();
-	
-	/**
-	 * Set the value into the variable and dereference it. Once it is set it is
-	 * no longer a reference and must be dereferenced.
-	 * @param value value to set to.
-	 * @param type type of the value being set. It may be of use to the reference or maybe not.
-	 * @return the dereferenced value after being set. The type of the dereferenced value 
-	 * is the type stored in the corresponding expressionTypeStack entry for this reference.
-	 * @throws IllegalAccessException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.1.0
-	 */
-	public abstract Object set(Object value, Class type) throws IllegalArgumentException, IllegalAccessException;
-}
diff --git a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/messages.properties b/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/messages.properties
deleted file mode 100644
index da6840d..0000000
--- a/plugins/org.eclipse.jem.proxy/initParser/org/eclipse/jem/internal/proxy/initParser/tree/messages.properties
+++ /dev/null
@@ -1,29 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-ExpressionProcesser.CannotCastXToY_EXC_                           = IWAV0156E Cannot cast "{0}" to be "{1}".
-ExpressionProcesser.InvalidOperandOfPrefixOperator_EXC_           = IWAV0157E {0} not valid as the operand of prefix operator "{1}".
-ExpressionProcesser.PopExpressionType.ExpressionVoid_EXC_=Expression was void.
-ExpressionProcesser.InvalidOperandOfOperator_EXC_                 = IWAV0158E {0} not valid as the operand of operator "{1}".
-ExpressionProcesser.XIsGreaterThanNumberOfDimensionsInArray_EXC_  = IWAV0159E {0} is greater then number of dimensions ({1}) in the array
-ExpressionProcesser.CreateArrayAccessReference.OutOfBounds_EXC_=Index: {0} size:{1}
-ExpressionProcesser.PushTryEnd.TryEndReceivedOutOfOrder_EXC_=Try/end received out of order.
-ExpressionProcesser.PushEndmark.EndMarkOnNonExistingID_EXC_=Tried to do an end mark on a non-existing markID ({0})
-ExpressionProcesser.NotAnArray_EXC_                               = IWAV0160E "{0}" is not an array.
-ExpressionProcesser.ArraytypeHasFewerDimensionsThanRequested_EXC_ = IWAV0161E Arraytype "{0}" has fewer dimensions than creation requested ({1}).
-ExpressionProcesser.CreateFieldAccessReference.FieldsTypesNotMatching_EXC_=Field receiver does not match the type of the field: Field: {0} receiver: {1}
-ExpressionProcesser.GetExpressionProxyValue.ExpressionProxyNotSet_EXC_=Expression Proxy never set.
-ExpressionProcesser.GetExpressionProxyValue.ExpressionProxyDoesntExist_EXC_=Expression proxy doesn't exist.
-ExpressionProcesser.PushBlockEnd.ReceivedEndBlocksOutOfOrder_EXC_=End Blocks received out of order.
-ExpressionProcesser.PushTryCatchClause.CatchReceivedOutOfOrder_EXC_=Catch received out of order.
-ExpressionProcesser.PushTryFinallyClause.FinallyReceivedOutOfOrder_EXC_=Finally received out of order.
-ExpressionProcesser.PushTryRethrow.RethrowReceivedOutOfOrder_EXC_=Rethrow received out of order.
-ExpressionProcesser.PushTryRethrow.RetryReceivedOutOfExecutingCatchClause_EXC_=Retry received outside of an executing catch clause
-ExpressionProcesser.PushSubexpressionEnd.ReceivedEndSubexpressionsOutOfOrder_EXC_=End Subexpressions received out of order.
diff --git a/plugins/org.eclipse.jem.proxy/plugin.properties b/plugins/org.eclipse.jem.proxy/plugin.properties
deleted file mode 100644
index e07dfc9..0000000
--- a/plugins/org.eclipse.jem.proxy/plugin.properties
+++ /dev/null
@@ -1,21 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.proxy/plugin.properties,v $
-# $Revision: 1.7 $  $Date: 2005/08/24 20:39:07 $
-#
-
-
-pluginName=Java EMF Model Proxy Support
-providerName = Eclipse.org
-contributors.extensionpoint.name=Proxy configuration contributors
-extensions.extensionpoint.name=Proxy configuration extension registrations
-Launch.localProxy=Local Proxy Application
diff --git a/plugins/org.eclipse.jem.proxy/plugin.xml b/plugins/org.eclipse.jem.proxy/plugin.xml
deleted file mode 100644
index ca74b42..0000000
--- a/plugins/org.eclipse.jem.proxy/plugin.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-
-     <extension-point id="contributors" name="%contributors.extensionpoint.name" schema="schema/contributors.exsd"/>
-   <extension-point id="extensions" name="%extensions.extensionpoint.name" schema="schema/extensions.exsd"/>
-
-   <extension
-         point="org.eclipse.debug.core.launchConfigurationTypes">
-      <launchConfigurationType
-            name="%Launch.localProxy"
-            delegate="org.eclipse.jem.internal.proxy.remote.LocalProxyLaunchDelegate"
-            category="org.eclipse.jem.proxy"
-            modes="run"
-            id="org.eclipse.jem.proxy.LocalProxyLaunchConfigurationType"
-            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
-            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
-      </launchConfigurationType>
-   </extension>
-
-</plugin>
diff --git a/plugins/org.eclipse.jem.proxy/proxy.jars b/plugins/org.eclipse.jem.proxy/proxy.jars
deleted file mode 100644
index 10aede4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy.jars
+++ /dev/null
@@ -1,4 +0,0 @@
-proxycommon.jar=/org.eclipse.jem.proxy/common_bin/
-initparser.jar=/org.eclipse.jem.proxy/common_bin/
-remotecommon.jar=/org.eclipse.jem.proxy/common_bin/
-vm/remotevm.jar=/org.eclipse.jem.proxy/vm_bin/
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/awt/IStandardAwtBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/awt/IStandardAwtBeanProxyFactory.java
deleted file mode 100644
index f1e03fd..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/awt/IStandardAwtBeanProxyFactory.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.awt;
-/*
- *  $RCSfile: IStandardAwtBeanProxyFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.IBeanProxyFactory;
-/**
- * The Standard awt bean proxy factory.
- * This is the Interface that the desktop will talk
- * to.
- * Creation date: (12/3/99 11:52:09 AM)
- * @author: Joe Winchester
- */
-public interface IStandardAwtBeanProxyFactory extends IBeanProxyFactory {
-	public static final String REGISTRY_KEY = "standard-java.awt"; //$NON-NLS-1$
-
-/**
- * Return a new bean proxy for the dimension argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IDimensionBeanProxy createDimensionBeanProxyWith(int width, int height);
-/**
- * Return a new bean proxy for the point argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IPointBeanProxy createPointBeanProxyWith(int x, int y);
-/**
- * Return a new bean proxy for the rectangle argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IRectangleBeanProxy createBeanProxyWith(int x, int y, int width, int height);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/awt/JavaStandardAwtBeanConstants.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/awt/JavaStandardAwtBeanConstants.java
deleted file mode 100644
index 4e2f2a0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/awt/JavaStandardAwtBeanConstants.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.awt;
-/*
- *  $RCSfile: JavaStandardAwtBeanConstants.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Standard AWT Constants
- *
- * Use the static accessor method (getConstants()) to get the appropriate 
- * constants instance for the registry. This is done so that until the
- * the constants are needed, they aren't registered.
- *
- * NOTE: Since everything in here just proxies, there is
- *       no need to have them separated by VM. That is why
- *       this in the Proxy package.
- *
- * This is final because this can't be extended. This specific one
- * will be registered with the factory for this key. Any extensions
- * must be done in their own constants and registry key.
- *
- * Creation date: (4/7/00 4:47:48 PM)
- * @author: Administrator
- */
-public final class JavaStandardAwtBeanConstants {
-		
-	public static final Object REGISTRY_KEY = new Object();
-			
-	final boolean AWTLoaded;	// AWT may not be available. So non-ui JVM's don't have AWT.
-	final boolean AWTRegistered;	// AWT was registered to be used in this VM. It may be registered, but still not available.
-		
-	final IFieldProxy dimensionHeightProxy;
-	final IFieldProxy dimensionWidthProxy;
-	final IMethodProxy setDimensionSizeHWProxy;
-	final IMethodProxy setDimensionSizeDProxy;
-	
-	final IFieldProxy pointXProxy;
-	final IFieldProxy pointYProxy;
-	final IMethodProxy setPointLocationXYProxy;
-	final IMethodProxy setPointLocationPProxy;
-	
-	final IFieldProxy rectangleHeightProxy;
-	final IFieldProxy rectangleWidthProxy;
-	final IFieldProxy rectangleXProxy;
-	final IFieldProxy rectangleYProxy;
-	final IMethodProxy setRectangleSizeHWProxy;
-	final IMethodProxy setRectangleSizeDProxy;
-	final IMethodProxy setRectangleLocationXYProxy;
-	final IMethodProxy setRectangleLocationPProxy;
-	final IMethodProxy setRectangleBoundsXYHWProxy;
-	final IMethodProxy setRectangleBoundsRProxy;
-	
-/**
- * Get the constants instance for the specified registry.
- */
-public static JavaStandardAwtBeanConstants getConstants(ProxyFactoryRegistry registry) {
-	JavaStandardAwtBeanConstants constants = (JavaStandardAwtBeanConstants) registry.getConstants(REGISTRY_KEY);
-	if (constants == null)
-		registry.registerConstants(REGISTRY_KEY, constants = new JavaStandardAwtBeanConstants(registry, registry.getBeanProxyFactoryExtension(IStandardAwtBeanProxyFactory.REGISTRY_KEY) != null));
-	return constants;
-}
-		
-
-public JavaStandardAwtBeanConstants(ProxyFactoryRegistry registry, boolean isRegistered) {
-	super();
-	
-	AWTRegistered = isRegistered;
-	if (!AWTRegistered) {
-		AWTLoaded = false;
-		dimensionHeightProxy = dimensionWidthProxy = pointXProxy = pointYProxy = rectangleHeightProxy = rectangleWidthProxy = rectangleXProxy = rectangleYProxy = null;
-		setDimensionSizeHWProxy = setDimensionSizeDProxy = setPointLocationXYProxy = setPointLocationPProxy = setRectangleSizeHWProxy = setRectangleSizeDProxy = setRectangleLocationXYProxy = setRectangleLocationPProxy = setRectangleBoundsXYHWProxy = setRectangleBoundsRProxy = null;		
-		return;
-	}
-	
-	IStandardBeanTypeProxyFactory typeFactory = registry.getBeanTypeProxyFactory();
-	
-	IBeanTypeProxy dimensionTypeProxy = typeFactory.getBeanTypeProxy("java.awt.Dimension");//$NON-NLS-1$
-	if (dimensionTypeProxy != null) {
-		// AWT is available.
-		AWTLoaded = true;
-		IBeanTypeProxy intTypeProxy = typeFactory.getBeanTypeProxy("int"); //$NON-NLS-1$
-		
-		dimensionHeightProxy = dimensionTypeProxy.getFieldProxy("height");//$NON-NLS-1$
-		dimensionWidthProxy = dimensionTypeProxy.getFieldProxy("width");//$NON-NLS-1$
-		setDimensionSizeHWProxy = dimensionTypeProxy.getMethodProxy("setSize", new IBeanTypeProxy[] {intTypeProxy, intTypeProxy}); //$NON-NLS-1$
-		setDimensionSizeDProxy = dimensionTypeProxy.getMethodProxy("setSize", new IBeanTypeProxy[] {dimensionTypeProxy}); //$NON-NLS-1$
-	
-		IBeanTypeProxy pointTypeProxy = typeFactory.getBeanTypeProxy("java.awt.Point");//$NON-NLS-1$
-		pointXProxy = pointTypeProxy.getFieldProxy("x");//$NON-NLS-1$
-		pointYProxy = pointTypeProxy.getFieldProxy("y");	//$NON-NLS-1$
-		setPointLocationXYProxy = pointTypeProxy.getMethodProxy("setLocation", new IBeanTypeProxy[] {intTypeProxy, intTypeProxy}); //$NON-NLS-1$
-		setPointLocationPProxy = pointTypeProxy.getMethodProxy("setLocation", new IBeanTypeProxy[] {pointTypeProxy}); //$NON-NLS-1$
-		
-		
-		IBeanTypeProxy rectangleTypeProxy = typeFactory.getBeanTypeProxy("java.awt.Rectangle");//$NON-NLS-1$
-		rectangleHeightProxy = rectangleTypeProxy.getFieldProxy("height");//$NON-NLS-1$
-		rectangleWidthProxy = rectangleTypeProxy.getFieldProxy("width");//$NON-NLS-1$
-		rectangleXProxy = rectangleTypeProxy.getFieldProxy("x");//$NON-NLS-1$
-		rectangleYProxy = rectangleTypeProxy.getFieldProxy("y");//$NON-NLS-1$
-		setRectangleSizeHWProxy = rectangleTypeProxy.getMethodProxy("setSize", new IBeanTypeProxy[] {intTypeProxy, intTypeProxy}); //$NON-NLS-1$
-		setRectangleSizeDProxy = rectangleTypeProxy.getMethodProxy("setSize", new IBeanTypeProxy[] {dimensionTypeProxy}); //$NON-NLS-1$
-		setRectangleLocationXYProxy = rectangleTypeProxy.getMethodProxy("setLocation", new IBeanTypeProxy[] {intTypeProxy, intTypeProxy}); //$NON-NLS-1$
-		setRectangleLocationPProxy = rectangleTypeProxy.getMethodProxy("setLocation", new IBeanTypeProxy[] {pointTypeProxy});		 //$NON-NLS-1$
-		setRectangleBoundsXYHWProxy = rectangleTypeProxy.getMethodProxy("setBounds", new IBeanTypeProxy[] {intTypeProxy, intTypeProxy, intTypeProxy, intTypeProxy}); //$NON-NLS-1$
-		setRectangleBoundsRProxy = rectangleTypeProxy.getMethodProxy("setBounds", new IBeanTypeProxy[] {rectangleTypeProxy}); //$NON-NLS-1$
-	} else {
-		AWTLoaded = false;
-		dimensionHeightProxy = dimensionWidthProxy = pointXProxy = pointYProxy = rectangleHeightProxy = rectangleWidthProxy = rectangleXProxy = rectangleYProxy = null;
-		setDimensionSizeHWProxy = setDimensionSizeDProxy = setPointLocationXYProxy = setPointLocationPProxy = setRectangleSizeHWProxy = setRectangleSizeDProxy = setRectangleLocationXYProxy = setRectangleLocationPProxy = setRectangleBoundsXYHWProxy = setRectangleBoundsRProxy = null;
-	}
-}
-
-/**
- * Answer if AWT is available.
- */
-public boolean isAWTAvailable() {
-	return AWTLoaded;
-}
-
-/**
- * Answer if AWT was registered to be available.
- */
-public boolean isAWTRegistered() {
-	return AWTRegistered;
-}
-
-
-
-/**
- * getDimensionHeightFieldProxy method comment.
- */
-public IFieldProxy getDimensionHeightFieldProxy() {
-	return dimensionHeightProxy;
-}
-/**
- * getDimensionWidthProxy method comment.
- */
-public IFieldProxy getDimensionWidthFieldProxy() {
-	return dimensionWidthProxy;
-}
-/**
- * getDimensionSetSizeWHProxy method comment.
- */
-public IMethodProxy getDimensionSetSizeHWProxy() {
-	return setDimensionSizeHWProxy;
-}
-/**
- * getDimensionSetSizeDProxy method comment.
- */
-public IMethodProxy getDimensionSetSizeDProxy() {
-	return setDimensionSizeDProxy;
-}
-
-/**
- * getPointXFieldProxy method comment.
- */
-public IFieldProxy getPointXFieldProxy() {
-	return pointXProxy;
-}
-/**
- * getPointYFieldProxy method comment.
- */
-public IFieldProxy getPointYFieldProxy() {
-	return pointYProxy;
-}
-/**
- * getPointSetLocationXYProxy method comment.
- */
-public IMethodProxy getPointSetLocationXYProxy() {
-	return setPointLocationXYProxy;
-}
-/**
- * getPointSetLocationPProxy method comment.
- */
-public IMethodProxy getPointSetLocationPProxy() {
-	return setPointLocationPProxy;
-}
-/**
- * getRectangleHeightFieldProxy method comment.
- */
-public IFieldProxy getRectangleHeightFieldProxy() {
-	return rectangleHeightProxy;
-}
-/**
- * getRectangleWidthFieldProxy method comment.
- */
-public IFieldProxy getRectangleWidthFieldProxy() {
-	return rectangleWidthProxy;
-}
-/**
- * getRectangleXFieldProxy method comment.
- */
-public IFieldProxy getRectangleXFieldProxy() {
-	return rectangleXProxy;
-}
-/**
- * getRectangleYFieldProxy method comment.
- */
-public IFieldProxy getRectangleYFieldProxy() {
-	return rectangleYProxy;
-}
-/**
- * getRectangleSetSizeWHProxy method comment.
- */
-public IMethodProxy getRectangleSetSizeHWProxy() {
-	return setRectangleSizeHWProxy;
-}
-/**
- * getRectangleSetSizeDProxy method comment.
- */
-public IMethodProxy getRectangleSetSizeDProxy() {
-	return setRectangleSizeDProxy;
-}
-/**
- * getRectangleSetLocationXYProxy method comment.
- */
-public IMethodProxy getRectangleSetLocationXYProxy() {
-	return setRectangleLocationXYProxy;
-}
-/**
- * getRectangleSetLocationPProxy method comment.
- */
-public IMethodProxy getRectangleSetLocationPProxy() {
-	return setRectangleLocationPProxy;
-}
-
-/**
- * getRectangleSetBoundsXYHWProxy method comment.
- */
-public IMethodProxy getRectangleSetBoundsXYHWProxy() {
-	return setRectangleBoundsXYHWProxy;
-}
-/**
- * getRectangleSetBoundsRProxy method comment.
- */
-public IMethodProxy getRectangleSetBoundsRProxy() {
-	return setRectangleBoundsRProxy;
-}
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/BaseProxyFactoryRegistry.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/BaseProxyFactoryRegistry.java
deleted file mode 100644
index 1faf179..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/BaseProxyFactoryRegistry.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BaseProxyFactoryRegistry.java,v $
- *  $Revision: 1.1 $  $Date: 2005/06/15 20:19:11 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-/**
- * This is the Base Registry that all implementations should subclass. 
- * <p>
- * It is not meant to be used by customers. It provides public functions only for access of individual implementations.
- * Customers should only access {@link org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry}.
- * 
- * @since 1.1.0
- */
-public abstract class BaseProxyFactoryRegistry extends ProxyFactoryRegistry {
-
-	private final String registryTypeID;
-
-	/**
-	 * Construct with registry type ID. The type id should be provided by
-	 * each implementation. This will be used to provide specific type
-	 * registrations through contributions.
-	 *  
-	 * @param registryTypeID
-	 * 
-	 * @since 1.1.0
-	 */
-	protected BaseProxyFactoryRegistry(String registryTypeID) {
-		super();
-		this.registryTypeID = registryTypeID;
-	}
-	
-	/**
-	 * Return the reqistry type id.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public String getRegistryTypeID() {
-		return registryTypeID;
-	}
-
-	/**
-	 Register the current registered bean proxy factory to be used for creating IBeanProxy instances
-	 */
-	public void registerBeanProxyFactory(IStandardBeanProxyFactory aStandardFactory) {
-		fCurrentStandardBeanProxyFactory = aStandardFactory;
-	}
-
-	/**
-	 Register a factory to be used for creating IBeanProxy instances
-	 */
-	public void registerBeanProxyFactory(String packageName, IBeanProxyFactory aFactory) {
-		fRegisteredExtensionBeanProxyFactories.put(packageName, aFactory);
-	}
-
-	/**
-	 Register the current registered bean type proxy factory to be used for creating IBeanTypeProxy instances
-	 */
-	public void registerBeanTypeProxyFactory(IStandardBeanTypeProxyFactory aStandardFactory) {
-		fCurrentStandardBeanTypeProxyFactory = aStandardFactory;
-	}
-
-	/**
-	 Register a factory to be used for creating IBeanTypeProxy instances
-	 */
-	public void registerBeanTypeProxyFactory(String packageName, IBeanTypeProxyFactory aFactory) {
-		fRegisteredExtensionBeanTypeProxyFactories.put(packageName, aFactory);
-	}
-
-	/**
-	 * Set the Method Proxy Factory for this VM.
-	 * Creation date: (3/13/00 10:58:19 AM)
-	 */
-	public void registerMethodProxyFactory(IMethodProxyFactory newMethodProxyFactory) {
-		fMethodProxyFactory = newMethodProxyFactory;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/CollectionBeanProxyWrapper.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/CollectionBeanProxyWrapper.java
deleted file mode 100644
index eaa81ff..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/CollectionBeanProxyWrapper.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: CollectionBeanProxyWrapper.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.core.runtime.*;
-/**
- * This is a wrapper for an java.util.Collection proxy.
- * It provides the collection methods to interface to
- * the proxy.
- */
-
-public class CollectionBeanProxyWrapper {
-	protected final IBeanProxy fCollection;
-	protected final JavaStandardBeanProxyConstants fConstants;
-	
-	/**
-	 * Construct with the collection.
-	 */
-	public CollectionBeanProxyWrapper(IBeanProxy aCollectionProxy) {
-		if (!aCollectionProxy.getTypeProxy().isKindOf(aCollectionProxy.getProxyFactoryRegistry().getBeanTypeProxyFactory().getBeanTypeProxy("java.util.Collection"))) //$NON-NLS-1$
-			throw new ClassCastException(java.text.MessageFormat.format(ProxyMessages.ClassCast_EXC__IncorrectType, new Object[] {aCollectionProxy.getTypeProxy().getTypeName(), "java.util.Collection"})); 
-		else
-			fCollection = aCollectionProxy;
-			
-		fConstants = JavaStandardBeanProxyConstants.getConstants(aCollectionProxy.getProxyFactoryRegistry());
-	}
-	
-	/**
-	 * Answer the collection proxy that this is wrappering.
-	 */
-	public IBeanProxy getBeanProxy() {
-		return fCollection;
-	}
-
-	/**
-	 * equals - Pass it on to the proxy to handle this.
-	 */
-	public boolean equals(Object object) {
-		return fCollection.equals(object);
-	}
-	
-	/**
-	 * hashCode - Pass it on to the proxy to handle this.
-	 */
-	public int hashCode() {
-		return fCollection.hashCode();
-	}
-	
-	/**
-	 * Collection accessors
-	 */
-	public boolean add(IBeanProxy object) throws ThrowableProxy {
-		return ((IBooleanBeanProxy) fConstants.getCollectionAdd().invoke(fCollection, object)).booleanValue();
-	}
-	public boolean addAll(IBeanProxy collection) throws ThrowableProxy {
-		return ((IBooleanBeanProxy) fConstants.getCollectionAddAll().invoke(fCollection, collection)).booleanValue();
-	}
-	public void clear() throws ThrowableProxy {
-		fConstants.getCollectionClear().invoke(fCollection);
-	}
-	public boolean contains(IBeanProxy object) {
-		try {
-			return ((IBooleanBeanProxy) fConstants.getCollectionContains().invoke(fCollection, object)).booleanValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return false;
-		}
-	}
-	public boolean containsAll(IBeanProxy collection) {
-		try {
-			return ((IBooleanBeanProxy) fConstants.getCollectionContainsAll().invoke(fCollection, collection)).booleanValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return false;
-		}			
-	}		
-	public boolean isEmpty() {
-		try {
-			return ((IBooleanBeanProxy) fConstants.getCollectionIsEmpty().invoke(fCollection)).booleanValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return true;
-		}			
-	}		
-	public IteratorBeanProxyWrapper iterator() {
-		try {
-			IBeanProxy itr = fConstants.getCollectionIterator().invoke(fCollection);
-			if (itr != null)
-				return new IteratorBeanProxyWrapper(itr);
-			else
-				return null;
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return null;
-		}			
-	}
-	public boolean remove(IBeanProxy object) throws ThrowableProxy {
-		return ((IBooleanBeanProxy) fConstants.getCollectionRemove().invoke(fCollection, object)).booleanValue();
-	}
-	public boolean removeAll(IBeanProxy collection) throws ThrowableProxy {
-		return ((IBooleanBeanProxy) fConstants.getCollectionRemoveAll().invoke(fCollection, collection)).booleanValue();
-	}		
-	public boolean retainAll(IBeanProxy collection) throws ThrowableProxy {
-		return ((IBooleanBeanProxy) fConstants.getCollectionRetainAll().invoke(fCollection, collection)).booleanValue();
-	}
-	public int size() {
-		try {
-			return ((IIntegerBeanProxy) fConstants.getCollectionSize().invoke(fCollection)).intValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return 0;
-		}			
-	}	
-	public IArrayBeanProxy toArray() throws ThrowableProxy {
-		return (IArrayBeanProxy) fConstants.getCollectionToArray().invoke(fCollection);
-	}
-	public IArrayBeanProxy toArray(IArrayBeanProxy array) throws ThrowableProxy {
-		return (IArrayBeanProxy) fConstants.getCollectionToArrayWithArray().invoke(fCollection, array);
-	}	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ConfigurationContributorAdapter.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ConfigurationContributorAdapter.java
deleted file mode 100644
index be242da..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ConfigurationContributorAdapter.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ConfigurationContributorAdapter.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
- 
-/**
- * This is an implementation of IConfigurationContributor that does nothing. It
- * can be subclassed to provide specific overrides.
- * @since 1.0.0
- */
-public class ConfigurationContributorAdapter implements IConfigurationContributor {
-
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributor#initialize(org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo)
-	 */
-	public void initialize(IConfigurationContributionInfo info) {
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributor#contributeClasspaths(org.eclipse.jem.internal.proxy.core.IConfigurationContributionController)
-	 */
-	public void contributeClasspaths(IConfigurationContributionController controller) throws CoreException {
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributor#contributeToConfiguration(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
-	 */
-	public void contributeToConfiguration(ILaunchConfigurationWorkingCopy config) throws CoreException {
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributor#contributeToRegistry(org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry)
-	 */
-	public void contributeToRegistry(ProxyFactoryRegistry registry) {
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ContainerPathContributionMapping.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ContainerPathContributionMapping.java
deleted file mode 100644
index c092168..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ContainerPathContributionMapping.java
+++ /dev/null
@@ -1,186 +0,0 @@
-package org.eclipse.jem.internal.proxy.core;
-
-import java.lang.reflect.Array;
-import java.util.*;
-import java.util.regex.Pattern;
-
-
-/**
- * Mapping of container paths (Regular expressions) to configuration elements.
- * <p>
- * It can be instantiated by clients that need to built up a subset of the mapping from the 
- * normal mapping done by {@link ProxyPlugin#getPluginExtensions(String)}.
- * <p>
- * To build one up separately clients would:
- * <pre><code>
- * ContainerPathContributionMapping mapping = new ContainerPathContributionMapping(contributionType);
- * mapping.addContribution(containerid, pattern, contribution);
- * 	...
- * mapping.finalizeMapping();
- * </code></pre>
- * 
- * @since 1.2.0
- */
-public class ContainerPathContributionMapping {
-	
-	/**
-	 * Used in {@link ContainerPathContributionMapping#containerIdToContributions} as the value of the map. 
-	 * This contains a Pattern for a container path to match against to see if the contribution
-	 * should be used.
-	 * <p>
-	 * Normally it would be better to use {@link ContainerPathContributionMapping#getContributors(String, String[])}
-	 * to get all of the contributors for all of the paths of the same container id. 
-	 * 
-	 * @since 1.2.0
-	 */
-	public static class ContainerContributionEntry {
-		
-		private final Object contribution;
-		private final Pattern containerPathPattern;
-	
-		public ContainerContributionEntry(Object contribution, Pattern containerPathPattern) {
-			this.contribution = contribution;
-			this.containerPathPattern = containerPathPattern;
-		}
-		
-		
-		/**
-		 * @return Returns the contribution.
-		 * 
-		 * @since 1.2.0
-		 */
-		public final Object getContribution() {
-			return contribution;
-		}
-		
-		
-		/**
-		 * @return Returns the container pattern for matching.
-		 * 
-		 * @since 1.2.0
-		 */
-		public final Pattern getContainerPathPattern() {
-			return containerPathPattern;
-		}
-	}
-
-	
-	/**
-	 * Map of container ids (String, first segment of container path) to {@link ContainerContributionEntry[]}.
-	 * <p>
-	 * Normally it would be better to use {@link #getContributors(String, String[])}
-	 * to get all of the contributors for all of the paths of the same container id. 
-	 * 
-	 * @since 1.2.0
-	 */
-	public Map containerIdToContributions = Collections.EMPTY_MAP;
-	
-	// TODO When 1.5, this can go away.
-	private final Class contributionType;
-	
-	/**
-	 * Create with contribution type (i.e. the array type returned from {@link #getContributors(String, String[])}.
-	 * <p>
-	 * TODO This will go away with 1.5 because this will be templated.
-	 * 
-	 * @param type
-	 * 
-	 * 
-	 * @since 1.2.0
-	 */
-	public ContainerPathContributionMapping(Class type) {
-		contributionType = type;
-	}
-	
-	
-	/**
-	 * Get the unique array of configuration elements (no duplicates) for the given container id, and
-	 * the set of container paths for that container id. For example, "SWT_CONTAINER" as containerID and
-	 * {"/SWT_CONTAINER/", "/SWT_CONTAINER/PDE/JFACE"} for container paths. This will then return configuration elements
-	 * that match these two paths in the container attribute of the configuration element. The container attribute
-	 * is a regular expression. For example "SWT_CONTAINER" will match both "/SWT_CONTAINER/" and "/SWT_CONTAINER/PDE/JFACE"
-	 * while "SWT_CONTAINER/.* /JFACE" will match "/SWT_CONTAINER/PDE/JFACE". (Note it is actually no space between the "*" and "/" but java comment syntax won't allow it.)   
-	 * @param containerId id of all the containers in the list of paths (the first segment of all of the paths).
-	 * @param containerPaths array of all of the paths to look for contributions for.
-	 * @return array of configuration elements for the given list of paths. They will be in order declared within a plugin within plugin order.
-	 * 
-	 * @since 1.2.0
-	 */
-	public Object[] getContributors(String containerId, String[] containerPaths) {
-		ContainerContributionEntry[] bundleContributions = (ContainerContributionEntry[]) containerIdToContributions.get(containerId);
-		if (bundleContributions == null)
-			return (Object[]) Array.newInstance(contributionType, 0);
-		List contributions = new ArrayList();
-		// Patterns that have been tested. Key is a pattern, value is Boolean. true if this pattern matched any of the container paths.
-		// This way a pattern will only be tested once for the list of paths. If the pattern is found the list again we will know if it
-		// should be selected or not.
-		// The bundleContributions are in order declared within each plugin within plugin order.
-		Map testedPatterns = new HashMap();
-		for (int i = 0; i < bundleContributions.length; i++) {
-			Boolean tested = (Boolean) testedPatterns.get(bundleContributions[i].getContainerPathPattern());
-			if (tested == null) {
-				// Need to test it.
-				// Run through container paths and see if any match.
-				tested = Boolean.FALSE;
-				Pattern pattern = bundleContributions[i].getContainerPathPattern();
-				for (int j = 0; j < containerPaths.length; j++) {
-					if (pattern.matcher(containerPaths[j]).matches()) {
-						tested = Boolean.TRUE;
-						break;
-					}
-				}
-				testedPatterns.put(pattern, tested);
-			}
-			if (tested.booleanValue())
-				contributions.add(bundleContributions[i].getContribution());
-		}
-		return contributions.toArray((Object[]) Array.newInstance(contributionType, contributions.size()));
-	}
-
-	/**
-	 * Add contribution to mapping. This is not normally needed by clients unless the client needs to
-	 * build up a different container path mapping than the one normally created by {@link ProxyPlugin#processContributionExtensionPoint(String)}.
-	 * <p>
-	 * After all contributions have been added {@link #finalizeMapping()} must be called. If this
-	 * is not called then {@link #getContributors(String, String[])} will fail with exceptions.
-
-	 * @param containerId
-	 * @param pattern
-	 * @param contribution
-	 * 
-	 * @since 1.2.0
-	 */
-	public void addContribution(String containerId, Pattern pattern, Object contribution) {
-		if (containerIdToContributions == Collections.EMPTY_MAP)
-			containerIdToContributions = new HashMap();	// This is first call to add something.
-		// We will build as list, but then change to array when done.
-		Object contributions = containerIdToContributions.get(containerId);
-		if (contributions == null) {
-			contributions = new ArrayList(1);
-			containerIdToContributions.put(containerId, contributions);
-		} else if (!(contributions instanceof List)) {
-			// It must be an array, so convert back to list so that we can add to it.
-			List oldContributions = Arrays.asList((Object[]) contribution);
-			contributions = new ArrayList(oldContributions.size());
-			((List) contributions).addAll(oldContributions);
-			containerIdToContributions.put(containerId, contributions);
-		}
-		((List) contributions).add(new ContainerContributionEntry(contribution, pattern));
-
-	}
-	
-	/**
-	 * Finalize the mapping. This is called when clients are done with all {@link #addContribution(String)}.
-	 * It takes the mapping from an internal format that allowed for quicker building into the final format.
-	 * 
-	 * 
-	 * @since 1.2.0
-	 */
-	public void finalizeMapping() {
-		for (Iterator iter = containerIdToContributions.entrySet().iterator(); iter.hasNext();) {
-			Map.Entry entry = (Map.Entry) iter.next();
-			if (entry.getValue() instanceof List)
-				entry.setValue(((List) entry.getValue()).toArray(new ContainerContributionEntry[((List) entry.getValue()).size()]));
-		}
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ContributorExtensionPointInfo.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ContributorExtensionPointInfo.java
deleted file mode 100644
index 2c40467..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ContributorExtensionPointInfo.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.eclipse.jem.internal.proxy.core;
-
-import java.util.Map;
-
-
-/**
- * Result from {@link ProxyPlugin#processContributionExtensionPoint(String)}
- * 
- * @since 1.0.0
- */
-public class ContributorExtensionPointInfo {
-	
-	/**
-	 * Contributions that are based upon container paths that are built up from
-	 * the extension point.
-	 * 
-	 * @since 1.2.0
-	 */
-	public ContainerPathContributionMapping containerPathContributions;
-
-	ContributorExtensionPointInfo() {
-		// Not meant to be instantiated or subclassed outside of ProxyPlugin.
-	}
-	
-	/**
-	 * Map of plugin ids (String) to contributions (IConfigurationElement[]) that was found with that id. For each plugin,
-	 * the contributions will be listed in plugin prereq order.
-	 */
-	public Map pluginToContributions;
-
-	
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/EnumerationBeanProxyWrapper.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/EnumerationBeanProxyWrapper.java
deleted file mode 100644
index 169da10..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/EnumerationBeanProxyWrapper.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: EnumerationBeanProxyWrapper.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-/**
- * This is a wrapper for an java.util.Enumeration proxy.
- * It provides the Enumeration methods to interface to
- * the proxy.
- */
-
-public class EnumerationBeanProxyWrapper {
-	protected final IBeanProxy fEnumeration;
-	protected final JavaStandardBeanProxyConstants fConstants;
-	
-	/**
-	 * Construct with the collection.
-	 */
-	public EnumerationBeanProxyWrapper(IBeanProxy anEnumerationProxy) {
-		
-		fEnumeration = anEnumerationProxy;
-			
-		fConstants = JavaStandardBeanProxyConstants.getConstants(anEnumerationProxy.getProxyFactoryRegistry());
-	}
-	
-	/**
-	 * Answer the iterator proxy that this is wrappering.
-	 */
-	public IBeanProxy getBeanProxy() {
-		return fEnumeration;
-	}
-
-	/**
-	 * equals - Pass it on to the proxy to handle this.
-	 */
-	public boolean equals(Object object) {
-		return fEnumeration.equals(object);
-	}
-	
-	/**
-	 * hashCode - Pass it on to the proxy to handle this.
-	 */
-	public int hashCode() {
-		return fEnumeration.hashCode();
-	}
-	
-	/**
-	 * Enumeration accessors
-	 */
-	public boolean hasMoreElements() {
-		try {
-			return ((IBooleanBeanProxy) fConstants.getEnumerationHasMoreElements().invoke(fEnumeration)).booleanValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return false;
-		}			
-	}
-	public IBeanProxy nextElement() throws ThrowableProxy {
-		return fConstants.getEnumerationNextElement().invoke(fEnumeration);
-	}	
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/Expression.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/Expression.java
deleted file mode 100644
index 600efaf..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/Expression.java
+++ /dev/null
@@ -1,2546 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: Expression.java,v $
- *  $Revision: 1.14 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.text.MessageFormat;
-import java.util.*;
-
-import org.eclipse.jem.internal.proxy.initParser.tree.*;
- 
-/**
- * This is implementation of IExpression. It encapsulates much of the processing required
- * into a common form that will be turned into simple push/pop/evaluate type of interaction with the
- * actual other side. All registry specific implementations of IExpression must subclass this class.
- * <p>
- * It will maintain a stack of the expressions. As the expressions come in they will be stacked if not
- * able to be executed immediately. The expressions come to this class in an  outside to inside order,
- * but they need to be processed in an inside-out order instead. 
- * <p>
- * Subclasses will be used for the different types of proxy interfaces. The abstract methods will
- * then be the simple interface. 
- * <p>
- * It is not meant for subclasses to override the actual create expression methods because the processing the stack
- * is very sensitive and must execute in the proper sequence. So the create methods are final for this reason.
- * <p>
- * This class is not thread-safe.
- * <p>
- * This class also has API of its own and can be used by customers for advanced usage. Those advanced API are
- * listed on each method as to whether it is customer API or implementers API (i.e. API for implementers of
- * expression subclasses to use). 
- * 
- * 
- * @since 1.0.0
- */
-public abstract class Expression implements IExpression {
-
-	/*
-	 * We have stack here, but rather than create a class that does the
-	 * stack protocol, will simply have some private methods to do
-	 * the same thing for the stack. (Note: Can't use java.util.Stack
-	 * because that is a synchronized class, and don't want the overhead). 
-	 * 
-	 * The purpose of the stack is to stack up expressions that have not yet
-	 * been evaluated. 
-	 * 
-	 * Each expression type will control the content of what it pushes and pops.
-	 * The expression type will be the last thing it pushes so that on popping
-	 * we know what kind of expression is now completed and ready for evaluation.
-	 */
-	private ArrayList controlStack = new ArrayList(30);
-	
-	protected final ProxyFactoryRegistry registry;
-	protected final IStandardBeanProxyFactory beanProxyFactory;
-	protected Boolean traceFlag;
-	
-	/**
-	 * Answer whether trace has been explicitly set.
-	 * This is not in the IExpression interface because it is for advanced users.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isTraceSet() {
-		return traceFlag != null; 
-	}
-	
-	/**
-	 * Answer if trace is on. If not explicitly set this will answer false.
-	 * Use {@link Expression#isTraceSet()} first to determine if this
-	 * should be called or not.
-	 * This is not in the IExpression interface because it is for advanced users.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isTrace() {
-		return traceFlag != null ? traceFlag.booleanValue() : false;
-	}
-	
-	/**
-	 * Explicitly set the trace flag. This will only be honoured before any
-	 * expressions have been created. After that this will be ignored.
-	 * The trace is initially set to use default. Once set it cannot be unset.
-	 * This is not in the IExpression interface because it is for advanced users.
-	 * @param trace
-	 * 
-	 * @since 1.1.0
-	 */
-	public void setTrace(boolean trace) {
-		traceFlag = Boolean.valueOf(trace);
-	}
-	
-	/**
-	 * Push an object onto the control stack.
-	 * 
-	 * @param o
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final void push(Object o) {
-		controlStack.add(o);
-	}
-	
-	/**
-	 * Pop an object off of the control stack
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final Object pop() {
-		return controlStack.remove(controlStack.size()-1);
-	}
-	
-	/**
-	 * Peek at an object from the control stack. <code>fromTop</code> is how far from the top of the stack to look.
-	 * If it one, then it is the top entry, two is the next one down. Zero is an invalid value for the parameter.
-	 * @param fromTop How far from the top to peek. <code>1</code> is the top, not zero.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final Object peek(int fromTop) {
-		// 1 means the top, 2 is the next one down.
-		return controlStack.get(controlStack.size()-fromTop);
-	}
-	
-	/*
-	 * Expression type constants.
-	 */
-	
-	/*
-	 * ARRAY ACCESS expression.
-	 * The expression stack will have:
-	 * 	IExpression.ARRAYACCESS_ARRAY
-	 * 	IExpression.ARRAYACCESS_INDEX (for 1 to n times depending on index count)
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have
-	 * 	ARRAYACCESS
-	 * 	Integer(index count) 
-	 */
-	private static final Integer ARRAYACCESS_INDEX_1 = new Integer(1);	// Use in normal case of one index count. Saves object creation.
-	
-	/*
-	 * ARRAY CREATION expression.
-	 * The expression stack will have:
-	 * 	ARRAYCREATION_INITIALIZER - if hasInitializer
-	 *  IExpression.ARRAYCREATION_DIMENSION (for 0 to n times depending on dimension count)
-	 *  PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have
-	 *  ARRAYCREATION
-	 *  type (either a string representing the type, or an IBeanProxyType representing the type).
-	 *  Integer(dimension count) (if zero then there is an initializer) 
-	 * 
-	 * 
-	 * Note: Array Initializer works with this in that it will peek into the value stack two entries down
-	 * to find the type of array it should be creating.
-	 */
-	private static final Integer ARRAY_CREATION_DIMENSION_1 = new Integer(1);	// Use in normal case of one dimension. Save object creation.
-	private static final Integer ARRAY_CREATION_DIMENSION_0 = new Integer(0);	// Use in normal case of initializer. Save object creation.
-	private static final ForExpression ARRAY_INITIALIZER = new ExpressionEnum(Integer.MIN_VALUE+1, "Array Initializer Internal"); //$NON-NLS-1$
-	
-	/*
-	 * ARRAY INITIALIZER expression
-	 * The expression stack will have:
-	 * 	IExpression.ARRAYINITIALIZER_EXPRESSION (for n times depending on number of expressions count)
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have
-	 * 	ARRAYINITIALIZER
-	 *  type (either a string representing the type, or an IBeanProxyType representing the type).
-	 * 		I.e. if array being created is int[][], the value pushed here will be int[]. This is because when created
-	 * 		the array will wind up with int[expressioncount][] in the end.
-	 * 	Integer (expression count)
-	 * 
-	 * Note: Imbedded Array Initializers works with this in that it will peek into the value stack two entries down
-	 * to find the type of array it should be creating.
-	 */
-	private static final Integer ARRAYINITIALIZER_COUNT_0 = new Integer(0);	// Use in normal case of empty array. Save object creation.
-	private static final Integer ARRAYINITIALIZER_COUNT_1 = new Integer(1);	// Use in normal case of one element array. Save object creation.
-	private static final Integer ARRAYINITIALIZER_COUNT_2 = new Integer(2);	// Use in normal case of two element array. Save object creation.	
-	
-	/*
-	 * CAST expression.
-	 * The expression stack will have:
-	 * 	IExpression.CAST_EXPRESSION
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	CAST
-	 * 	type (either a string representing the type, or an IBeanProxyType representing the type).
-	 */
-
-	/*
-	 * CLASS INSTANCE CREATION expression.
-	 * The expression stack will have:
-	 *  IExpression.CLASSINSTANCECREATION_ARGUMENT (for 0 to n times depending on argument count)
-	 *  PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have
-	 *  CLASSINSTANCECREATION
-	 *  type (either a string representing the type, or an IBeanProxyType representing the type).
-	 *  Integer(argument count) 
-	 * 
-	 * 
-	 * Note: Array Initializer works with this in that it will peek into the value stack two entries down
-	 * to find the type of array it should be creating.
-	 */
-	private static final Integer CLASS_INSTANCE_CREATION_ARGUMENTS_1 = new Integer(1);	// Use in normal case of one argument. Save object creation.
-	private static final Integer CLASS_INSTANCE_CREATION_ARGUMENTS_0 = new Integer(0);	// Use in normal case of no arguments (default ctor). Save object creation.
-
-	/*
-	 * CONDITIONAL expression.
-	 * Since this can cause skipping of expressions (e.g. if condition is false, then the true condition should not be evaluated),
-	 * we need to have a process expression and process call to the other side for each expression so that it can
-	 * determine if it should be ignored or not.
-	 * 
-	 * The expression stack will have:
-	 * 	IExpression.CONDITIONAL_CONDITION
-	 * 	PROCESS_EXPRESSION
-	 * 	IExpression.CONDITIONAL_TRUE
-	 * 	PROCESS_EXPRESSION
-	 * 	IExpression.CONDITIONAL_FALSE
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	CONDITIONAL
-	 * 	CONDITIONAL_CONDITION
-	 * 	CONDITIONAL
-	 * 	CONDITIONAL_TRUE
-	 * 	CONDITIONAL
-	 * 	CONDITIONAL_FALSE
-	 * 
-	 */
-	
-	/*
-	 * PREFIX expression.
-	 * The expression stack will have:
-	 * 	IExpression.PREFIX_OPERAND
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	PREFIX
-	 * 	operator (using Integer prefix operator constants defined here) 
-	 */
-	
-	/*
-	 * INFIX expression.
-	 * Since two types of infix operators (conditional and AND or) can cause skipping of expressions (e.g. once
-	 * conditional and sees a false expression, the rest of the expressions are skipped and should not be evaluated),
-	 * we need to have a process expression and process call to the other side for each expression so that it can
-	 * determine if it should be ignored or not.
-	 * 
-	 * The expression stack will have:
-	 * 	IExpression.INFIX_LEFT
-	 * 	PROCESS_EXPRESSION
-	 * 	IExpression.INFIX_RIGHT
-	 *  PROCESS_EXPRESSION
-	 * 		(for 0 to n times depending upon extended count)
-	 * 		IExpression.INFIX_EXTENDED 
-	 * 		PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	INFIX
-	 * 	operator (using Integer infix operator constants defined here)
-	 *  IN_LEFT
-	 * 		(for (extendedCount) times) This will cover the right one and all but last extended
-	 * 		INFIX
-	 * 		operator (using Integer infix operator constants defined here)
-	 *  	IN_OTHER
-	 * INFIX
-	 * 	operator (using Integer infix operator constants defined here)
-	 *  IN_LAST (this is covers either the right one if no extended, or the last extended)
-	 */
-	
-	/*
-	 * INSTANCEOF expression.
-	 * The expression stack will have:
-	 * 	IExpression.INSTANCEOF_EXPRESSION
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	INSTANCEOF
-	 * 	type (either a string representing the type, or an IBeanProxyType representing the type).
-	 */
-
-	/*
-	 * Field access expression.
-	 * The expression stack will have:
-	 * 	IExpression.FIELD_RECEIVER (if hasReceiver is true)
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	FIELDACCESS
-	 * 	name (the name of the field)
-	 *  Boolean (true if has receiver)
-	 */
-
-	/*
-	 * Method invocation expression.
-	 * The expression stack will have:
-	 * 	IExpression.METHOD_RECEIVER (if hasReceiver is true)
-	 * 	IExpression.METHOD_ARGUMENT (0 to n times for how many arguments).
-	 * 	PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 * 	METHODINVOCATION
-	 * 	name (the name of the method)
-	 *  Boolean (true if has receiver)
-	 *  argCount (the number of arguments).
-	 */
-	private static final Integer METHOD_ARGUMENTS_1 = new Integer(1);	// Use in normal case of one argument. Save object creation.
-	private static final Integer METHOD_ARGUMENTS_0 = new Integer(0);	// Use in normal case of no arguments. Save object creation.
-	
-
-	/*
-	 * Assignment expression
-	 * The expression stack will have:
-	 *  IExpression.ASSIGNMENT_RIGHT
-	 *  IExpression.ASSIGNMENT_LEFT
-	 *  PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 *  ASSIGNMENT
-	 *  left expression (variable reference)
-	 *  right expression
-	 */
-
-	/*
-	 * Assignment proxy expression
-	 * The expression stack will have:
-	 *  IExpression.ASSIGNMENT_RIGHT
-	 *  PROCESS_EXPRESSION
-	 * 
-	 * The value stack will have:
-	 *  ASSIGNMENT_PROXY
-	 *  expression proxy (an expression proxy)
-	 */
-	
-	/*
-	 * Next valid for expression stack. This is kept as a stack also.
-	 * As the expressions come in, the appropriate order (in reverse)
-	 * of expression types will be pushed, and then popped as they 
-	 * come in.
-	 * 
-	 * Since we can't have an array list of ints, will simulate the
-	 * stack here.
-	 */
-	private ForExpression[] nextForExpressionStack = new ForExpression[30];
-	private int nextForExpressionStackPos = -1;	// Position of top entry in stack.
-	private boolean expressionValid = true;	// Is the expression currently valid.
-	private String invalidMsg = null;	// Msg for being invalid if default msg not sufficient.
-	private List expressionProxies;	// List of expression proxies. The index of the proxy is its id. This list must never shrink in size.
-
-	// A MarkEntry. To allow restore in case of error.
-	private static class MarkEntry {
-		public int markID;
-		public int controlStackPos;	// Position of control stack at time of mark.
-		public int nextExpressionStackPos;	// Position of nextForExpression stack at time of mark.
-		public int expressionProxiesPos;	// Position of expressionProxies list at time of mark.
-	}
-	
-	private int highestMarkID = 0;	// Next mark id. '0' is invalid, as in no marks. This is incremented for each new mark. Never decremented.
-	private MarkEntry currentMarkEntry;	// Just a convienence to the current mark entry so no need to look into the list every time.
-	private List markEntries;	// Stack of mark entries.
-	
-	// This class is here so we can add our special internal ForExpression: PROCESS_EXPRESSION. These are never used outside Expression.
-	private static class ExpressionEnum extends ForExpression {
-
-		public ExpressionEnum(int value, String name) {
-			super(value, name);
-		}
-		
-	}
-	
-	// This is pushed onto the next expression stack, and when it is popped, then the expression is complete and ready to be pushed to the proxy side.
-	private static final ForExpression PROCESS_EXPRESSION = new ExpressionEnum(Integer.MIN_VALUE, "Process Expression"); //$NON-NLS-1$
-	
-	// This is pushed onto the next expression stack for end block and will test if this there to make sure that it is being called correctly.
-	private static final ForExpression BLOCKEND_EXPRESSION = new ExpressionEnum(PROCESS_EXPRESSION.getValue()-2, "End Block Expression"); //$NON-NLS-1$
-
-	// This is pushed onto the next expression stack for end try and will test if this there to make sure that it is being called correctly.
-	private static final ForExpression TRYEND_EXPRESSION = new ExpressionEnum(BLOCKEND_EXPRESSION.getValue()-1, "End Try Expression"); //$NON-NLS-1$
-
-	// This is pushed onto the next expression stack for catch and will test if this there to make sure that it is being called correctly.
-	private static final ForExpression TRYCATCH_EXPRESSION = new ExpressionEnum(TRYEND_EXPRESSION.getValue()-1, "Catch Expression"); //$NON-NLS-1$
-	
-
-	// This is pushed onto the next expression stack for begin thread transfer and will test if this there to make sure that it is being called correctly.
-	private static final ForExpression THREADTRANSFER_EXPRESSION = new ExpressionEnum(TRYCATCH_EXPRESSION.getValue()-1, "Catch Expression"); //$NON-NLS-1$
-
-	// This is pushed onto the next expression stack for end subexpression and will test if this there to make sure that it is being called correctly.
-	private static final ForExpression SUBEXPRESSIONEND_EXPRESSION = new ExpressionEnum(THREADTRANSFER_EXPRESSION.getValue()-2, "End Subexpression"); //$NON-NLS-1$
-
-	/**
-	 * Check the for expression, and if legal, set to the next valid for expression type,
-	 * if it can. If the stack entry is ROOTEXPRESSION, and the forExpression is ROOTEXPRESSION,
-	 * then the expression is allowed, but it is not popped. It must be popped later when appropriate.
-	 * <p>
-	 * This is for "block" expressions. We don't want to pop down the stack passed the ROOTEXPRESSION
-	 * that got added by the create block until we get an end block. That allows root expressions to
-	 * be added to the block without the stack popping up past the block start in the stack.
-	 * 
-	 * @param forExpression
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final void checkForExpression(ForExpression forExpression) throws IllegalStateException {
-		if (expressionValid) {
-			if (nextForExpressionStackPos == -1)
-				if (forExpression == ForExpression.ROOTEXPRESSION)
-					return;	// valid. We are at the root (i.e. nothing is waiting).
-				else
-					;	// invalid. drop through
-			else if (nextForExpressionStack[nextForExpressionStackPos] == forExpression) {
-				// Valid, either the root expression matched (We don't implicitly pop those. That needs to be done explicitly). 
-				// Or we matched non-root, those will be popped.
-				if (forExpression != ForExpression.ROOTEXPRESSION) {
-					popForExpression();	// Pop the stack since stack not a root expression.
-				}
-				return;	
-			}
-		} else {
-			String expMsg = invalidMsg != null ? MessageFormat.format(ProxyMessages.Expression_InInvalidStateDueTo_EXC_, new Object[] {invalidMsg}) : ProxyMessages.Expression_InInvalidState_EXC_; 
-			throw new IllegalStateException(expMsg);
-		}
-		
-		// If we got here, then invalid.
-		ForExpression expected = nextForExpressionStack[nextForExpressionStackPos];
-		expressionValid = false;
-		throw new IllegalStateException(MessageFormat.format(ProxyMessages.Expression_TypeSentInInvalidOrder_EXC_, new Object[] {forExpression, expected})); 
-	}
-	
-	/**
-	 * Pop the top for expression, whatever it is.
-	 * @throws IllegalStateException thrown if try to pop through through the current mark entry. The endMark is the only one who can do this.
-	 * @since 1.1.0
-	 */
-	protected final void popForExpression() throws IllegalStateException {
-		if (expressionValid && nextForExpressionStackPos >= 0) {
-			nextForExpressionStackPos--;
-			if (currentMarkEntry != null && nextForExpressionStackPos < currentMarkEntry.nextExpressionStackPos) {
-				nextForExpressionStackPos++;	// Restore to what it was
-				throwInvalidMarkNesting();
-			}
-		}
-	}
-
-	/*
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	private void throwInvalidMarkNesting() throws IllegalStateException {
-		expressionValid = false;
-		throw new IllegalStateException(MessageFormat.format(ProxyMessages.Expression_InvalidMarkNesting, new Object[] {new Integer(currentMarkEntry != null ? currentMarkEntry.markID : 0)})); 
-	}
-	
-	/**
-	 * Peek into the for expression stack to see if the top entry is the passed in value. It will
-	 * not pop the stack nor throw any exceptions.
-	 * 
-	 * @param forExpression The top expression flag will be compared against this value.
-	 * @return <code>true</code> if the top expression equals the parameter passed in.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final boolean peekForExpression(ForExpression forExpression) {
-		if (expressionValid) {
-			if (nextForExpressionStackPos == -1)
-				if (forExpression == ForExpression.ROOTEXPRESSION)
-					return true;	// valid. We are at the root (i.e. nothing is waiting).
-				else
-					;	// invalid. drop through
-			else if (nextForExpressionStack[nextForExpressionStackPos] == forExpression)
-				return true;	// Valid, the top expression matched.
-		} 
-		return false;
-	}	
-	
-	/**
-	 * Mark this expression as now invalid.
-	 */
-	protected final void markInvalid() {
-		expressionValid = false;
-	}
-	
-	/**
-	 * Mark this expression as now invalid, but supply a message to go with it.
-	 * 
-	 * @param msg
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final void markInvalid(String msg) {
-		invalidMsg = msg;
-		markInvalid();
-	}
-	
-	public void close() {
-		nextForExpressionStackPos = -1;
-		controlStack.clear();
-		if (expressionProxies != null)
-			markAllProxiesNotResolved(expressionProxies);	// They weren't processed, close must of been called early.
-		expressionProxies = null;
-		markEntries = null;
-		expressionValid = false;
-		closeProxy();
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#isValid()
-	 */
-	public boolean isValid() {
-		return expressionValid;
-	}
-	
-	/*
-	 * Check if the pending expression is ready for evaluation.
-	 * It is complete if the next entry on the stack is a PROCESS_EXPRESSION
-	 */
-	private boolean expressionReady() {
-		if (nextForExpressionStackPos >= 0 && nextForExpressionStack[nextForExpressionStackPos] == PROCESS_EXPRESSION) {
-			checkForExpression(PROCESS_EXPRESSION);	// pop it
-			return true;
-		} else
-			return false;
-	}
-	
-	/*
-	 * Push the next expression type.
-	 */
-	private void pushForExpression(ForExpression nextExpression) {
-		if (++nextForExpressionStackPos >= nextForExpressionStack.length) {
-			// Increase stack size.
-			ForExpression[] newStack = new ForExpression[nextForExpressionStackPos*2];	// So room to grow without excessive allocations.
-			System.arraycopy(nextForExpressionStack, 0, newStack, 0, nextForExpressionStack.length);
-			nextForExpressionStack = newStack;
-		}
-		nextForExpressionStack[nextForExpressionStackPos] = nextExpression;
-	}
-	
-	/*
-	 * Check if expression is complete, and if it is, process it.
-	 */
-	private void processExpression() {
-		while (expressionReady()) {
-			try {
-				// We've received all of the expressions for the expression, so process it.
-				int expType = ((InternalExpressionTypes) pop()).getValue();
-				switch (expType) {
-					case InternalExpressionTypes.CAST_EXPRESSION_VALUE:
-						pushCastToProxy((IProxyBeanType) pop());
-						break;
-					case InternalExpressionTypes.INSTANCEOF_EXPRESSION_VALUE:
-						pushInstanceofToProxy((IProxyBeanType) pop());
-						break;
-					case InternalExpressionTypes.PREFIX_EXPRESSION_VALUE:
-						pushPrefixToProxy((PrefixOperator)pop());
-						break;
-					case InternalExpressionTypes.INFIX_EXPRESSION_VALUE:
-						pushInfixToProxy((InfixOperator) pop(), (InternalInfixOperandType) pop());
-						break;
-					case InternalExpressionTypes.ARRAY_ACCESS_EXPRESSION_VALUE:
-						pushArrayAccessToProxy(((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.ARRAY_CREATION_EXPRESSION_VALUE:
-						pushArrayCreationToProxy((IProxyBeanType) pop(), ((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.ARRAY_INITIALIZER_EXPRESSION_VALUE:
-						pushArrayInitializerToProxy((IProxyBeanType) pop(), ((Integer) pop()).intValue(), ((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.CLASS_INSTANCE_CREATION_EXPRESSION_VALUE:
-						pushClassInstanceCreationToProxy((IProxyBeanType) pop(), ((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.FIELD_ACCESS_EXPRESSION_VALUE:
-						pushFieldAccessToProxy(pop(), ((Boolean) pop()).booleanValue());
-						break;
-					case InternalExpressionTypes.METHOD_EXPRESSION_VALUE:
-						pushMethodInvocationToProxy(pop(), ((Boolean) pop()).booleanValue(), ((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.CONDITIONAL_EXPRESSION_VALUE:
-						pushConditionalToProxy((InternalConditionalOperandType) pop());
-						break;
-					case InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION_VALUE:
-						pushAssignmentToProxy((ExpressionProxy) pop());
-						break;
-					case InternalExpressionTypes.ASSIGNMENT_EXPRESSION_VALUE:
-						pushAssignmentToProxy();
-						break;
-					case InternalExpressionTypes.BLOCK_END_EXPRESSION_VALUE:
-						pushBlockEndToProxy(((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.TRY_END_EXPRESSION_VALUE:
-						pushTryEndToProxy(((Integer) pop()).intValue());
-						break;
-					case InternalExpressionTypes.THROW_EXPRESSION_VALUE:
-						pushThrowToProxy();
-						break;
-					case InternalExpressionTypes.IF_TEST_EXPRESSION_VALUE:
-						pushIfTestToProxy();
-						break;												
-					case InternalExpressionTypes.IF_ELSE_EXPRESSION_VALUE:
-						pushIfElseToProxy((InternalIfElseOperandType) pop());
-						break;	
-					case InternalExpressionTypes.SUBEXPRESSION_END_EXPRESSION_VALUE:
-						pushSubexpressionEndToProxy(((Integer) pop()).intValue());
-						break;						
-					default:
-						internalProcessUnknownExpressionType(expType);
-						break;
-				}
-			} catch (RuntimeException e) {
-				markInvalid();
-				throw e;
-			}
-		}
-	}
-	
-
-	private void internalProcessUnknownExpressionType(int expressionType) throws IllegalArgumentException {
-		if (!processUnknownExpressionType(expressionType))
-			throw new IllegalArgumentException();
-	}
-
-	/**
-	 * An unknown expression type was found in the processing of expression stack. Subclasses can override
-	 * to process new types of expressions. 
-	 * <p>
-	 * Overrides must return <code>true</code> if they processed the expression type. If they return <code>false</code>
-	 * it means they didn't understand it either and we should do default processing for unknow type.
-	 * @param expressionType
-	 * @return <code>true</code> if type was processed, <code>false</code> if not known by subclass either.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected boolean processUnknownExpressionType(int expressionType) {
-		return false;
-	}
-
-	/**
-	 * Create the expression.
-	 * 
-	 * @param registry
-	 * 
-	 * @since 1.0.0
-	 */
-	protected Expression(ProxyFactoryRegistry registry) {
-		this.registry = registry;
-		this.beanProxyFactory = this.registry.getBeanProxyFactory();
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#getRegistry()
-	 */
-	public ProxyFactoryRegistry getRegistry() {
-		return registry;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#invokeExpression()
-	 */
-	public final void invokeExpression() throws ThrowableProxy, IllegalStateException, NoExpressionValueException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION); // We are at the root.
-			popForExpression();	// Get rid of any intermediate roots.
-			checkForExpression(ForExpression.ROOTEXPRESSION);	// We should be at true root now. We don't have more than one intermediate root pushed in sequence.
-			List proxies = expressionProxies;
-			expressionProxies = null;
-			pushInvoke(processExpressionProxyCallbacks(proxies), proxies);
-		} finally {
-			markInvalid(); // Mark invalid so any new calls after this will fail.
-			close();
-		}
-	}
-		
-	/*
-	 * Process the expression proxy callbacks, if any.
-	 * @return the number of proxies that have callbacks.
-	 */
-	private int processExpressionProxyCallbacks(List proxies) {
-		if (proxies != null) {
-			// Strip list down to only those with callbacks and send on.
-			int proxiesWithCallbacks = 0;
-			for (ListIterator eps = proxies.listIterator(); eps.hasNext();) {
-				ExpressionProxy proxy = (ExpressionProxy) eps.next();
-				if (!proxy.hasListeners())
-					eps.set(null);	// Remove it from the list. No one cares.
-				else
-					proxiesWithCallbacks++;
-			}
-			return proxiesWithCallbacks;
-		}
-		return 0;
-	}
-	
-	/**
-	 * Called to validate this is a valid proxy for this expression. This could happen
-	 * if a proxy from another expression is sent to this expression. If the proxy
-	 * is a bean proxy or is an expression proxy for this expression, then this
-	 * just returns. Else it will throw the {@link IllegalArgumentException}. 
-	 * @param proxy
-	 * @throws IllegalArgumentException if the proxy is an expression proxy for another expression.
-	 * 
-	 * @since 1.1.0.1
-	 */
-	private void validateProxy(IProxy proxy) throws IllegalArgumentException {
-		if (proxy != null && (proxy.isExpressionProxy() && ((ExpressionProxy) proxy).getExpression() != this))
-			throw new IllegalArgumentException(ProxyMessages.Expression_InvalidProxy);
-	}
-		
-	/**
-	 * Called by subclass to fill in the value of an expression proxy. See {@link Expression#pullProxyValue(int, List))} for an example of who would call it.
-	 * @param ep
-	 * @param beanproxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fireProxyResolved(ExpressionProxy ep, IBeanProxy beanproxy) {
-		ep.fireResolved(beanproxy);
-	}
-	
-	/**
-	 * Called by subclass to fire proxy was not resolved. See {@link Expression#pullProxyValue(int, List))} for an example of who would call it.
-	 * @param ep
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fireProxyNotResolved(ExpressionProxy ep) {
-		ep.fireNotResolved();
-	}
-	
-	/**
-	 * Called by subclass to fire proxy resolved to a void return type. See {@link Expression#pullProxyValue(int, List))} for an example of who would call it.
-	 * @param ep
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fireProxyVoid(ExpressionProxy ep) {
-		ep.fireVoidResolved();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#getExpressionValue()
-	 */
-	public final IBeanProxy getExpressionValue() throws ThrowableProxy, NoExpressionValueException, IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION); // We are at the root.
-			popForExpression();	// Get rid of any intermediate roots.
-			checkForExpression(ForExpression.ROOTEXPRESSION);	// We should be at true root now. We don't have more than one intermediate root pushed in sequence.
-			List proxies = expressionProxies;
-			expressionProxies = null;
-			return pullProxyValue(processExpressionProxyCallbacks(proxies), proxies); // Get the top value.
-		} finally {
-			markInvalid();	// Mark invalid so any new calls after this will fail. 
-			close();
-		}
-	}
-
-	
-	/**
-	 * Mark the list of proxies as not resolved. 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void markAllProxiesNotResolved(List proxies) {
-		if (proxies != null) {
-			for (ListIterator eps = proxies.listIterator(); eps.hasNext();) {
-				ExpressionProxy proxy = (ExpressionProxy) eps.next();
-				if (proxy != null && proxy.hasListeners())
-					fireProxyNotResolved(proxy);
-			}
-		}
-	}
-
-	private int blockNumber = -1;	// Current block number. This is always incrementing.
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createBlockBegin()
-	 */
-	public final int createBlockBegin() throws IllegalStateException {
-		try {
-			// Blocks are special, they can be anywhere at root, of could be the true or else clause of an if/else.
-			if (peekForExpression(ForExpression.ROOTEXPRESSION))
-				checkForExpression(ForExpression.ROOTEXPRESSION);
-			else if (peekForExpression(ForExpression.IF_TRUE))
-				checkForExpression(ForExpression.IF_TRUE);
-			else
-				checkForExpression(ForExpression.IF_ELSE);
-			
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(BLOCKEND_EXPRESSION);
-			pushForExpression(ForExpression.ROOTEXPRESSION);
-
-			pushBlockBeginToProxy(++blockNumber);
-			push(new Integer(blockNumber));
-			push(InternalExpressionTypes.BLOCK_END_EXPRESSION);
-			processExpression();
-			return blockNumber;
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createBlockBreak(int)
-	 */
-	public final void createBlockBreak(int blockNumber) throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			pushBlockBreakToProxy(blockNumber);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createBlockEnd()
-	 */
-	public final void createBlockEnd() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			popForExpression(); // Remove the root expression since block is done.
-			checkForExpression(BLOCKEND_EXPRESSION); // This needs to be next for it to be valid.
-			processExpression(); // Now let it handle the previously pushed end block, containing the block number being ended.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createArrayAccess(int, int)
-	 */
-	public final void createArrayAccess(ForExpression forExpression, int indexCount) {
-		try {
-			checkForExpression(forExpression);
-			pushForExpression(PROCESS_EXPRESSION);
-			int i = indexCount;
-			while (i-- > 0)
-				pushForExpression(ForExpression.ARRAYACCESS_INDEX);
-			pushForExpression(ForExpression.ARRAYACCESS_ARRAY);
-
-			push(indexCount == 1 ? ARRAYACCESS_INDEX_1 : new Integer(indexCount));
-			push(InternalExpressionTypes.ARRAY_ACCESS_EXPRESSION);
-			processExpression(); // See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}		
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createArrayCreation(int, java.lang.String, int)
-	 */
-	public final void createArrayCreation(ForExpression forExpression, String type, int dimensionExpressionCount)
-		throws IllegalStateException {
-		pushArrayCreation(forExpression, getProxyBeanType(type), dimensionExpressionCount);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createArrayCreation(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.IProxyBeanType, int)
-	 */
-	public final void createArrayCreation(ForExpression forExpression, IProxyBeanType type, int dimensionExpressionCount)
-		throws IllegalStateException, IllegalArgumentException {
-		pushArrayCreation(forExpression, type, dimensionExpressionCount);
-	}
-
-	private void pushArrayCreation(ForExpression forExpression, IProxyBeanType type, int dimensionExpressionCount) throws IllegalStateException, IllegalArgumentException {
-		try {
-			checkForExpression(forExpression);
-			validateProxy(type);
-			switch (dimensionExpressionCount) {
-				case 0:
-					push(ARRAY_CREATION_DIMENSION_0);
-					break;
-				case 1:
-					push(ARRAY_CREATION_DIMENSION_1);
-					break;
-				default:
-					push(new Integer(dimensionExpressionCount));
-					break;
-			}
-			push(type);
-			push(InternalExpressionTypes.ARRAY_CREATION_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			if (dimensionExpressionCount == 0)
-				pushForExpression(ARRAY_INITIALIZER);
-			else {
-				while (dimensionExpressionCount-- > 0)
-					pushForExpression(ForExpression.ARRAYCREATION_DIMENSION);
-			}
-			processExpression(); // See if previous expression is ready for processing.		
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createArrayInitializer(int)
-	 */
-	public final void createArrayInitializer(int expressionCount) throws IllegalStateException {
-		try {
-			// This is special, we could be waiting for an array initializer or an array initializer expression.
-			// We will peek to see what it is and handle it.
-			if (peekForExpression(ARRAY_INITIALIZER))
-				checkForExpression(ARRAY_INITIALIZER);
-			else
-				checkForExpression(ForExpression.ARRAYINITIALIZER_EXPRESSION);
-
-			// At this point in time that stack may either have:
-			// array_type, array_creation
-			// strip_count, array_type, array_initializer
-			// So we can get the array type from peek(2), and get the command type from peek(1).
-			// Then if the command type is array_creation, strip_count will be inited to 0, while
-			// else it will be inited to peek(3). From that we can increment the strip_count to
-			// use for this initializer.
-			//
-			// We need to peek here because we will be adding various pushes to the stack and we
-			// need to get the info while it is still at the top of the stack.
-			Object arrayType = peek(2); 
-			int stripCount = 0;
-			if (peek(1) == InternalExpressionTypes.ARRAY_INITIALIZER_EXPRESSION)
-				stripCount = ((Integer) peek(3)).intValue();
-
-			switch (expressionCount) {
-				case 0:
-					push(ARRAYINITIALIZER_COUNT_0);
-					break;
-				case 1:
-					push(ARRAYINITIALIZER_COUNT_1);
-					break;
-				case 2:
-					push(ARRAYINITIALIZER_COUNT_2);
-					break;
-				default:
-					push(new Integer(expressionCount));
-					break;
-			}
-
-			if (arrayType instanceof String) {
-				String at = (String) arrayType;
-				int i = at.lastIndexOf("[]"); //$NON-NLS-1$
-				if (i == -1)
-					throw new IllegalArgumentException(MessageFormat.format(
-							ProxyMessages.Expression_ArrayTypeNotAnArray_EXC_, new Object[] { arrayType})); 
-				arrayType = getProxyBeanType(at);
-			} else if (!(arrayType instanceof IProxyBeanType)) {
-				throw new IllegalArgumentException(MessageFormat.format(
-						ProxyMessages.Expression_ArrayTypeNotAnArray_EXC_, new Object[] { arrayType})); 
-			}
-			push(new Integer(++stripCount));
-			push(arrayType);
-			push(InternalExpressionTypes.ARRAY_INITIALIZER_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			while (expressionCount-- > 0)
-				pushForExpression(ForExpression.ARRAYINITIALIZER_EXPRESSION);
-
-			processExpression(); 
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
- 
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createCastExpression(int, java.lang.String)
-	 * A cast expression has one nested expression.
-	 */
-	public final void createCastExpression(ForExpression forExpression, String type) throws IllegalStateException {
-		pushCast(forExpression, getProxyBeanType(type)); // Push this onto the local stack to wait for completion.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createCastExpression(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	public final void createCastExpression(ForExpression forExpression, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException {
-		pushCast(forExpression, type); // Push this onto the local stack to wait for completion.
-	}
-	
-	/*
-	 * Push for a cast.
-	 */
-	private void pushCast(ForExpression forExpression, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException {
-		try {
-			checkForExpression(forExpression);
-			validateProxy(type);
-			push(type);
-			push(InternalExpressionTypes.CAST_EXPRESSION);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.CAST_EXPRESSION); // The next expression must be for the cast expression.
-			processExpression(); 
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}	
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createClassInstanceCreation(int, java.lang.String, int)
-	 */
-	public final void createClassInstanceCreation(ForExpression forExpression, String type, int argumentCount)
-		throws IllegalStateException {
-		pushClassInstanceCreation(forExpression, getProxyBeanType(type), argumentCount);	// Push this onto the local stack to wait for completion.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createClassInstanceCreation(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.IProxyBeanType, int)
-	 */
-	public final void createClassInstanceCreation(ForExpression forExpression, IProxyBeanType type, int argumentCount)
-		throws IllegalStateException, IllegalArgumentException {
-		pushClassInstanceCreation(forExpression, type, argumentCount);	// Push this onto the local stack to wait for completion.
-	}
-
-	/*
-	 * Push for a class instance creation
-	 */
-	private void pushClassInstanceCreation(ForExpression forExpression, IProxyBeanType type, int argumentCount) throws IllegalStateException, IllegalArgumentException {
-		try {
-			checkForExpression(forExpression);
-			validateProxy(type);
-			switch (argumentCount) {
-				case 0:
-					push(CLASS_INSTANCE_CREATION_ARGUMENTS_0);
-					break;
-				case 1:
-					push(CLASS_INSTANCE_CREATION_ARGUMENTS_1);
-					break;
-				default:
-					push(new Integer(argumentCount));
-					break;
-			}
-			push(type);
-			push(InternalExpressionTypes.CLASS_INSTANCE_CREATION_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			while (argumentCount-- > 0)
-				pushForExpression(ForExpression.CLASSINSTANCECREATION_ARGUMENT);
-			processExpression(); // See if previous expression is ready for processing.						
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createConditionalExpression(int)
-	 */
-	public final void createConditionalExpression(ForExpression forExpression) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.CONDITIONAL_FALSE);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.CONDITIONAL_TRUE);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.CONDITIONAL_CONDITION);
-
-			push(InternalConditionalOperandType.CONDITIONAL_FALSE);
-			push(InternalExpressionTypes.CONDITIONAL_EXPRESSION);
-			push(InternalConditionalOperandType.CONDITIONAL_TRUE);
-			push(InternalExpressionTypes.CONDITIONAL_EXPRESSION);
-			push(InternalConditionalOperandType.CONDITIONAL_TEST);
-			push(InternalExpressionTypes.CONDITIONAL_EXPRESSION);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createFieldAccess(int, java.lang.String, boolean)
-	 */
-	public final void createFieldAccess(ForExpression forExpression, String fieldName, boolean hasReceiver) throws IllegalStateException, IllegalArgumentException {
-		try {
-			// Only for string fieldnames is this invalid when no receiver because no way to determine receiver. (Don't handle implicit "this" yet for fields). 
-			// For the accessor that takes a IFieldProxy we can get away with no receiver because the field proxy can determine if static or not, and if not
-			// static it will fail at evaluation time.
-			if (!hasReceiver)
-				throw new IllegalArgumentException(MessageFormat.format(
-						ProxyMessages.Expression_CannotHandleNoReceiveOnFieldAccess_EXC_, new Object[] { fieldName})); 
-			pushFieldAccess(forExpression, fieldName, hasReceiver);
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createIfElse(boolean)
-	 */
-	public final void createIfElse(boolean hasElseClause) throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			
-			pushForExpression(PROCESS_EXPRESSION);
-			if (hasElseClause) {
-				pushForExpression(ForExpression.IF_ELSE);
-			}
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.IF_TRUE);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.IF_CONDITION);
-
-			// We still push an else clause so that we know when finished. We don't have a pushForExpression for it because there
-			// won't be any. But the else clause processing will be on the push stack so that we can clean up when end of if stmt occurs.
-			push(InternalIfElseOperandType.ELSE_CLAUSE);	
-			push(InternalExpressionTypes.IF_ELSE_EXPRESSION);
-			
-			push(InternalIfElseOperandType.TRUE_CLAUSE);
-			push(InternalExpressionTypes.IF_ELSE_EXPRESSION);
-			push(InternalExpressionTypes.IF_TEST_EXPRESSION);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/*
-	 * Push the field access.
-	 * @param forExpression
-	 * @param field String if field name, or IProxyField.
-	 * @param hasReceiver
-	 * @throws IllegalAccessException
-	 * 
-	 * @since 1.1.0
-	 */
-	private void pushFieldAccess(ForExpression forExpression, Object field, boolean hasReceiver) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			push(hasReceiver ? Boolean.TRUE : Boolean.FALSE); // We have a receiver
-			push(field);
-			push(InternalExpressionTypes.FIELD_ACCESS_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			if (hasReceiver)
-				pushForExpression(ForExpression.FIELD_RECEIVER);
-			processExpression(); // See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createInfixExpression(int, int, int)
-	 */
-	public final void createInfixExpression(ForExpression forExpression, InfixOperator operator, int extendedOperandCount) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			push(InternalInfixOperandType.INFIX_LAST_OPERAND);
-			push(operator);
-			push(InternalExpressionTypes.INFIX_EXPRESSION);
-			int i = extendedOperandCount;
-			while (i-- > 0) {
-				push(InternalInfixOperandType.INFIX_OTHER_OPERAND);
-				push(operator);
-				push(InternalExpressionTypes.INFIX_EXPRESSION);
-			}
-			push(InternalInfixOperandType.INFIX_LEFT_OPERAND);
-			push(operator);
-			push(InternalExpressionTypes.INFIX_EXPRESSION);
-
-			i = extendedOperandCount;
-			while (i-- > 0) {
-				pushForExpression(PROCESS_EXPRESSION);
-				pushForExpression(ForExpression.INFIX_EXTENDED);
-			}
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.INFIX_RIGHT);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.INFIX_LEFT);
-			processExpression(); // See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createInstanceofExpression(int, java.lang.String)
-	 */
-	public final void createInstanceofExpression(ForExpression forExpression, String type) throws IllegalStateException {
-		pushInstanceof(forExpression, getProxyBeanType(type));	// Push this onto the local stack to wait for completion.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createInstanceofExpression(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	public final void createInstanceofExpression(ForExpression forExpression, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException {
-		pushInstanceof(forExpression, type);	// Push this onto the local stack to wait for completion.
-	}
-	
-	/*
-	 * Push for a cast.
-	 */
-	private void pushInstanceof(ForExpression forExpression, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException {
-		try {
-			checkForExpression(forExpression);
-			validateProxy(type);
-			push(type);
-			push(InternalExpressionTypes.INSTANCEOF_EXPRESSION);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.INSTANCEOF_VALUE); // The next expression must be for the instance of expression.
-			processExpression(); 
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createMethodInvocation(int, java.lang.String, boolean, int)
-	 */
-	public final void createMethodInvocation(ForExpression forExpression, String name, boolean hasReceiver, int argumentCount)
-		throws IllegalStateException, IllegalArgumentException {
-		try {
-			// Only for string methodnames is this invalid when no receiver because no way to determine receiver. (Don't handle implicit "this" yet for methods). 
-			// For the accessor that takes a IFieldProxy we can get away with no receiver because the field proxy can determine if static or not, and if not
-			// static it will fail at evaluation time.
-			if (!hasReceiver)
-				throw new IllegalArgumentException(MessageFormat.format(
-						ProxyMessages.Expression_MethodsNeedReceiver_EXC_, new Object[] { name})); 
-
-			pushMethodInvocation(forExpression, name, hasReceiver, argumentCount);
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	/**
-	 * @param forExpression
-	 * @param method String for method name, IMethodProxy otherwise.
-	 * @param hasReceiver 
-	 * @param argumentCount
-	 * @throws ThrowableProxy
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.1.0
-	 */
-	private void pushMethodInvocation(ForExpression forExpression, Object method, boolean hasReceiver, int argumentCount) throws IllegalArgumentException, IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			switch (argumentCount) {
-				case 0:
-					push(METHOD_ARGUMENTS_0);
-					break;
-				case 1:
-					push(METHOD_ARGUMENTS_1);
-					break;
-				default:
-					push(new Integer(argumentCount));
-					break;
-			}
-			push(hasReceiver ? Boolean.TRUE : Boolean.FALSE);
-			push(method);
-			push(InternalExpressionTypes.METHOD_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			while (argumentCount-- > 0)
-				pushForExpression(ForExpression.METHOD_ARGUMENT);
-			if (hasReceiver)
-				pushForExpression(ForExpression.METHOD_RECEIVER);
-			processExpression(); // See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrefixExpression(int, org.eclipse.jem.internal.proxy.initParser.tree.PrefixOperator)
-	 */
-	public final void createPrefixExpression(ForExpression forExpression, PrefixOperator operator) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			push(operator);
-			push(InternalExpressionTypes.PREFIX_EXPRESSION);
-			
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.PREFIX_OPERAND);
-			processExpression();	// See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	/**
-	 * Create a new instance using the initialization string. The result must be compatible with the
-	 * given type. This is not on the IExpression interface because it is not for use of regular
-	 * customers. It is here for the allocation processer to create entries that are just strings.
-	 * <p>
-	 * This is not customer advanced API. This API for the implementers of registries and expression subclasses.
-	 * 
-	 * @param forExpression
-	 * @param initializationString
-	 * @param type
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void createNewInstance(ForExpression forExpression, String initializationString, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException{
-		try {
-			checkForExpression(forExpression);
-			validateProxy(type);
-			pushNewInstanceToProxy(initializationString, type);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createNull(int)
-	 */
-	public final void createNull(ForExpression forExpression) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(null);
-			processExpression();	// See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTypeLiteral(int, java.lang.String)
-	 */
-	public final void createTypeLiteral(ForExpression forExpression, String type) throws IllegalStateException {
-		createProxyExpression(forExpression, getProxyBeanType(type));
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTypeReceiver(java.lang.String)
-	 */
-	public final void createTypeReceiver(String type) throws IllegalStateException {
-		pushTypeReceiver(getProxyBeanType(type));
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTypeReceiver(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	public final void createTypeReceiver(IProxyBeanType type) throws IllegalStateException, IllegalArgumentException {
-		validateProxy(type);
-		pushTypeReceiver(type);
-	}
-
-	/*
-	 * Push for a type receiver.
-	 * @param type
-	 * 
-	 * @since 1.0.0
-	 */
-	private void pushTypeReceiver(IProxyBeanType type) throws IllegalStateException {
-		try {
-			// This is special because type receivers are only valid as the receiver for a field access or a method access.
-			// Since each has a different forExpression we need to test for one or the other. It doesn't make any difference
-			// which one it is, but it must be one or the other.
-			if (peekForExpression(ForExpression.FIELD_RECEIVER))
-				checkForExpression(ForExpression.FIELD_RECEIVER);
-			else
-				checkForExpression(ForExpression.METHOD_RECEIVER);
-			
-			pushTypeReceiverToProxy(type);
-			processExpression();	// See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}			
-	}
-	
-	/*
-	 * For all of the primitive types we will be creating a IBeanProxy for them. That is because that
-	 * would be the expected result of the expression, and no need to get the other side involved.
-	 */
-
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, boolean)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, boolean value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, char)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, char value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, byte)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, byte value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, double)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, double value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, float)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, float value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, int)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, int value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, long)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, long value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createPrimitiveLiteral(int, short)
-	 */
-	public final void createPrimitiveLiteral(ForExpression forExpression, short value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createStringLiteral(int, java.lang.String)
-	 */
-	public final void createStringLiteral(ForExpression forExpression, String value) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			pushToProxy(beanProxyFactory.createBeanProxyWith(value));
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createProxyExpression(int, org.eclipse.jem.internal.proxy.core.IProxy)
-	 */
-	public final void createProxyExpression(ForExpression forExpression, IProxy proxy) throws IllegalStateException, IllegalArgumentException {
-		try {
-			checkForExpression(forExpression);
-			validateProxy(proxy);
-			pushToProxy(proxy);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createAssignmentExpression(int)
-	 */
-	public final void createAssignmentExpression(ForExpression forExpression) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			push(InternalExpressionTypes.ASSIGNMENT_EXPRESSION);
-			
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.ASSIGNMENT_RIGHT);
-			pushForExpression(ForExpression.ASSIGNMENT_LEFT);
-			processExpression();	// See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createAssignmentExpression(int)
-	 */
-	public final ExpressionProxy createProxyAssignmentExpression(ForExpression forExpression) throws IllegalStateException {
-		try {
-			checkForExpression(forExpression);
-			ExpressionProxy proxy = allocateExpressionProxy(NORMAL_EXPRESSION_PROXY);
-			push(proxy);
-			push(InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.ASSIGNMENT_RIGHT);
-			processExpression(); // See if previous expression is ready for processing.
-			return proxy;
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	/**
-	 * Called by registries to create an expression proxy for a bean type. It is not in the interface because it should
-	 * only be called by the proxy registry to create an expression proxy. It shouldn't be called outside of the registries
-	 * because there may already exist in the registry the true IBeanTypeProxy, and that one should be used instead.
-	 * <p>
-	 * This is not customer advanced API. This API for the implementers of registries and expression subclasses.
-	 * 
-	 * @param typeName
-	 * @return expression proxy that is hooked up and will notify when resolved. It can be called at any time. The resolution will occur at this point in the
-	 * execution stack, but since it will not interfere with the stack this is OK, other than it could throw a ClassNotFoundException on the
-	 * execution.
-	 * 
-	 * @since 1.1.0
-	 */
-	public final IProxyBeanType createBeanTypeExpressionProxy(String typeName) {
-		IBeanTypeExpressionProxy proxy = (IBeanTypeExpressionProxy) allocateExpressionProxy(BEANTYPE_EXPRESSION_PROXY);
-		proxy.setTypeName(typeName);
-		// This can be sent at any time. It doesn't matter what is on the expression stack. It will be sent to be resolved immediately.
-		pushBeanTypeToProxy(proxy);
-		return proxy;
-	}
-
-	/**
-	 * Called by registries to create an expression proxy for a method. It is not in the interface because it should
-	 * only be called by the proxy registry to create an expression proxy. It shouldn't be called outside of the registries
-	 * because there may already exist in the registry the true IMethodProxy, and that one should be used instead.
-	 * <p>
-	 * This is not customer advanced API. This API for the implementers of registries and expression subclasses.
-	 * 
-	 * @param declaringType
-	 * @param methodName
-	 * @param parameterTypes parameter types or <code>null</code> if no parameter types.
-	 * @return
-	 * 
-	 * @throws IllegalArgumentException
-	 * @since 1.1.0
-	 */
-	public final IProxyMethod createMethodExpressionProxy(IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes) throws IllegalArgumentException{
-		validateProxy(declaringType);
-		if (parameterTypes != null && parameterTypes.length > 0) {
-			for (int i = 0; i < parameterTypes.length; i++) {
-				validateProxy(parameterTypes[i]);
-			}
-		}
-		ExpressionProxy proxy = allocateExpressionProxy(METHOD_EXPRESSION_PROXY);
-		// This can be sent at any time. It doesn't matter what is on the expression stack. It will be sent to be resolved immediately.
-		pushMethodToProxy(proxy, declaringType, methodName, parameterTypes);
-		return (IProxyMethod) proxy;
-	}
-	
-	/**
-	 * Called by registries to create an expression proxy for a field. It is not in the interface because it should
-	 * only be called by the proxy registry to create an expression proxy. It shouldn't be called outside of the registries
-	 * because there may already exist in the registry the true IFieldProxy, and that one should be used instead.
-	 * <p>
-	 * This is not customer advanced API. This API for the implementers of registries and expression subclasses.
-	 * 
-	 * @param declaringType
-	 * @param fieldName
-	 * @return
-	 * 
-	 * @throws IllegalArgumentException
-	 * @since 1.1.0
-	 */
-	public final IProxyField createFieldExpressionProxy(IProxyBeanType declaringType, String fieldName) throws IllegalArgumentException {
-		validateProxy(declaringType);
-		ExpressionProxy proxy = allocateExpressionProxy(FIELD_EXPRESSION_PROXY);
-		// This can be sent at any time. It doesn't matter what is on the expression stack. It will be sent to be resolved immediately.
-		pushFieldToProxy(proxy, declaringType, fieldName);
-		return (IProxyField) proxy;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createProxyReassignmentExpression(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.ExpressionProxy)
-	 */
-	public final void createProxyReassignmentExpression(ForExpression forExpression, ExpressionProxy proxy) throws IllegalStateException, IllegalArgumentException {
-		try {
-			checkForExpression(forExpression);
-			if (!proxy.isValidForReassignment())
-				throw new IllegalArgumentException(MessageFormat.format(ProxyMessages.Expression_CreateProxyReassignmentExpression_InvalidForReassignment_EXC_, new Object[]{proxy.toString()})); 
-			push(proxy);
-			push(InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION);
-
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.ASSIGNMENT_RIGHT);
-			processExpression(); // See if previous expression is ready for processing.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-		
-	protected static final int NORMAL_EXPRESSION_PROXY = 0;
-	protected static final int BEANTYPE_EXPRESSION_PROXY = 1;
-	protected static final int METHOD_EXPRESSION_PROXY = 2;
-	protected static final int FIELD_EXPRESSION_PROXY = 3;
-	/**
-	 * Allocate a new ExpressionProxy
-	 * @return new ExpressionProxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected final ExpressionProxy allocateExpressionProxy(int proxyType) {
-		if (expressionProxies == null)
-			expressionProxies = new ArrayList();
-		// It is very important that this always creates a proxy id that is greater than all previous. This is
-		// so that it can be assured that proxies will be resolved in order of creation.
-		// Currently this is done here by using expressionProxies.size().
-		ExpressionProxy proxy = createExpressionProxy(proxyType, expressionProxies.size());
-		expressionProxies.add(proxy);
-		return proxy;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createFieldAccess(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.IProxyField, boolean)
-	 */
-	public final void createFieldAccess(ForExpression forExpression, IProxyField fieldProxy, boolean hasReceiver) throws IllegalStateException, IllegalArgumentException {
-		validateProxy(fieldProxy);
-		pushFieldAccess(forExpression, fieldProxy, hasReceiver);
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createMethodInvocation(org.eclipse.jem.internal.proxy.initParser.tree.ForExpression, org.eclipse.jem.internal.proxy.core.IProxyMethod, boolean, int)
-	 */
-	public final void createMethodInvocation(ForExpression forExpression, IProxyMethod methodProxy, boolean hasReceiver, int argumentCount) throws IllegalArgumentException,
-			IllegalStateException {
-		validateProxy(methodProxy);
-		pushMethodInvocation(forExpression, methodProxy, hasReceiver, argumentCount);
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createSimpleFieldAccess(org.eclipse.jem.internal.proxy.core.IProxyField, org.eclipse.jem.internal.proxy.core.IProxy)
-	 */
-	public final ExpressionProxy createSimpleFieldAccess(IProxyField field, IProxy receiver) throws IllegalStateException, IllegalArgumentException {
-		validateProxy(field);
-		validateProxy(receiver);
-		ExpressionProxy result = createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION);
-		createFieldAccess(ForExpression.ASSIGNMENT_RIGHT, field, receiver != null);
-		if (receiver != null)
-			createProxyExpression(ForExpression.FIELD_RECEIVER, receiver);
-		return result;
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createSimpleFieldSet(org.eclipse.jem.internal.proxy.core.IProxyField, org.eclipse.jem.internal.proxy.core.IProxy, org.eclipse.jem.internal.proxy.core.IProxy, boolean)
-	 */
-	public final ExpressionProxy createSimpleFieldSet(IProxyField field, IProxy receiver, IProxy value, boolean wantResult) throws IllegalStateException, IllegalArgumentException {
-		validateProxy(field);
-		validateProxy(receiver);
-		ExpressionProxy result = null;
-		ForExpression forExpression = ForExpression.ROOTEXPRESSION;
-		if (wantResult) {
-			result = createProxyAssignmentExpression(forExpression);
-			forExpression = ForExpression.ASSIGNMENT_RIGHT;			
-		}		
-		createAssignmentExpression(forExpression);
-		createFieldAccess(ForExpression.ASSIGNMENT_LEFT, field, receiver != null);
-		if (receiver != null)
-			createProxyExpression(ForExpression.FIELD_RECEIVER, receiver);
-		createProxyExpression(ForExpression.ASSIGNMENT_RIGHT, value);
-		return result;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createSimpleMethodInvoke(org.eclipse.jem.internal.proxy.core.IMethodProxy, org.eclipse.jem.internal.proxy.core.IProxy, org.eclipse.jem.internal.proxy.core.IProxy[], boolean)
-	 */
-	public final ExpressionProxy createSimpleMethodInvoke(IProxyMethod method, IProxy receiver, IProxy[] arguments, boolean wantResult)
-			throws IllegalStateException, IllegalArgumentException {
-		validateProxy(method);
-		validateProxy(receiver);
-		if (arguments != null && arguments.length > 0) {
-			for (int i = 0; i < arguments.length; i++) {
-				validateProxy(arguments[i]);
-			}
-		}
-		ForExpression nextExpression = ForExpression.ROOTEXPRESSION;
-		ExpressionProxy result = null;
-		if (wantResult) {
-			result = createProxyAssignmentExpression(nextExpression);
-			nextExpression = ForExpression.ASSIGNMENT_RIGHT;
-		}
-		createMethodInvocation(nextExpression, method, receiver != null, arguments != null ? arguments.length : 0);
-		if (receiver != null)
-			createProxyExpression(ForExpression.METHOD_RECEIVER, receiver);
-		if (arguments != null) {
-			for (int i = 0; i < arguments.length; i++) {
-				createProxyExpression(ForExpression.METHOD_ARGUMENT, arguments[i]);
-			}
-		}
-		return result;
-	}
-	
-	private int subexpressionNumber = -1;	// Current subexpression number. This is always incrementing.
-	
-	public void createSubexpression() throws IllegalStateException {
-		try {
-			// Subexpressions are special, they can be anywhere.
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(SUBEXPRESSIONEND_EXPRESSION);
-			pushForExpression(ForExpression.ROOTEXPRESSION);
-
-			pushSubexpressionBeginToProxy(++subexpressionNumber);
-			push(new Integer(subexpressionNumber));
-			push(InternalExpressionTypes.SUBEXPRESSION_END_EXPRESSION);
-			processExpression();
-			return;
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	public void createSubexpressionEnd() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			popForExpression(); // Remove the root expression since block is done.
-			checkForExpression(SUBEXPRESSIONEND_EXPRESSION); // This needs to be next for it to be valid.
-			processExpression(); // Now let it handle the previously pushed end subexpression, containing the subexpression number being ended.
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	
-	private int tryNumber = -1;	// Current try number. This is always incrementing.
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTry()
-	 */
-	public final void createTry() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			pushForExpression(PROCESS_EXPRESSION); // Set up so that when reached we can process the TRY_END that we've pushed data for later in this method.
-			pushForExpression(TRYEND_EXPRESSION); // Must get a try end before we can process it.
-			pushForExpression(TRYCATCH_EXPRESSION); // Must get a catch/finally clause (or try end, which knows how to handle this).
-			pushForExpression(ForExpression.ROOTEXPRESSION); // Expecting root expressions for the try clause.
-
-			pushTryBeginToProxy(++tryNumber);
-			push(new Integer(tryNumber));
-			push(InternalExpressionTypes.TRY_END_EXPRESSION);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTryCatchClause(org.eclipse.jem.internal.proxy.core.IProxyBeanType, boolean)
-	 */
-	public final ExpressionProxy createTryCatchClause(IProxyBeanType exceptionType, boolean wantExceptionReturned)
-			throws IllegalStateException, IllegalArgumentException {
-		validateProxy(exceptionType);
-		return pushTryCatch(exceptionType, wantExceptionReturned);
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTryCatchClause(java.lang.String, boolean)
-	 */
-	public final ExpressionProxy createTryCatchClause(String exceptionType, boolean wantExceptionReturned)
-		throws IllegalStateException {
-		return pushTryCatch(getProxyBeanType(exceptionType), wantExceptionReturned);
-	}
-
-	/**
-	 * @param exceptionType
-	 * @param wantExceptionReturned
-	 * @return
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	private ExpressionProxy pushTryCatch(IProxyBeanType exceptionType, boolean wantExceptionReturned) throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			popForExpression(); // Remove the root expression since try or previous catch clause is done.
-			checkForExpression(TRYCATCH_EXPRESSION); // This needs to be next for it to be valid.
-			pushForExpression(TRYCATCH_EXPRESSION); // Set up for a following catch/finally clause.
-			pushForExpression(ForExpression.ROOTEXPRESSION); // Root expressions are next for the catch clause.
-
-			int tryNumber = ((Integer) peek(2)).intValue(); // Get the try#. It should be in this place on the stack.
-
-			ExpressionProxy ep = null;
-			if (wantExceptionReturned)
-				ep = allocateExpressionProxy(NORMAL_EXPRESSION_PROXY);
-			pushTryCatchClauseToProxy(tryNumber, exceptionType, ep);
-
-			processExpression();
-			return ep;
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTryEnd()
-	 */
-	public final void createTryEnd() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			popForExpression(); // Remove the root expression since try or previous catch clause is done.
-			if (peekForExpression(TRYCATCH_EXPRESSION))
-				checkForExpression(TRYCATCH_EXPRESSION); // This may of been next if no finally clause was added. If a finally clause was added this would not be here.
-			checkForExpression(TRYEND_EXPRESSION); // And this needs to be after that to be valid.
-
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createTryFinallyClause()
-	 */
-	public final void createTryFinallyClause() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			popForExpression(); // Remove the root expression since try or previous catch clause is done.
-			checkForExpression(TRYCATCH_EXPRESSION); // This needs to be next for it to be valid.
-			pushForExpression(ForExpression.ROOTEXPRESSION); // Root expressions are next for the finally clause.
-
-			int tryNumber = ((Integer) peek(2)).intValue(); // Get the try#. It should be in this place on the stack.
-
-			pushTryFinallyClauseToProxy(tryNumber);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createRethrow()
-	 */
-	public final void createRethrow() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			popForExpression(); // Remove the root expression since try or previous catch clause is done.
-			checkForExpression(TRYCATCH_EXPRESSION); // This needs to be next for it to be valid.
-			// It is in a valid state, so put the catch and root back on so that things work correctly.
-			pushForExpression(TRYCATCH_EXPRESSION);
-			pushForExpression(ForExpression.ROOTEXPRESSION); 
-
-			int tryNumber = ((Integer) peek(2)).intValue(); // Get the try#. It should be in this place on the stack.
-
-			pushRethrowToProxy(tryNumber);
-			processExpression();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IExpression#createThrow()
-	 */
-	public final void createThrow() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			push(InternalExpressionTypes.THROW_EXPRESSION);
-			pushForExpression(PROCESS_EXPRESSION);
-			pushForExpression(ForExpression.THROW_OPERAND); // The next expression must be for the throw value.
-			processExpression(); 
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	
-	public final int mark() throws IllegalStateException {
-		try {
-			checkForExpression(ForExpression.ROOTEXPRESSION);
-			++highestMarkID;
-			currentMarkEntry = new MarkEntry();
-			currentMarkEntry.markID = highestMarkID;
-			currentMarkEntry.controlStackPos = controlStack.size() - 1;
-			currentMarkEntry.nextExpressionStackPos = nextForExpressionStackPos;
-			currentMarkEntry.expressionProxiesPos = expressionProxies != null ? expressionProxies.size() - 1 : -1;
-			if (markEntries == null)
-				markEntries = new ArrayList(5);
-			markEntries.add(currentMarkEntry);
-			pushMarkToProxy(highestMarkID);
-			return highestMarkID;
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-	
-	public void endMark(int markNumber) throws IllegalStateException {
-		if (isValid()) {
-			// Can only do a valid end mark if we are at root. If not at root, we fall through and treat as invalid.
-			if (peekForExpression(ForExpression.ROOTEXPRESSION)) {
-				checkForExpression(ForExpression.ROOTEXPRESSION);	// Now remove it if it should be removed. 
-				// If the current mark number is not the same as the incoming mark number, we have improper nesting.
-				if (currentMarkEntry == null || currentMarkEntry.markID != markNumber)
-					throwInvalidMarkNesting();	// We have improper nesting.
-				// We are popping the current mark. Since we are valid, just move up one in the mark stack.
-				MarkEntry me = (MarkEntry) markEntries.remove(markEntries.size()-1);
-				if (!markEntries.isEmpty())
-					currentMarkEntry = (MarkEntry) markEntries.get(markEntries.size()-1);
-				else
-					currentMarkEntry = null;
-				pushEndmarkToProxy(markNumber, false);
-				if (me.controlStackPos != controlStack.size()-1 || me.nextExpressionStackPos != nextForExpressionStackPos)
-					throwInvalidMarkNesting();	// The stacks should be back to the same size at this point for a valid end mark.
-				return;
-			}
-		} 
-		
-		// It was invalid, or became invalid.
-		if (markEntries == null)
-			throwInvalidMarkNesting();	// We have no marks, so this is an invalid end mark.
-		
-		// We are invalid, need to pop to the given markNumber.
-		// Starting from the end we search back to find the entry for the given mark number. We do it
-		// from the end because it is more likely to be closer to the end than to the beginning.
-		for (int i = markEntries.size()-1; i >=0; i--) {
-			MarkEntry me = (MarkEntry) markEntries.get(i);
-			if (me.markID == markNumber) {
-				// Found it.
-				// Trim the control stack down to the size at time of mark. (No easy way to do this other than repeated remove's.
-				// We do it backwards to eliminate repeated shuffling of entries.
-				for (int j = controlStack.size()-1; j > me.controlStackPos; j--) {
-					controlStack.remove(j);
-				}
-				
-				// Trim the expression stack. This is simple, just reset the next entry pointer.
-				nextForExpressionStackPos = me.nextExpressionStackPos;
-				
-				if (expressionProxies != null) {
-					// Now we need to mark all of the expression proxies that occured after the mark as
-					// not resolved (since someone may be listening), and remove them, and reuse the proxies.
-					for (int j = expressionProxies.size()-1; j > me.expressionProxiesPos; j--) {
-						ExpressionProxy proxy = (ExpressionProxy) expressionProxies.remove(j);
-						if (proxy != null && proxy.hasListeners())
-							fireProxyNotResolved(proxy);
-					}
-				}
-				
-				// Now that we know it is valid, we want to remove all of the mark entries above it in the stack
-				// since those are now invalid. We couldn't remove them as we were searching for the entry because
-				// if the entry wasn't found we didn't want to wipe out the probably valid ones.
-				for (int j = markEntries.size()-1; j >= i; j--) {
-					markEntries.remove(j);
-				}
-				
-				if (!markEntries.isEmpty())
-					currentMarkEntry = (MarkEntry) markEntries.get(markEntries.size()-1);
-				else
-					currentMarkEntry = null;					
-				pushEndmarkToProxy(markNumber, true);
-				expressionValid = true;
-				return;
-			} 
-		}
-		throwInvalidMarkNesting();	// The mark number wasn't found, so this is an invalid end mark.
-	}
-	
-	/**
-	 * Begin the transfer of the expression to another thread.
-	 * <p>
-	 * This is used when the expression needs to continue to be built up, but it needs
-	 * to be done on a different thread. The reason for doing something special other
-	 * than just using it on the other thread is that some proxy registries connections are
-	 * tied through the thread. If you switched to another thread the connections would not
-	 * be properly set up.
-	 * This is not on the IExpression interface because even though it is API, it is tricky
-	 * to use and so not exposed to everyone. Users can legitimately cast to Expression and 
-	 * use this as API for advanced use. 
-	 * <p>
-	 * This is used to begin the transfer. It puts it into a state ready for the transfer. Calling this
-	 * method will cause a synchronization of the expression up to the current level. This means
-	 * that it will not return until the expression has been completely processed in the proxy registry
-	 * up to this point. Typically the connection is a pipe where the instructions are just pushed onto
-	 * it and the caller is not held up waiting for the registry to process it. 
-	 * <p>
-	 * Then when the other thread is done, it will call beginTransferThread itself to signal that it is done
-	 * and that the old thread can pick it up. Then the old thread will call transferThread to pick up processing.
-	 * <p>
-	 * It will be:
-	 * <pre><code>
-	 *   ... expression stuff ...
-	 *   expression.beginTransferThread()
-	 *   ... do what is necessary to get to the other thread ...
-	 *   ... on other thread:
-	 *   expression.transferThread();
-	 *   try {
-	 *     ... do your expression stuff on this thread ...
-	 *   } finally {
-	 *     expression.beginTransferThread(); // This is to return it to old thread.
-	 *   }
-	 *   ... tell old thread to pick up ...
-	 *   ... back on old thread:
-	 *   expression.transferThread();
-	 *   ... do more expression stuff ...
-	 *   expression.invokeExpression();
-	 * </code></pre>
-	 * 
-	 * @throws IllegalStateException
-	 * @throws ThrowableProxy Thrown if there was an exception with the remote vm during this request.
-	 * @since 1.1.0
-	 */
-	public final void beginTransferThread() throws IllegalStateException, ThrowableProxy {
-		try {
-			pushForExpression(THREADTRANSFER_EXPRESSION);
-			pushBeginTransferThreadToProxy();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}
-	}
-		
-	/**
-	 * Transfer the expression to the current thread.
-	 * <p>
-	 * This is called to actually transfer to the current thread. It must be the next call against
-	 * the expression after the beginTransferThread, but on the new thread.
-	 * <p>
-	 * This is not on the IExpression interface because even though it is API, it is tricky
-	 * to use and so not exposed to everyone. Users can legitimately cast to Expression and 
-	 * use this as API for advanced use. 
-	 * @see Expression#beginTransferThread() for a full explanation.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public final void transferThread() throws IllegalStateException {
-		try {
-			checkForExpression(THREADTRANSFER_EXPRESSION);
-			pushTransferThreadToProxy();
-		} catch (RuntimeException e) {
-			markInvalid();
-			throw e;
-		}		
-	}
-	
-	
-	/**
-	 * Get the IProxyBeanType for the type string sent in.
-	 * @param type
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IProxyBeanType getProxyBeanType(String type) {
-		return getRegistry().getBeanTypeProxyFactory().getBeanTypeProxy(this, type);
-	}
-	
-	/**
-	 * Create the expression proxy subclass that is applicable for this kind of processor. 
-	 * @param proxyType type of proxy. {@link Expression#NORMAL_EXPRESSION_PROXY
-	 * @param proxyID the id of the new expression proxy.
-	 * 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract ExpressionProxy createExpressionProxy(int proxyType, int proxyID);
-	
-	/**
-	 * Push this proxy to the other side. It will simply take the proxy and push it onto
-	 * its evaluation stack. It will be treated as the result of an expression. It's just 
-	 * that the expression was evaluatable on this side (since it is already a proxy).
-	 * 
-	 * @param proxy
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushToProxy(IProxy proxy);
-
-	/**
-	 * Tell the other side we are complete. This will always be called after expression evaluation, or
-	 * if expression was prematurely closed.
-	 * <p>
-	 * <b>Note:</b> The implementation must be able to handle multiple invocations, where the first call is a valid close and any
-	 * subsequent call should be ignored.
-	 * 
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void closeProxy();
-	
-	/**
-	 * Do invoke. This should simply make sure everything is done and throw any pending errors.
-	 * <p>
-	 * <b>Note:</b> The expression proxies MUST be resolved (callbacks called) in the order they are found in the expressionProxies list. This
-	 * is so that the contract is followed that resolution notifications will occur in the order of creation.
-	 * 
-	 * @param proxycount Number of Expression Proxies that need a callback.
-	 * @param list of expression proxies. If proxycount > 0, then process the non-null entries in the list. They will be of type ExpressionProxy.
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushInvoke(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException;
-	
-	/**
-	 * Pull the top expression value from the evaluation stack. It will also under
-	 * the covers call closeProxy.  It also must process the expression proxy callbacks. It must do the expression proxy callbacks first, and then
-	 * process the result value. If an error had occured sometime during processing, it should still process the proxy callbacks before throwing
-	 * an exception.
-	 * <p>
-	 * <b>Note:</b> The expression proxies MUST be resolved (callbacks called) in the order they are found in the expressionProxies list. This
-	 * is so that the contract is followed that resolution notifications will occur in the order of creation. Also <b>REQUIRED</b> is that
-	 * the entire list must be processed of proxies must be processed by this call. It cannot do some or none.
-	 * 
-	 * @param proxycount Number of Expression Proxies that need a callback.
-	 * @param list of expression proxies. If proxycount > 0, then process the non-null entries in the list. They will be of type ExpressionProxy.
-	 * @return The top level evaluation stack value.
-	 * @throws ThrowableProxy
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract IBeanProxy pullProxyValue(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException;
-	
-	/**
-	 * Push to proxy the cast expression. The expression to use will be on the top of its evaluation stack.
-	 * The result of the cast expression will be placed onto the evaluation stack.
-	 *  
-	 * @param type Cast type. 
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushCastToProxy(IProxyBeanType type);
-
-	/**
-	 * Push to proxy the instanceof expression. The expression to use will be on the top of its evaluation stack.
-	 * The result of the instanceof expression will be placed onto the evaluation stack.
-	 *  
-	 * @param type Instanceof type.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushInstanceofToProxy(IProxyBeanType type);
-	
-	/**
-	 * Push to proxy the infix operation. This is called on the completion of each operand of the expression.
-	 * So it will be called a minimum of two times.
-	 * 
-	 * @param operator The operator.
-	 * @param operandType The operand type. left, other, or last.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushInfixToProxy(InfixOperator operator, InternalInfixOperandType operandType);
-	
-	/**
-	 * Push to proxy the prefix expression. The expression to use will be on top of its evaluation stack.
-	 * The result of the prefix operation will be placed onto the evaluation stack.
-	 * 
-	 * @param operator 
-	 * 
-	 * @see IExpressionConstants#PRE_MINUS
-	 * @since 1.0.0
-	 */
-	protected abstract void pushPrefixToProxy(PrefixOperator operator);	
-
-	
-	/**
-	 * Push to proxy the array access. The result will be placed onto the evaluation stack.
-	 * 
-	 * @param indexCount
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushArrayAccessToProxy(int indexCount);
-	
-	/**
-	 * Push to proxy the array creation. The result will be placed onto the evaluation stack.
-	 * @param type The array type. 
-	 * @param dimensionCount
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushArrayCreationToProxy(IProxyBeanType type, int dimensionCount);
-	
-	/**
-	 * Push to proxy the array initializer. The resulting array will be placed onto the evaluation stack.
-	 * @param type The array type. (must be an array type).
-	 * @param stripDimCount the number of dimensions that must be stripped from the array type. This is needed
-	 * because the first array initializer needs to be for the component type of the array (array minus one dimension), and
-	 * each initializer after that needs one more dimension stripped off. But since we are working with possible expression
-	 * proxies for "type", we can't create the appropriate component types of the array. So we need to tell the
-	 * processor how many dims to strip from the original type (which is what is sent in on every initializer push, the original type).
-	 * @param expressionCount
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushArrayInitializerToProxy(IProxyBeanType type, int stripDimCount, int expressionCount);
-	
-	/**
-	 * Push to proxy the class instance creation. The resulting class instance will be placed onto the evaluation stack.
-	 * 
-	 * @param type Class type. 
-	 * @param argumentCount The number of arguments.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushClassInstanceCreationToProxy(IProxyBeanType type, int argumentCount);
-	
-	/**
-	 * Push to proxy the type receiver. The resulting class will be placed onto the evaluation stack, along with it also
-	 * being the expression type.
-	 * @param type Class type. 
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushTypeReceiverToProxy(IProxyBeanType type);
-
-	/**
-	 * Push to proxy the field access. The result value will be placed onto the evaluation stack.
-	 * @param field The name of the field if string, or an IFieldProxy.
-	 * @param hasReceiver Has receiver flag.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushFieldAccessToProxy(Object field, boolean hasReceiver);
-	
-	/**
-	 * Push to proxy the method invocation. The result value will be placed onto the evaluation stack.
-	 * 
-	 * @param method String for method name or IProxyMethod
-	 * @param hasReceiver
-	 * @param argCount
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushMethodInvocationToProxy(Object method, boolean hasReceiver, int argCount);
-	
-	/**
-	 * Push to proxy the conditional expression. This will be called on each part of expression. The expression type
-	 * will be the current part (e.g. test, true, false).
-	 * 
-	 * @param expressionType The expression type.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected abstract void pushConditionalToProxy(InternalConditionalOperandType expressionType);
-	
-	/**
-	 * Push to the proxy the expression proxy. Whatever the last expression value is will be assigned to the ExpressionProxy.
-	 * 
-	 * @param proxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushAssignmentToProxy(ExpressionProxy proxy);
-	
-	/**
-	 * Push the assignment expression. The operands are already on the stack.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushAssignmentToProxy();
-
-	
-	/**
-	 * Push the begin block expression. 
-	 * @param blockNumber 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushBlockBeginToProxy(int blockNumber);
-	
-	/**
-	 * Push the end block expression.
-	 * @param blockNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushBlockEndToProxy(int blockNumber);
-
-	/**
-	 * Push the break block expression.
-	 * @param blockNumber
-	 * 
-	 * @since 1.1.0
-	 *
-	 */
-	protected abstract void pushBlockBreakToProxy(int blockNumber);
-	
-	/**
-	 * Push the begin try expression. 
-	 * @param tryNumber 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushTryBeginToProxy(int tryNumber);
-
-	/**
-	 * Push the catch clause to proxy.
-	 * @param tryNumber
-	 * @param exceptionType 
-	 * @param ep ExpressionProxy to be assigned with the exception or <code>null</code> if exception is not to be assigned.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushTryCatchClauseToProxy(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep);
-
-	/**
-	 * Push the finally clause to proxy.
-	 * @param tryNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushTryFinallyClauseToProxy(int tryNumber);
-
-	/**
-	 * Push try end to proxy.
-	 * @param tryNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushTryEndToProxy(int tryNumber);
-	
-	/**
-	 * Push the throw of the exception to proxy.
-	 * @param exception
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushThrowToProxy();
-	
-	/**
-	 * Push a rethrow to proxy.
-	 * @param tryNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushRethrowToProxy(int tryNumber);
-
-	/**
-	 * Push the BeanType Expression proxy to be resolved on the execution side.
-	 * @param proxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushBeanTypeToProxy(IBeanTypeExpressionProxy proxy);
-	
-	/**
-	 * Push the Method Expression proxy to be resolved on the execution side.
-	 * @param proxy
-	 * @param declaringType
-	 * @param methodName
-	 * @param parameterTypes parameter types or <code>null</code> if no parameters.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushMethodToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes);
-
-	/**
-	 * Push the Field Expression Proxy to be resolved on the execution side.
-	 * @param proxy
-	 * @param declaringType
-	 * @param fieldName
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushFieldToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String fieldName);
-	
-	/**
-	 * Push the If test condition to proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushIfTestToProxy();
-	
-	/**
-	 * Push a true or else clause to proxy.
-	 * @param clauseType
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushIfElseToProxy(InternalIfElseOperandType clauseType);
-	
-	/**
-	 * Push to proxy a new instance using an initialization string.
-	 * @param initializationString
-	 * @param resultType
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushNewInstanceToProxy(String initializationString, IProxyBeanType resultType);
-	
-	/**
-	 * Push the mark id to proxy.
-	 * 
-	 * @param markID
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushMarkToProxy(int markID);
-	
-	/**
-	 * Push the end mark id to proxy.
-	 * 
-	 * @param markID
-	 * @param restore <code>true</code> if this is a restore due to error, <code>false</code> if this is just a normal end mark.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushEndmarkToProxy(int markID, boolean restore);
-	
-	/**
-	 * Push the begin transfer thread to proxy.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushBeginTransferThreadToProxy() throws ThrowableProxy;
-	
-	/**
-	 * Push the actual transfer to the current thread to proxy.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushTransferThreadToProxy();
-	
-	/**
-	 * Push the subexpression begin to proxy.
-	 * @param subexpressionNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushSubexpressionBeginToProxy(int subexpressionNumber);
-	
-	/**
-	 * Push the subexpression end to proxy.
-	 * @param subexpressionNumber
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract void pushSubexpressionEndToProxy(int subexpressionNumber);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ExpressionProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ExpressionProxy.java
deleted file mode 100644
index 94ea28c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ExpressionProxy.java
+++ /dev/null
@@ -1,349 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ExpressionProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.util.EventObject;
-import java.util.logging.Level;
- 
-
-/**
- * This is a proxy for an IExpression evaluation value. It is used as a place holder proxy value for result of an expression, and
- * then the value can be used in a later expression, or at the end, it can callback and return a proxy in the IDE 
- * side in a callback for usage later on outside of the IExpression.
- * <p>
- * After receiving the resolved event, listeners should not hold onto the ExpressionProxy because it would then be invalid. At that
- * point they should instead hold onto the resolved bean proxy.
- * 
- * @see org.eclipse.jem.internal.proxy.core.IExpression#assignExpressionProxy()
- * @see org.eclipse.jem.internal.proxy.core.IExpression#createExpressionProxyExpression(int, ExpressionProxy)
- * @since 1.1.0
- */
-public class ExpressionProxy implements IProxy {
-
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return getExpression().getRegistry();
-	}
-	
-	/**
-	 * The event object for the resolved event of the proxy listener.
-	 * <p>
-	 * The source will be the ExpressionProxy that is being resolved.
-	 * @since 1.1.0
-	 */
-	public static class ProxyEvent extends EventObject {
-		
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0
-		 */
-		private static final long serialVersionUID = -2305781662465107377L;
-		private final IBeanProxy proxy;
-
-		/**
-		 * @param source the expression proxy for the event.
-		 * @param proxy the bean proxy the expression proxy (source) resolved to.
-		 * 
-		 * @since 1.1.0
-		 */
-		public ProxyEvent(ExpressionProxy source, IBeanProxy proxy) {
-			super(source);
-			this.proxy = proxy;
-		}
-		
-		/**
-		 * Construct the event with no proxy. Used for not resolved and void.
-		 * @param source
-		 * 
-		 * @since 1.1.0
-		 */
-		public ProxyEvent(ExpressionProxy source) {
-			this(source, null);
-		}
-		
-		/**
-		 * Get the proxy value that the expression proxy (source) resolved to.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public IBeanProxy getProxy() {
-			return proxy;
-		}
-	}
-	
-	/**
-	 * Listener for expression proxy events.
-	 * 
-	 * @since 1.1.0
-	 */
-	public interface ProxyListener {
-		/**
-		 * The expression proxy has been resolved. The event contains the resolved proxy.
-		 * At this point, any listeners should no longer hold onto the ExpressionProxy
-		 * because it is now invalid. They should hold onto the resolved bean proxy instead.
-		 * 
-		 * @param event
-		 * 
-		 * @since 1.1.0
-		 */
-		public void proxyResolved(ProxyEvent event);
-		
-		/**
-		 * This is called for ExpressionProxies that have a callback listener, but the proxy 
-		 * was never resolved. This means that the expression that assigns to the proxy was
-		 * not executed. In this case the event does not have a bean proxy in it.
-		 * 
-		 * @param event
-		 * 
-		 * @since 1.1.0
-		 */
-		public void proxyNotResolved(ProxyEvent event);
-		
-		/**
-		 * This is called for ExpressionProxies that were assigned to an expression that
-		 * had a <code>VOID</code> return type. This is usually for method invocations that
-		 * have a void return type. In this case the event does not have a bean proxy in it.
-		 * @param event
-		 * 
-		 * @since 1.1.0
-		 */
-		public void proxyVoid(ProxyEvent event);
-	}
-	
-	/**
-	 * An implementation of ProxyListener that does nothing. It can be
-	 * used as a superclass for individual listeners that are only interested
-	 * in some of the events.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static class ProxyAdapter implements ProxyListener {
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyNotResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent)
-		 */
-		public void proxyNotResolved(ProxyEvent event) {
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent)
-		 */
-		public void proxyResolved(ProxyEvent event) {
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyVoid(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent)
-		 */
-		public void proxyVoid(ProxyEvent event) {
-		}
-	}
-	
-	final private int proxyID;
-	final private int proxyType;
-	private ListenerList listenerList;
-	private Expression expression;
-	
-	/**
-	 * Create with the given proxy id.
-	 * @param proxyid
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy(int proxyid, int proxyType, Expression expression) {
-		this.proxyID = proxyid;
-		this.proxyType = proxyType;
-		this.expression = expression;
-	}
-	
-	/**
-	 * Get the expression this proxy is for. 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public Expression getExpression() {
-		return expression;
-	}
-	
-	/**
-	 * Used internally in expression to get the proxy type. 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected final int getProxyType() {
-		return proxyType;
-	}
-	
-	/**
-	 * Return the proxy id.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public final int getProxyID() {
-		return proxyID;
-	}
-	
-	/**
-	 * Add a listener. If listener already added, it has no effect.
-	 * @param listener
-	 * 
-	 * @since 1.1.0
-	 */
-	public void addProxyListener(ProxyListener listener) {
-		if (listenerList == null)
-			listenerList = new ListenerList();
-		listenerList.add(listener);
-	}
-	
-	/**
-	 * Remove a listener. If listener not already added, then no error.
-	 * @param listener
-	 * 
-	 * @since 1.1.0
-	 */
-	public void removeProxyListener(ProxyListener listener) {
-		if (listenerList != null)
-			listenerList.remove(listener);
-	}
-	
-	/**
-	 * Used by internal subclasses or Expression to know if anyone is listening.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected final boolean hasListeners() {
-		return listenerList != null && !listenerList.isEmpty();
-	}
-	
-	/**
-	 * The proxy has been fired (one of the events has occurred). Subclasses should clean
-	 * up and not hold onto anything that would be expensive in case the proxy is still
-	 * held onto be someone. For example the default clears the listener list.
-	 * <p>
-	 * <b>Note:</b> Subclasses must call super.dispose().
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void dispose() {
-		listenerList = null;
-		expression = null;
-	}
-	
-	/**
-	 * Used by internal subclasses  or by Expression to fire the resolved event. Once fired all listeners are removed.
-	 * This is because only one kind of firing can be done for a expression proxy and then the proxy is dead. This
-	 * prevents listeners from being held on to if any one accidently still holds the proxy.
-	 * @param proxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fireResolved(IBeanProxy proxy) {
-		if (hasListeners()) {
-			ProxyEvent event = new ProxyEvent(this, proxy);
-			Object[] listeners = listenerList.getListeners();
-			for (int i = 0; i < listeners.length; i++) {
-				try {
-					((ProxyListener) listeners[i]).proxyResolved(event);
-				} catch (RuntimeException e) {
-					ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-				}
-			}
-		}
-		dispose();
-	}
-	
-	/**
-	 * Used by internal subclasses or by Expression to fire the not resolved event. Once fired all listeners are removed.
-	 * This is because only one kind of firing can be done for a expression proxy and then the proxy is dead. This
-	 * prevents listeners from being held on to if any one accidently still holds the proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fireNotResolved() {
-		if (hasListeners()) {
-			ProxyEvent event = new ProxyEvent(this);
-			Object[] listeners = listenerList.getListeners();
-			for (int i = 0; i < listeners.length; i++) {
-				try {
-					((ProxyListener) listeners[i]).proxyNotResolved(event);
-				} catch (RuntimeException e) {
-					ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-				}
-				
-			}
-		}
-		dispose();
-	}
-	
-	/**
-	 * Used by internal subclasses or by Expression to fire the void resolved event. Once fired all listeners are removed.
-	 * This is because only one kind of firing can be done for a expression proxy and then the proxy is dead. This
-	 * prevents listeners from being held on to if any one accidently still holds the proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fireVoidResolved() {
-		if (hasListeners()) {
-			ProxyEvent event = new ProxyEvent(this);
-			Object[] listeners = listenerList.getListeners();
-			for (int i = 0; i < listeners.length; i++) {
-				try {
-					((ProxyListener) listeners[i]).proxyVoid(event);
-				} catch (RuntimeException e) {
-					ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-				}
-				
-			}
-		}
-		dispose();
-	}	
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return false;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return true;
-	}
-	
-	/**
-	 * Is this proxy valid for reassignment. By default only if the type is NORMAL_EXPRESSION_PROXY.
-	 * Subclasses may override and return true in their cases.
-	 * 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isValidForReassignment() {
-		return getProxyType() == Expression.NORMAL_EXPRESSION_PROXY;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		return super.toString()+": "+getProxyID(); //$NON-NLS-1$
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IAccessibleObjectProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IAccessibleObjectProxy.java
deleted file mode 100644
index d9a87c4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IAccessibleObjectProxy.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IAccessibleObjectProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-/**
- * Proxy for an AccessibleObject.
- * 
- * @since 1.0.0 
- */ 
-public interface IAccessibleObjectProxy extends IBeanProxy {
-	
-	/**
-	 * Is the proxy accessible or not?
-	 * 
-	 * @return <code>true</code> if accessible.
-	 */
-	public boolean isAccessible() throws ThrowableProxy;
-	
-	/**
-	 * Set the accessible flag on the proxy.
-	 * 
-	 * @param flag <code>true</code> if accessible.
-	 * @throws ThrowableProxy
-	 */
-	public void setAccessible(boolean flag) throws ThrowableProxy;
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IArrayBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IArrayBeanProxy.java
deleted file mode 100644
index af51c01..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IArrayBeanProxy.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IArrayBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Proxy wrappering an array.
- */
-public interface IArrayBeanProxy extends IBeanProxy {
-	/**
-	 * Get the object at the specified index.
-	 */
-	IBeanProxy get(int index) throws ThrowableProxy;
-
-	IBeanProxy getCatchThrowableException(int index);
-	
-	/**
-	 * Get the object at the specified multi-dimensional index.
-	 * The array must be at least the number of dimensions specified,
-	 * and each index along the way must exist.
-	 * The number of dimensions can't be greater than the number
-	 * of dimensions of the real object.
-	 */
-	IBeanProxy get(int [] indexes) throws ThrowableProxy; 
-	
-	/**
-	 * Get a snapshot of the array. It will return an array of proxies of the
-	 * complete first dimension of the array. This is useful if you need
-	 * to be working with more than one entry of the array. You can save
-	 * accesses to the vm by doing this. 
-	 * <p>
-	 * NOTE: This is a snapshot. It will not see changes to the array.
-	 * If an entry is set into the returned array of proxies, this will
-	 * not be reflected into the real array. Also any changes in the
-	 * contents of the first dimension of the real array will not
-	 * be reflected into this returned array of proxies. The proxies
-	 * returned are real proxies, so any changes to them will be reflected
-	 * back and forth. Treat this as an array copy to a new array.
-	 * 
-	 * @return array of proxies of the first dimension of the array.
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.1.0
-	 */
-	IBeanProxy[] getSnapshot() throws ThrowableProxy;
-	
-	/**
-	 * Set the object at the specified index.
-	 */
-	void set(IBeanProxy value, int index) throws ThrowableProxy;
-	
-	/**
-	 * Set the object at the specified multi-dimensional index.
-	 * The array must be at least the number of dimensions specified,
-	 * and each index along the way must exist.
-	 * The number of dimensions can't be greater than the number
-	 * of dimensions of the real object.
-	 */
-	void set(IBeanProxy value, int [] indexes) throws ThrowableProxy;	 
-	
-	/**
-	 * Get the length of the first dimension of this array.
-	 * If there are multi-dimensions, you must get the appropriate
-	 * dimension from the get method to see the size of that dimension.
-	 *
-	 * e.g.
-	 *    int [3] returns 3
-	 *    int [3][2] returns 3
-	 *
-	 *    ((IArrayBeanProxy) get(1)).getLength() returns 2
-	 *    Since arrays do not have to be homogenous, there could
-	 *    be a different length array for each of the arrays 
-	 *    returned from the first dimension, the returned length
-	 *    from get(2) and get(3) could result in a different value
-	 *    from get(1).
-	 */
-	int getLength();
-
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IArrayBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IArrayBeanTypeProxy.java
deleted file mode 100644
index dbae633..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IArrayBeanTypeProxy.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IArrayBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * A Proxy for an array type.
- */
-
-public interface IArrayBeanTypeProxy extends IBeanTypeProxy {
-	/**
-	 * getComponentType: Get the component type of this array.
-	 * e.g. (new Object[3]).getClass().getComponentType() will
-	 * return "java.lang.Object".
-	 * and (new Object[3][2][1]).getClass().getComponentType() will
-	 * return "Object[][]";
-	 */
-	public IBeanTypeProxy getComponentType();
-	/**
-	 * Return the final type, i.e. the final non-array type.
-	 * i.e. int[][] will return int.
-	 */
-	public IBeanTypeProxy getFinalComponentType();	
-	/**
-	 * Return the number of dimensions for this type.
-	 * i.e. int [][] will return 2.
-	 */
-	public int getDimensions();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanProxy.java
deleted file mode 100644
index 40f46e4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanProxy.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * Bean Proxy interface. This is the
- * root interface for any bean proxy instance.
- * Creation date: (12/3/99 11:37:01 AM)
- * @author: Joe Winchester
- */
-public interface IBeanProxy extends IProxy {
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject);
-
-/**
- * Test for identity among this bean proxy and the other bean proxy.
- * For some proxy systems, this may be redundent and you can be assured
- * that if the objects being proxied are identical you will receive the
- * same proxy for both. However, other implementations may not have this
- * condition. Therefor this method was created.
- * 
- * There is one restriction, constants may not necessarily be identical.
- * For instance, in some implementations, the Boolean proxy (i.e. an instance of class Boolean) is a constant, i.e. 
- * it cannot be changed. In those cases a new proxy may be created for each
- * access and so they will not be considered to be identical. In those cases false will be returned.
- * But in other implementations a new proxy will not be created and so sameAs will return true. 
- * 
- * Primitives will return true if just equal because in Java primitives are identical if the same value.
- * 
- * @param aBeanProxy
- * @return true if they are identical (i.e. ==) and not just equals.
- */
-public boolean sameAs(IBeanProxy aBeanProxy);
-  
-/**
- * Return the registry this proxy was created with.
- */
-public ProxyFactoryRegistry getProxyFactoryRegistry();
-/**
- * Return the proxied class of the bean
- * Creation date: (12/3/99 11:37:01 AM)
- * @author: Joe Winchester
- */
-public IBeanTypeProxy getTypeProxy();
-
-/**
- * Return a string representation of the bean itself
- * This could be done by finding the toString() method by a findMethod()
- * on the type proxy, etc... but toString() is so ubiquitous that it is
- * explicitly declared on the IBeanProxy interface
- * Creation date: (12/3/99 11:37:01 AM)
- * @author: Joe Winchester
- */
-public String toBeanString();
-/**
- * Is this bean still valid? It could be invalid because it
- * was specifically released but someone is still holding onto it.
- */
-public boolean isValid();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanProxyFactory.java
deleted file mode 100644
index 76baa4c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanProxyFactory.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IBeanProxyFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Bean Proxy Factory for creating bean proxies.
- * Creation methods are actually package protected.
- * All creation is done through the IBeanTypeProxy.
- * Specific factories may have helper methods that
- * allow creation of specific types, such as the
- * standard factory allows creation of Boolean, int's, etc.
- * Creation date: (12/3/99 11:52:09 AM)
- * @author: Joe Winchester
- */
-public interface IBeanProxyFactory {
-	/**
-	 * The factory is being terminated.
-	 * <p>
-	 * It should clean up its resources.
-	 * It should not reference any other factory because they could of
-	 * already been terminated.
-	 * <p>
-	 * For example, if it is holding onto IREMBeanProxy's, it doesn't
-	 * need to call release on them except if they are constants because
-	 * the BeanProxyFactory has all non-constant bean proxies registered
-	 * and will call the release itself.
-	 * <p>
-	 * Note: This is not meant to be called by users. It will be called internally by the proxy registry when necessary.
-	 * 
-	 * @param wait <code>true</code> should wait for completion, <code>false</code> don't necessarily wait. False is just
-	 * a suggestion. The factory may not permit not waiting. True must be honoured and it must wait.
-	 * 
-	 * @since 1.0.2
-	 */
-	public void terminateFactory(boolean wait); 
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeExpressionProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeExpressionProxy.java
deleted file mode 100644
index 2726d05..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeExpressionProxy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IBeanTypeExpressionProxy.java,v $
- *  $Revision: 1.1 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * An internal interface for the registries to create the appropriate beantype expression proxy.
- * Not to be implemented or referenced by customers.
- * @since 1.1.0
- */
-public interface IBeanTypeExpressionProxy extends IProxyBeanType {
-
-	/**
-	 * Allow the expression to set the type name.
-	 * @param typeName
-	 * 
-	 * @since 1.1.0
-	 */
-	public void setTypeName(String typeName);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeProxy.java
deleted file mode 100644
index da65767..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeProxy.java
+++ /dev/null
@@ -1,318 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IBeanTypeProxy.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:06 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;
-
-/**
- * A proxy for a BeanType (i.e. Java type/class). Creation date: (12/3/99 11:38:06 AM)
- * 
- * @author: Joe Winchester
- */
-public interface IBeanTypeProxy extends IBeanProxy, IProxyBeanType {
-	
-	/**
-	 * Find the most compatible constructor (out of the declared constructors). This means it will
-	 * find either an exact match or an override that is compatible, e.g. X(Object j) is returned when looking with arg type of "java.lang.String".
-	 * @param argumentTypes array of arg types or <code>null</code> if none. (In case of null, this is the default ctor, so just use that).
-	 * @return
-	 * @throws NoSuchMethodException
-	 * @throws AmbiguousMethodException
-	 * 
-	 * @since 1.1.0
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) throws AmbiguousMethodException, NoSuchMethodException;
-	
-	/**
-	 * Find the most compatible public method, including inheritied. This means it will
-	 * find either an exact match or an override that is compatible, e.g. xyz(Object j) is returned when looking with arg type of "java.lang.String".
-	 * @param methodName
-	 * @param argumentTypes array of arg types or <code>null</code> if none. (In case of null, just use getMethod(String methodName) since only one is compatible then.
-	 * @return
-	 * @throws AmbiguousMethodException
-	 * @throws NoSuchMethodException
-	 * 
-	 * @since 1.1.0
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes)  throws AmbiguousMethodException, NoSuchMethodException;
-
-	/**
-	 * Return the constructor proxy on the receiver with the specified arguments Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames);
-
-	/**
-	 * Return the constructor proxy on the receiver with the specified types Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes);
-	
-	/**
-	 * Return an array of public constructors for this class. 
-	 * 
-	 * @return an array of constructor proxies or <code>null</code> if an error.
-	 * 
-	 * @since 1.1.0
-	 */
-	public IConstructorProxy[] getConstructors();
-
-	/**
-	 * Return the declared constructor proxy on the receiver with the specified arguments Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames);
-
-	/**
-	 * Return the declared constructor proxy on the receiver with the specified types Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes);
-
-	/**
-	 * Return an array of declared constructors for this class. 
-	 * 
-	 * @return an array of constructor proxies or <code>null</code> if an error.
-	 * 
-	 * @since 1.1.0
-	 */
-	public IConstructorProxy[] getDeclaredConstructors();
-
-	/**
-	 * Return the array of field proxies.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IFieldProxy[] getFields();
-
-	/**
-	 * Return the array of declared field proxies.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IFieldProxy[] getDeclaredFields();
-
-	/**
-	 * Return the fieldproxy on the receiver with the specified name Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IFieldProxy getFieldProxy(String fieldName);
-
-	/**
-	 * Return the declared fieldproxy on the receiver with the specified name
-	 */
-	public IFieldProxy getDeclaredFieldProxy(String fieldName);
-
-	/**
-	 * Return the method proxy on the receiver with the specified name and no arguments.
-	 * 
-	 * @param methodName
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IMethodProxy getMethodProxy(String methodName);
-
-	/**
-	 * Return the method proxy on the receiver with the qualified class names as string arguments
-	 * 
-	 * @param methodName
-	 * @param argumentClassNames
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames);
-
-	/**
-	 * Return the method proxy on the receiver with the specified name and one argument
-	 * 
-	 * @param methodName
-	 * @param argumentClassName
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String argumentClassName);
-
-	/**
-	 * Return the method proxy on the receiver with the beanTypes as arguments
-	 * 
-	 * @param methodName
-	 * @param argumentTypes
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes);
-
-	/**
-	 * Return an array of public methods for this class. 
-	 * 
-	 * @return an array of method proxies or <code>null</code> if an error.
-	 * 
-	 * @since 1.1.0
-	 */
-	public IMethodProxy[] getMethods();
-
-	/**
-	 * Return the declared method proxy on the receiver with the specified arguments Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames);
-
-	/**
-	 * Return the declared method proxy on the receiver with the specified types Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes);
-
-	/**
-	 * Return an array of declared methods for this class. 
-	 * 
-	 * @return an array of method proxies or <code>null</code> if an error.
-	 * 
-	 * @since 1.1.0
-	 */
-	public IMethodProxy[] getDeclaredMethods();
-
-	/**
-	 * Return the invokable on the receiver with the specified name and no arguments.
-	 * <p>
-	 * The method proxy is not retrieved. Instead the method will be looked up
-	 * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should
-	 * be retrieved instead.
-	 * <p>
-	 * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise
-	 * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy.
-	 * <p>
-	 * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done.
-	 * 
-	 * @param methodName
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IInvokable getInvokable(String methodName);
-
-	/**
-	 * Return the method proxy on the receiver with the qualified class names as string arguments
-	 * <p>
-	 * The method proxy is not retrieved. Instead the method will be looked up
-	 * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should
-	 * be retrieved instead.
-	 * <p>
-	 * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise
-	 * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy.
-	 * <p>
-	 * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done.
-	 * 
-	 * @param methodName
-	 * @param argumentClassNames
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IInvokable getInvokable(String methodName, String[] argumentClassNames);
-
-	/**
-	 * Return the method proxy on the receiver with the specified name and one argument
-	 * <p>
-	 * The method proxy is not retrieved. Instead the method will be looked up
-	 * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should
-	 * be retrieved instead.
-	 * <p>
-	 * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise
-	 * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy.
-	 * <p>
-	 * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done.
-	 * 
-	 * @param methodName
-	 * @param argumentClassName
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IInvokable getInvokable(String methodName, String argumentClassName);
-
-	/**
-	 * Return the method proxy on the receiver with the beanTypes as arguments
-	 * <p>
-	 * The method proxy is not retrieved. Instead the method will be looked up
-	 * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should
-	 * be retrieved instead.
-	 * <p>
-	 * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise
-	 * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy.
-	 * <p>
-	 * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done.
-	 * 
-	 * @param methodName
-	 * @param argumentTypes
-	 * @return 
-	 * @since 1.0.0
-	 */
-	public IInvokable getInvokable(String methodName, IBeanTypeProxy[] argumentTypes);
-	
-	/**
-	 * Return the constructor proxy on the receiver with no arguments Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IConstructorProxy getNullConstructorProxy();
-
-	/**
-	 * Answer the type proxy for the superclass Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IBeanTypeProxy getSuperBeanTypeProxy();
-
-	/**
-	 * Answer the name of the type we are proxying This is the fully qualified name. For arrays it will return the format: [Lclassname; Creation date:
-	 * (12/3/99 2:25:07 PM)
-	 */
-	public String getTypeName();
-
-	/**
-	 * Answer the formal format type name. For normal classes, this just the same as getTypeName(), but for arrays, it is of the format classname[]
-	 */
-	public String getFormalTypeName();
-
-	/**
-	 * Answer a boolean as to whether we are an array type.
-	 */
-	public boolean isArray();
-
-	/**
-	 * Answer a boolean as to whether we are a type or an interface Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public boolean isInterface();
-
-	/**
-	 * Answer a boolean as to whether we are a primitive or not.
-	 */
-	public boolean isPrimitive();
-
-	/**
-	 * Answer a boolean as to whether we are a kind of the argument We can either be it, inherit from it, or implement it
-	 */
-	public boolean isKindOf(IBeanTypeProxy aBeanProxyType);
-
-	/**
-	 * Return a new instance Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IBeanProxy newInstance() throws ThrowableProxy;
-
-	/**
-	 * Return a new instance of this type using the initialization string to create the proxy. ClassCastException is thrown if the initstring doesn't
-	 * result in an object compatible with this type. InstantiationException is thrown when the initialization string cannot be parsed correctly.
-	 * Creation date: (12/3/99 2:25:07 PM)
-	 */
-	public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException;
-
-	/**
-	 * Return the exception message that happened when trying to find this bean type. Class not found is not such an exception. In that case the bean
-	 * type will be returned as a null instead. An example of such is an initialization error during loading the class, i.e. it was found but some
-	 * static failed to initialize.
-	 * 
-	 * Return null if there is no initialization error.
-	 */
-	public String getInitializationError();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeProxyFactory.java
deleted file mode 100644
index 899faf1..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IBeanTypeProxyFactory.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Factory for creating BeanTypeProxy's.
- * This is a common tag interface so that
- * the factory can be registered. But each
- * VM requires a different interface that
- * extends this interface. That extended
- * interface is what must be implemented in
- * each VM.
- * Creation date: (12/3/99 2:26:00 PM)
- * @author: Joe Winchester
- */
-public interface IBeanTypeProxyFactory extends IBeanProxyFactory {
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBooleanBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBooleanBeanProxy.java
deleted file mode 100644
index 113781a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IBooleanBeanProxy.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IBooleanBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Optimized implementation that should be used for Boolean proxies that
- * allows the IDE VM to get the boolean value easily
- * Creation date: (2/6/00 8:58:22 AM)
- * @author: Joe Winchester
- */
-public interface IBooleanBeanProxy extends IBeanProxy {
-/**
- * Return the proxied boolean as a boolean that the IDE can use
- * Creation date: (2/6/00 8:58:32 AM)
- */
-boolean booleanValue();
-Boolean getBooleanValue();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICallback.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICallback.java
deleted file mode 100644
index ae994a9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICallback.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ICallback.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-import java.io.InputStream;
-
-/**
- * Users will create a callback of this interface
- * and register it with the factory. Then when ever
- * the callback occurs, this callback will be called
- * with data from the proxy. It can return a value too.
- *
- * Or an InputStream can be returned to supply the data.
- *  
- * @since 1.0.0
- */
-public interface ICallback {
-
-	/**
-	 * This is the entry point of the callback.
-	 * It will be called whenever the callback
-	 * occurred. It will be on its own thread.
-	 * A particular thread cannot be requested.
-	 * <p>
-	 * The implementation MUST return. This is 
-	 * because the callback will not be completed
-	 * until it is returned, and the process will
-	 * not continue on the remote vm until it is
-	 * returned.
-	 * <p>
-	 * The value returned must either be an
-	 * IBeanProxy or IBeanProxy[]. It is typed
-	 * to Object to allow either one, but it
-	 * will be checked, and if it isn't, then
-	 * null will be returned instead to the
-	 * caller.
-	 * 
-	 * @param msgID
-	 * @param parm The beanproxy - will not be null
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public Object calledBack(int msgID, IBeanProxy parm);
-
-	/**
-	 * This is the entry point of the callback.
-	 * It will be called whenever the callback
-	 * occurred. It will be on its own thread.
-	 * A particular thread cannot be requested.
-	 * <p>
-	 * The parms will be an array of IBeanProxys,
-	 * or an entry could be another array of IBeanProxys,
-	 * or null if null was sent to callBackWithParms.
-	 * The final component of any entry will be an
-	 * IBeanProxy. It is up to the developers to
-	 * agree on the format of the parms.
-	 * <p>
-	 * The implementation MUST return. This is 
-	 * because the callback will not be completed
-	 * until it is returned, and the process will
-	 * not continue on the remote vm until it is
-	 * returned.
-	 * <p>
-	 * The value returned must either be an
-	 * IBeanProxy or IBeanProxy[]. It is typed
-	 * to Object to allow either one, but it
-	 * will be checked, and if it isn't, then
-	 * null will be returned instead to the
-	 * caller.
-	 * 
-	 * @param msgID
-	 * @param parms
-	 * @return
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.common.ICallbackHandler#callbackWithParms(int, int, Object[])
-	 * @since 1.0.0
-	 */
-	public Object calledBack(int msgID, Object[] parms);
-	
-	/**
-	 * This is the entry point of the callback.
-	 * It will be called whenever the callback
-	 * occurred. It will be on its own thread.
-	 * A particular thread cannot be requested.
-	 * <p>
-	 * The parm will be an object. This occurs
-	 * if remote vm just wanted to send some objects.
-	 * They will not be proxies. It is recommended
-	 * that this be used only for small items. For
-	 * anything large, the callbackStream should be
-	 * used instead.
-	 * <p>
-	 * The implementation MUST return. This is 
-	 * because the callback will not be completed
-	 * until it is returned, and the process will
-	 * not continue on the remote vm until it is
-	 * returned.
-	 * <p>
-	 * The value returned must either be an
-	 * IBeanProxy or IBeanProxy[]. It is typed
-	 * to Object to allow either one, but it
-	 * will be checked, and if it isn't, then
-	 * null will be returned instead to the
-	 * caller.
-	 * 
-	 * @param msgID
-	 * @param parm The parm or <code>null</code> if null was sent.
-	 * @return
-	 * 
-	 * @see ICallback#calledBackStream(int, InputStream)
-	 * @since 1.0.0
-	 */
-	public Object calledBack(int msgID, Object parm);
-
-	/**
-	 * This is the entry point of the callback.
-	 * It will be called whenever the callback stream
-	 * occurred. It will be on its own thread.
-	 * A particular thread cannot be requested.
-	 * <p>
-	 * The callback should continue to read from the InputStream
-	 * until it returns -1 indicating no more data. The stream can
-	 * be closed. In that case the next time the remote vm wants to
-	 * send data it will first check that the stream has not been closed.
-	 * If it has, it will raise an exception on that side.
-	 * <p>
-	 * The implementation MUST return. This is 
-	 * because the callback will not be completed
-	 * until it is returned, and the process will
-	 * not continue on the remote vm until it is
-	 * returned.
-	 * 
-	 * @param msgID
-	 * @param is
-	 * 
-	 * @since 1.0.0
-	 */
-	public void calledBackStream(int msgID, InputStream is);	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICallbackRegistry.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICallbackRegistry.java
deleted file mode 100644
index 27b3a89..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICallbackRegistry.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ICallbackRegistry.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-/**
- * This is the registry for handling callbacks.
- * It is used to register and deregister callbacks.
- *
- * Callbacks are split into two parts:
- * 1) CallbackProxy. This is any proxy that implements the
- *    interface ICallback. (Or the
- *    equivalent one if not standard remote vm). This is the
- *    object which will actually submit the callback on the remote
- *    vm. For example, any kind of listener. It would implement
- *    both the ICallback and the appropriate listener interface.
- *    Then when it gets called as a listener, it will redirect the
- *    call to the remote vm callback handler to submit it to the
- *    proxy side.
- * 2) Callback. This is on this side and is the object that will
- *    be notified of the callback and will execute at that time.
- *
- */
-
-public interface ICallbackRegistry {
-	
-	/**
-	 * Register this callback proxy and this callback.
-	 *
-	 * The process is to:
-	 * 1) Create the callbackProxy and the callback
-	 * 2) register these with registerCallback
-	 * 3) Now connect the callbackProxy so that it will start notifying.
-	 *    For example, if it is a normal listener, at this time do the
-	 *    addListener call to add the callbackProxy to the appropriate object.
-	 *    You don't want it to start notifying before registering it.
-	 *    (Though it won't hust it, it will just return null).
-	 */
-	public void registerCallback(IBeanProxy callbackProxy, ICallback cb);
-	
-	/**
-	 * Same as {@link ICallbackRegistry#registerCallback(IBeanProxy, ICallback) registerCallback} except that
-	 * it is deferred off into an expression.
-	 *  
-	 * @param callbackProxy
-	 * @param cb
-	 * @param expression
-	 * 
-	 * @since 1.1.0
-	 */
-	public void registerCallback(IProxy callbackProxy, ICallback cb, IExpression expression);
-	
-	/**
-	 * Deregister the callback proxy. This will remove it from the
-	 * registry and release the callback.
-	 *
-	 * The process is to:
-	 * 1) Stop the proxy from listening so it no notifies. This is usually
-	 *    removeListener on the remote vm. You don't want it notifying
-	 *    after it deregister (though it won't hurt it, it will just return null).
-	 * 2) deregister it.
-	 */
-	public void deregisterCallback(IBeanProxy callbackProxy);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICharacterBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICharacterBeanProxy.java
deleted file mode 100644
index 96a6b46..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ICharacterBeanProxy.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ICharacterBeanProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Optimized implementation that should be used for character proxies that
- * allows the IDE VM to get the character value easily
- * Creation date: (2/6/00 8:58:22 AM)
- * @author: Joe Winchester
- */
-public interface ICharacterBeanProxy extends IBeanProxy, INumberBeanProxy {
-/**
- * Return the proxied character as a char that the IDE can use
- * Creation date: (2/6/00 8:58:32 AM)
- */
-char charValue();
-/**
- * Return the proxied character as a Character that the IDE can use
- * Creation date: (2/6/00 8:58:32 AM)
- */
-Character characterValue();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributionController.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributionController.java
deleted file mode 100644
index 2cab993..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributionController.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IConfigurationContributionController.java,v $
- *  $Revision: 1.11 $  $Date: 2005/10/26 18:48:19 $ 
- */
-
-import java.net.URL;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jdt.core.IJavaProject;
-import org.osgi.framework.Bundle;
-;
-/**
- * Controls contribution to the configuration. This allows the classpath
- * to be modified in an acceptable manner, so that duplicates aren't in
- * the path, or adding a project to the path in an acceptable way.
- * 
- * If only deleting or moving entries from the classpath, that can be done directly
- * to the classpath list passed in. Adding entries needs to go through this
- * controller.
- * 
- * This is meant to be implemented by developers of proxy launch configurations.
- * 
- * @version 	1.0
- * @author
- */
-public interface IConfigurationContributionController {
-	
-	/**
-	 * Append to the user classpath.
-	 */
-	public static final int APPEND_USER_CLASSPATH = 0;
-	
-	/**
-	 * Prepend to the user classpath. This will stick it in position 0. If
-	 * another prepend comes along, it will go in pos 0 and this one will move to 1.
-	 */
-	public static final int PREPEND_USER_CLASSPATH = 1;
-	
-
-	/**
-	 * Append to the boot classpath.
-	 */
-	public static final int APPEND_BOOT_CLASSPATH = 2;
-
-	/**
-	 * Prepend to the boot classpath.
-	 */
-	public static final int PREPEND_BOOT_CLASSPATH = 3;
-	
-	/**
-	 * Append a folder to the java.library.path (for things like
-	 * dll's). This should result in a folder only.
-	 * The nlsLocalize flag contribute via plugin will be
-	 * ignored for this type flag. 
-	 */
-	public static final int APPEND_JAVA_LIBRARY_PATH = 4;
-	
-	/**
-	 * Get the java project that we are contributing for.
-	 * 
-	 * @return javaproject, may be <code>null</code>
-	 * 
-	 * @since 1.0.0
-	 */
-	public IJavaProject getJavaProject();
-		
-	/**
-	 * Add a project to the classpath. The type flag tells where to add it.
-	 * 
-	 * @param project
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeProject(IProject project) throws CoreException;
-	
-	/**
-	 * Add an external file/folder to the classpath. The type flag tells where to add it.
-	 * 
-	 * @param classpath
-	 * @param typeFlag One of <code>APPEND_USER_CLASSPATH</code>, <code>APPEND_BOOT_CLASSPATH</code>, <code>PREPEND_BOOT_CLASSPATH</code>, or <code>APPEND_JAVA_LIBRARY_PATH</code>.
-	 * 
-	 * @deprecated use contributeClasspath(URL, int) instead.
-	 * @see #contributeClasspath(URL, int)
-	 * @since 1.0.0
-	 */
-	public void contributeClasspath(String classpath, int typeFlag);
-	
-	/**
-	 * Add an external file/folder to the classpath. The type flag tells where to add it.
-	 * 
-	 * @param classpathURL
-	 * @param typeFlag One of <code>APPEND_USER_CLASSPATH</code>, <code>APPEND_BOOT_CLASSPATH</code>, <code>PREPEND_BOOT_CLASSPATH</code>, or <code>APPEND_JAVA_LIBRARY_PATH</code>.
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeClasspath(URL classpathURL, int typeFlag);	
-	
-	/**
-	 * Add an external files/folders to the classpath. The type flag tells where to add it.
-	 * 
-	 * @param classpaths
-	 * @param typeFlag One of <code>APPEND_USER_CLASSPATH</code>, <code>APPEND_BOOT_CLASSPATH</code>, <code>PREPEND_BOOT_CLASSPATH</code>, or <code>APPEND_JAVA_LIBRARY_PATH</code>.
-	 * 
-	 * @deprecated use contributeClasspath(URL[], int) instead.
-	 * @see #contributeClasspath(URL[], int)
-	 * @since 1.0.0
-	 */
-	public void contributeClasspath(String[] classpaths, int typeFlag);	
-
-	/**
-	 * Add an external files/folders to the classpath. The type flag tells where to add it.
-	 * 
-	 * @param classpathURLs
-	 * @param typeFlag One of <code>APPEND_USER_CLASSPATH</code>, <code>APPEND_BOOT_CLASSPATH</code>, <code>PREPEND_BOOT_CLASSPATH</code>, or <code>APPEND_JAVA_LIBRARY_PATH</code>.
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeClasspath(URL[] classpathURLs, int typeFlag);	
-	
-	/**
-	 * Add a file/folder from a plugin in the running Eclipse to the classpath. The type flag tells where to add it.
-	 * In development mode it will find the bin class files instead if proxy.jars is setup correctly.
-	 * <p>
-	 * If nlsLocalize is <code>true</code>, then it will also search through the fragments in this manner:
-	 * (Note: if <code>false</code> it will still search in the fragments, but it will only return the first file found that matches.
-	 * <p>
-	 * Find in the plugin and all of the fragments those that match the name exactly
-	 * <p>
-	 * This is useful for nls where the nls for the filename will be in one or more of the fragments of the plugin.	 	 
-	 * 
-	 * @param bundle The bundle it can be found in.
-	 * @param relativePath Path to file/folder relative to bundle root. Or <code>null</code> if it is the bundle/fragment itself (for when the bundle has been jar'ed up). 
-	 *   <b>Note: </b>If it is <code>APPEND_JAVA_LIBRARY_PATH</code>, it should be folder and nlsLocalize will be ignored.
-	 *   In this case be careful that if a folder and the plugin is jarred that the folder <b>IS NOT THE ROOT OF THE PLUGIN</b>. This will
-	 *   cause the entire plugin to be extracted instead of just the directory containing the libraries. If the libraries are in the root
-	 *   of a jarred plugin then a separate cache directory should be created instead and the libraries of interest extracted to there. And
-	 *   then point to the cache directory instead.
-	 * @param typeFlag One of <code>APPEND_USER_CLASSPATH</code>, <code>APPEND_BOOT_CLASSPATH</code>, <code>PREPEND_BOOT_CLASSPATH</code>, or <code>APPEND_JAVA_LIBRARY_PATH</code>.
-	 * @param nlsLocalize The usual value should be <code>false</code>. Use <code>true</code> if should look through fragments to gather them all as described in this methods description. This will work for jarred bundles/fragments too.
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeClasspath(Bundle bundle, String relativePath, int typeFlag, boolean nlsLocalize);	
-	
-	/**
-	 * Same as {@link #contributeClasspath(Bundle, String, int, boolean)} except an IPath can be used as the relative path.
-	 * 
-	 * @param bundle
-	 * @param relativePath path to file within bundle. Or <code>null</code> if it is the bundle/fragment itself (for when the bundle has been jar'ed up).
-	 * @param typeFlag
-	 * @param nlsLocalize
-	 * 
-	 * @see #contributeClasspath(Bundle, String, int, boolean)
-	 * @since 1.0.0
-	 */
-	public void contributeClasspath(Bundle bundle, IPath relativePath, int typeFlag, boolean nlsLocalize);	
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributionInfo.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributionInfo.java
deleted file mode 100644
index 9920d7c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributionInfo.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IConfigurationContributionInfo.java,v $
- *  $Revision: 1.4 $  $Date: 2005/10/14 17:45:02 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.util.Map;
-
-import org.eclipse.jdt.core.IJavaProject;
- 
-/**
- * This interface will be passed to the IConfigurationContributor initialize method. It has info
- * that may be needed by the contributor. It may be saved for later use, but if classpaths have changed,
- * it won't be kept up to date.
- * <p>
- * This interface is not intended to be implemented by clients.
- * </p>
- * 
- * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributor#initialize(IConfigurationContributionInfo)
- * @since 1.0.0
- */
-public interface IConfigurationContributionInfo {
-	
-	/**
-	 * Hold the visible and hidden container paths. 
-	 * A visible container path means it has been exported up to the top-level project. And also
-	 * the array of those not visible. The paths are the String form (i.e. IPath.toString()).
-	 * <p>
-	 * These are the values of the {@link IConfigurationContributionInfo#getContainerIds()} map.
-	 * 
-	 * @since 1.2.0
-	 */
-	public static class ContainerPaths {
-		
-		private final String[] visiblePath;
-		private final String[] hiddenPaths;
-		private final String containerId;
-	
-		ContainerPaths(String containerId, String[] visiblePath, String[] hiddenPaths) {
-			// Not meant to be subclassed or constructed by clients.
-			this.containerId = containerId;
-			this.visiblePath = visiblePath;
-			this.hiddenPaths = hiddenPaths;
-		}
-		
-		
-		/**
-		 * @return Returns the containerId.
-		 * 
-		 * @since 1.2.0
-		 */
-		public final String getContainerId() {
-			return containerId;
-		}
-		
-		/**
-		 * Array of visible container paths. A path is visible if it is exported up to and can
-		 * see by the top-level project.
-		 * 
-		 * @return
-		 * 
-		 * @since 1.2.0
-		 */
-		public final String[] getVisibleContainerPaths() {
-			return visiblePath;
-		}
-		
-		/**
-		 * Array of hidden container paths. A path is hidden if it is not exported up to and cannot
-		 * see by the top-level project.
-		 * 
-		 * @return
-		 * 
-		 * @since 1.2.0
-		 */
-		public final String[] getHiddenContainerPaths() {
-			return hiddenPaths;
-		}
-		
-		/**
-		 * Get all of the paths together, both visible and hidden.
-		 * @return
-		 * 
-		 * @since 1.2.0
-		 */
-		public String[] getAllPaths() {
-			String[] allPaths = new String[visiblePath.length+hiddenPaths.length];
-			System.arraycopy(visiblePath, 0, allPaths, 0, visiblePath.length);
-			System.arraycopy(hiddenPaths, 0, allPaths, visiblePath.length, hiddenPaths.length);
-			return allPaths;
-		}
-	}
-
-	/**
-	 * Get the java project that we are contributing for.
-	 * 
-	 * @return javaproject, may be <code>null</code>
-	 * 
-	 * @since 1.0.0
-	 */
-	public IJavaProject getJavaProject();
-	
-	/**
-	 * Return the map of containers (the key) that are found in the classpath. This is useful for determining
-	 * if the container impliments a contributor interface.
-	 * <p>
-	 * Value will be {@link ContainerPaths}
-	 * 
-	 * @return Map of containers. Keys of type String for container id (e.g. "SWT_CONTAINER" for a container classpath of "/SWT_CONTAINER/PDE/xyz".
-	 * 	Values will be {@link ContainerPaths} Empty if launch not in a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public Map getContainers();
-	
-	/**
-	 * Return the map of container ids that are found in the classpath.
-	 * <p>
-	 * Key will be String and it is the first segment of a container path. Value will {@link ContainerPaths}. This
-	 * will contain all of the visible and hidden paths that the project can see. All of the paths will have
-	 * the key (container id) as the first segment of the path.
-	 * 
-	 * @return map of container ids. Keys of type String. Values will be {@link ContainerPaths} Empty if launch not in a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public Map getContainerIds();
-	
-	/**
-	 * Return the map of plugin ids (the key) that are found in the classpath.
-	 * <p>
-	 * Value will <code>Boolean</code> and will be true if plugin was visible to top-level project.
-	 * 
-	 * @return map of plugin ids. Key of type String. Empty if launch not in a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public Map getPluginIds();	
-	
-	/**
-	 * Return the map of project paths (the key) that are found in the classpath. The top-level project
-	 * will NOT be in this list since it is assumed to be visible to itself.
-	 * <p>
-	 * Value will <code>Boolean</code> and will be true if project was visible to top-level project.
-	 * 
-	 * @return map of project paths. Key of type <code>IPath</code>. Empty if launch not in a project.
-	 * 
-	 * @see org.eclipse.core.runtime.IPath
-	 * @since 1.0.0
-	 */
-	public Map getProjectPaths();
-	
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributor.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributor.java
deleted file mode 100644
index aceb0ca..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConfigurationContributor.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IConfigurationContributor.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
-
-
-/**
- * This interface is used to contribute to the configuration that will be
- * used to start a proxy registry. 
- * 
- * @since 1.0.0
- */
-public interface IConfigurationContributor {
-	
-	/**
-	 * Called first before any of the other calls. This can be used to do any internal initializations
-	 * required by the other calls. That way the other calls can have the order changed as the implementation
-	 * requires.
-	 * <p>
-	 * NOTE: For those who nest configuration contributors (i.e. within an implementation of a contributor, more
-	 * contributors are discovered) then it is imperitive that when those contributors are discovered that this method
-	 * be called on them too. This is necessary so the contract with contributors can be followed. It is best if the
-	 * discoveries are actually done in the initialize method itself so that it can pass the launch info right there.
-	 * 
-	 * @param info info contains things like containers visible, etc.
-	 * 
-	 * @see IConfigurationContributionInfo
-	 * @since 1.0.0
-	 */
-	public void initialize(IConfigurationContributionInfo info);
-	
-	/**
-	 * Contribute to the classpath. The controller is used to do the actual contribution.
-	 * 
-	 * @param controller
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeClasspaths(IConfigurationContributionController controller) throws CoreException;
-
-	/**
-	 * Contribute updates to the configuration. It will be called before the launch has started.
-	 * 
-	 * @param config
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeToConfiguration(ILaunchConfigurationWorkingCopy config) throws CoreException;
-	
-	/**
-	 * Contribute to the registry (or interact with the remote vm) after the registry has been
-	 * created.
-	 * 
-	 * @param registry
-	 * 
-	 * @since 1.0.0
-	 */
-	public void contributeToRegistry(ProxyFactoryRegistry registry);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConstructorProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConstructorProxy.java
deleted file mode 100644
index 1294e18..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IConstructorProxy.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IConstructorProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * This is a proxy that allows a constructor to exist in the target VM
- * and be referenced in the IDE VM
- * Creation date: (1/17/00 1:21:52 PM)
- * @author: Joe Winchester
- */
-public interface IConstructorProxy extends IAccessibleObjectProxy {
-/**
- * Return a new instance with no creation arguments,
- * i.e. for a null constructor
- * Creation date: (1/17/00 1:22:11 PM)
- */
-IBeanProxy newInstance() throws ThrowableProxy;
-/**
- * Return a new instance with the specified creation arguments
- * Creation date: (1/17/00 1:22:11 PM)
- */
-IBeanProxy newInstance(IBeanProxy[] creationArguments) throws ThrowableProxy;
-
-IBeanProxy newInstanceCatchThrowableExceptions();
-IBeanProxy newInstanceCatchThrowableExceptions(IBeanProxy[] creationArguments);
-
-IBeanTypeProxy[] getParameterTypes();
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IDimensionBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IDimensionBeanProxy.java
deleted file mode 100644
index 33030b9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IDimensionBeanProxy.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IDimensionBeanProxy.java,v $
- *  $Revision: 1.2 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-
-/**
- * Interface to a Dimension bean proxy.
- * <p>
- * These are common for different windowing systems, e.g. AWT and SWT. So this here
- * is common interface for them.
- * Creation date: (4/7/00 3:46:39 PM)
- * @author: Administrator
- */
-public interface IDimensionBeanProxy extends IBeanProxy {
-	public int getHeight();
-	public int getWidth();
-	public void setHeight(int height);
-	public void setWidth(int width);
-	public void setSize(int width, int height);
-	public void setSize(IDimensionBeanProxy dim);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IExpression.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IExpression.java
deleted file mode 100644
index 396adf1..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IExpression.java
+++ /dev/null
@@ -1,1009 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IExpression.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.jem.internal.proxy.initParser.tree.*;
-import org.eclipse.jem.internal.proxy.initParser.tree.IExpressionConstants;
-import org.eclipse.jem.internal.proxy.initParser.tree.NoExpressionValueException;
- 
-/**
- * This is an expression. It will be evaluated on the other side. The difference between an
- * expression and using IMethodProxy's, IConstructorProxy's, etc. is the granularity. The proxies
- * are one round-trip to the other side for each access or execution. The expression builds them up
- * and will execute them all at once on the other side. Another difference is that the reflection
- * will be done on the other side too. For instance when invoking a method, the method name is
- * passed into the expression as a string then reflected and then invoked, while with method
- * proxies, the string is used to find the proxy on the other side, and then a later round-trip
- * will be used to invoke it.
- * <p>
- * Also an expression is a one-time use object. It can't be reused a second time. A new one must be
- * built up again.
- * <p>
- * We are not using separate instances of expressions, and types of expressions, because we don't
- * want to build up many objects (in a form of an expression tree) that will then be thrown away
- * (one for each expression in the nested list of expressions). We just build the command list as
- * we build the expression.
- * <p>
- * To use, you call the IStandardBeanProxyFactory's createExpression method. An IExpression is
- * returned. From there you will start creating the contents of the expression. And then you will
- * finally either getExpressionValue() to get the final value of the expression, or use
- * invokeExpression() to just execute the expression(s). If you use getExpressionValue(), there can
- * only be one root expression. If you use invokeExpression there can be more than one root
- * expression, and they will all be executed.
- * <p>
- * Since sequence is so important, it will be tested and if anything is done out of order an
- * IllegalStateException will be thrown.
- * <p>
- * Each time an expression is created, one argument passed in will be <code>forExpression</code> flag.
- * This is a set of constants used as a clue for what expression this expression is being created.
- * This is for a sanity check on the state. For example, when creating the array expression for an
- * array access, the ARRAYACCESS_ARRAY flag is passed in. This way if the current expression on the
- * stack is not for an array access waiting for the array expression, an IllegalStateException will be thrown.
- * Without this flag, it would be easy to accidently create the wrong expression at the wrong time.
- * Once such an error occurs, this IExpression will no longer be valid. IllegalStateException will be thrown
- * for any type of access.
- * <p>
- * It is guarenteed that the entire stack of commands will be sent without stopping except for IllegalStateException
- * due to out of order expressions.
- * <p>
- * <b>Note:</b> This interface is not meant to be neither instantiated nor implemented by customers.
- * It is the interface into the expression processing. It is to be instantiated through the createExpression request.
- * The {@link org.eclipse.jem.internal.proxy.core.Expression} class is available as API. It is not meant to
- * be instantiated by customers, but customers can take the IExpression and cast to Expression for some advanced
- * API.
- *  
- * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createExpression()
- * @see java.lang.IllegalStateException
- * @since 1.0.0
- */
-public interface IExpression extends IExpressionConstants {
-	
-	/**
-	 * Return the registry this expression is working against.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public ProxyFactoryRegistry getRegistry();
-	
-	/**
-	 * Invoke the expression(s). If there is more than one root expression, it will invoke them
-	 * in the order created. If the expression stack is not complete, then <code>IllegalStateException</code>
-	 * will be thrown.
-	 * 
-	 * @throws ThrowableProxy
-	 * @throws IllegalStateException
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void invokeExpression() throws ThrowableProxy, NoExpressionValueException, IllegalStateException;
-	
-	/**
-	 * Return whether the expression is valid. It would be invalid if any of the create... calls had thrown an
-	 * exception or if the expression has already been evaluated (invoked or getExpressionValue()).
-	 * 
-	 * @return <code>true</code> if expression is valid, <code>false</code> if there had been some error, or if the expression has already been evaluated.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isValid();
-	
-	/**
-	 * Close the expression. This needs to be called if for some reason {@link IExpression#invokeExpression()} or {@link IExpression#getExpressionValue()}
-	 * were not called. It is not an error to always call this after these calls. It will not have any problems with the expression already
-	 * being closed. invoke and getvalue automatically call close for you. If you don't call close in case of an error, the resources
-	 * for the expression will not be freed up. 
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	public void close();
-	
-	/**
-	 * Invoke the root expression and return the value of the expression. If the expression stack
-	 * is not complete, or if there is more than one root expression, then <code>IllegalStateException</code>
-	 * will be thrown.
-	 * 
-	 * @return The value of the root expression. 
-	 * 
-	 * @throws ThrowableProxy
-	 * @throws IllegalStateException
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	public IBeanProxy getExpressionValue() throws ThrowableProxy, NoExpressionValueException, IllegalStateException;
-			
-	/**
-	 * Create an Array Access (e.g. x[3]).
-	 * This must be followed by create expressions for:
-	 * <pre>
-	 *  <code>ARRAYACCESS_ARRAY</code>
-	 *  <code>ARRAYACCESS_INDEX</code> an indexCount times. 
-	 * </pre>
-	 * <p>
-	 * So the array access must be followed by 1+indexCount expressions.
-	 * 
-	 * @param forExpression This is for what expression this expression is being created.
-	 * @param indexCount The number of index expressions that will be created.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createArrayAccess(ForExpression forExpression, int indexCount) throws IllegalStateException;
-	
-	/**
-	 * Create an Array Creation (e.g. <code>new int[3]</code> or <code>new int[3][]</code> or <code>new int[] {3, 4}</code>).
-	 * If <code>dimensionExpressionCount</code> is zero, then there must be an initializer. This is because
-	 * if there are any dimension expressions, then initializers are invalid and visa-versa.
-	 * <p>
-	 * The dimensionExpressionCount is for how many dimensions have an expression in them. For instance,
-	 * <code>new int[3]</code> will have a dimensionExpressionCount of 1. While
-	 * <code>new int[3][]</code> will also have count of 1. And finally
-	 * <code>new int []</code> will have a count of 0.
-	 * <p>
-	 * This must be followed by create expressions for:
-	 * <pre>
-	 *  <code>ARRAYCREATION_DIMENSION</code> a dimensionExpressionCount times, 
-	 *  or an <code>createArrayInitializer()</code> if dimension count is 0.
-	 * </pre>
-	 *  
-	 * @param forExpression
-	 * @param type This is the type. It must be fully-qualified and if an inner class, it must have the "$" format. It must also include the correct number of  <code>[]</code> at the end.
-	 * @param dimensionExpressionCount
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createArrayCreation(ForExpression forExpression, String type, int dimensionExpressionCount) throws IllegalStateException;
-
-	/**
-	 * Create an Array Creation (e.g. <code>new int[3]</code> or <code>new int[3][]</code> or <code>new int[] {3, 4}</code>).
-	 * If <code>dimensionExpressionCount</code> is zero, then there must be an initializer. This is because
-	 * if there are any dimension expressions, then initializers are invalid and visa-versa.
-	 * <p>
-	 * The dimensionExpressionCount is for how many dimensions have an expression in them. For instance,
-	 * <ol>
-	 * <li><code>new int[3]</code> will have a dimensionExpressionCount of 1. While
-	 * <li><code>new int[3][]</code> will also have count of 1. And finally
-	 * <li><code>new int []</code> will have a count of 0.
-	 * </ol>
-	 * The expressions that follow if dimensionExpressionCount is not zero must evaluate to be compatible to an int type (i.e. byte, char, short, or int).
-	 * Each expression will be used to create an array for that dimension of that size. For example <code>new int[3][]</code> will have an
-	 * dimension expression that evaluates to "3", and so it will create an array int[3][].
-	 * <p>
-	 * This must be followed by create expressions for:
-	 * 	dimensionExpressionCount times an: <code>ARRAYCREATION_DIMENSION</code>
-	 *  or an createArrayInitializer if dimension count is 0.
-	 *  
-	 * @param forExpression
-	 * @param type This is the type. This must be the actual type with the correct total number of dimensions (e.g. "java.lang.Object[][]").
-	 * @param dimensionExpressionCount number of int valued expressions that follow that give the size for each dimension.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createArrayCreation(ForExpression forExpression, IProxyBeanType type, int dimensionExpressionCount) throws IllegalStateException, IllegalArgumentException;
-	
-	/**
-	 * Create an array initializer. (e.g. <code>{2,3}</code>).
-	 * This one is unusual in that there is no forExpression. That is because array initializers are only valid in
-	 * certain places. And so if called when not expected, this is an IllegalStateException.
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	expressionCount times an: <code>ARRAYINITIALIZER_EXPRESSION</code>
-	 * 		except if the expression is another array initializer. That is valid and doesn't have a forExpression,
-	 * 		but it does count as one of the expressionCounts.
-	 * 
-	 * @param expressionCount Number of expressions, may be 0.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createArrayInitializer(int expressionCount) throws IllegalStateException;
-		
-	/**
-	 * Create a cast expression (e.g. <code>(short)10</code> or <code>(java.lang.String) "asd"</code>)
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	<code>CAST_EXPRESSION</code> 
-	 *  
-	 * @param forExpression
-	 * @param type This is the type. It must be fully-qualified and if an inner class, it must have the "$" format.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createCastExpression(ForExpression forExpression, String type) throws IllegalStateException;
-
-	/**
-	 * Create a cast expression (e.g. <code>(short)10</code> or <code>(java.lang.String) "asd"</code>)
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	<code>CAST_EXPRESSION</code> 
-	 *  
-	 * @param forExpression
-	 * @param type This is the type.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createCastExpression(ForExpression forExpression, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException;
-		
-	/**
-	 * Create a new class instance expression (e.g. <code>new java.lang.Integer(5)</code>)
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	argumentCount times an: <code>CLASSINSTANCECREATION_ARGUMENT</code>
-	 * 
-	 * <p>
-	 * <b>Note:</b> This method can throw {@link org.eclipse.jem.internal.proxy.common.UnresolvedCompilationError} while processing
-	 * and can be caught by an Expression try/catch. This is not thrown such that it can be caught by a real java try/catch.
-	 * 
-	 * @param forExpression
-	 * @param type This is the type. It must be fully-qualified and if an inner class, it must have the "$" format.
-	 * @param argumentCount
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createClassInstanceCreation(ForExpression forExpression, String type, int argumentCount) throws IllegalStateException;
-
-	/**
-	 * Create a new class instance expression (e.g. <code>new java.lang.Integer(5)</code>)
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	argumentCount times an: <code>CLASSINSTANCECREATION_ARGUMENT</code>
-	 * 
-	 * <p>
-	 * <b>Note:</b> This method can throw {@link org.eclipse.jem.internal.proxy.common.UnresolvedCompilationError} while processing
-	 * and can be caught by an Expression try/catch. This is not thrown such that it can be caught by a real java try/catch.
-	 * 
-	 * @param forExpression
-	 * @param type This is the type.
-	 * @param argumentCount
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createClassInstanceCreation(ForExpression forExpression, IProxyBeanType type, int argumentCount) throws IllegalStateException, IllegalArgumentException;
-	
-	/**
-	 * Create a conditional expression (e.g. <code>x != 3 ? 4 : 5</code>)
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	<code>CONDITIONAL_CONDITION</code>
-	 * 	<code>CONDITIONAL_TRUE</code>
-	 * 	<code>CONDITIONAL_FALSE</code>	
-	 * 
-	 * @param forExpression
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createConditionalExpression(ForExpression forExpression) throws IllegalStateException;
-	
-	/**
-	 * Create a field access (e.g. <code>java.awt.Color.red</code>)
-	 * <p>
-	 * Note: At this time we require a receiver. In the future it may be possible to not have one, but
-	 * for that we need a <code>this</code> object to know who the receiver implicitly is.
-	 * The receiver may be a "type receiver" if it is a type, e.g. <code>java.awt.Color</code>.
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * 	<code>FIELD_RECEIVER</code> if hasReceiver is <code>true</code>
-	 * 
-	 * @param forExpression
-	 * @param fieldName The name of the field.
-	 * @param hasReceiver Has a receiver flag. Currently this must always be true. This is because can't tell what class to look into for the field without a receiver.
-	 * @throws IllegalArgumentException
-	 * @throws IllegalStateException
-	 * 
-	 * @see IExpression#createTypeReceiver(String)
-	 * @since 1.0.0
-	 */
-	public void createFieldAccess(ForExpression forExpression, String fieldName, boolean hasReceiver) throws IllegalArgumentException, IllegalStateException;
-
-	/**
-	 * Create a field access (e.g. <code>java.awt.Color.red</code>)
-	 * <p>
-	 * Note: At this time we require a receiver for non-static access. In the future it may be possible to not have one, but
-	 * for that we need a <code>this</code> object to know who the receiver implicitly is.
-	 * The receiver may be a "type receiver" if it is a type, e.g. <code>java.awt.Color</code>.
-	 * <p>
-	 * This must be followed by createExpressions for:
-	 * <pre>
-	 * 	<code>FIELD_RECEIVER</code> if hasReceiver is <code>true</code>
-	 * </pre>
-	 * 
-	 * @param forExpression
-	 * @param fieldProxy The field proxy for the field.
-	 * @param hasReceiver Has a receiver flag.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @see IExpression#createTypeReceiver(String)
-	 * @since 1.0.0
-	 */
-	public void createFieldAccess(ForExpression forExpression, IProxyField fieldProxy, boolean hasReceiver) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * Create an if/else stmt. Since this is a statment, there is no ForExpression. ROOT_EXPRESSION must be the next expression type.
-	 * <p<
-	 * This must be followed by createExpressions for:
-	 * <pre>
-	 *   <code>IF_CONDITION</code> The if test, must return boolean.
-	 *   <code>IF_TRUE</code> The if condition is true clause. The clause may be an expression, or a block.
-	 *   <code>IF_ELSE</code>  if hasElseClause is <code>true</code>. The else clause. The clause may be an expression, or a block.
-	 * </pre>
-	 * 
-	 * @param hasElseClause
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createIfElse(boolean hasElseClause) throws IllegalStateException;
-	
-	/**
-	 * Create an infix expression (e.g. <code>3 + 4</code> or <code>3 + 4 + 5</code>).
-	 * <p>
-	 * If there are more than 2 operands (all with the same operator) then for convienence all of
-	 * the expression can be done in one expression than requiring several, one for each operator.
-	 * If they are different operators, then different expressions will be required.
-	 * <p>
-	 * <pre>
-	 * This must be followed by createExpressions for:
-	 * 	<code>INFIX_LEFT</code>
-	 * 	<code>INFIX_RIGHT</code>
-	 * 	extendedOperandCount times an: <code>INFIX_EXTENDED</code>
-	 * </pre>
-	 * 
-	 * @param forExpression
-	 * @param operator The operator.
-	 * @param extendedOperandCount The number of extended operands. May be zero.
-	 * @throws IllegalStateException
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.common.IExpressionConstants#IN_AND
-	 * @since 1.0.0
-	 */
-	public void createInfixExpression(ForExpression forExpression, InfixOperator operator, int extendedOperandCount) throws IllegalStateException;
-	
-	/**
-	 * Create an instanceof expression (e.g. <code>x instanceof java.lang.String</code>
-	 * <p>
-	 * This must be followed by createExpression for:
-	 * 	<code>INSTANCEOF_VALUE</code>
-	 * @param forExpression
-	 * @param type This is the type. It must be fully-qualified and if an inner class, it must have the "$" format.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createInstanceofExpression(ForExpression forExpression, String type) throws IllegalStateException;
-	
-	/**
-	 * Create an instanceof expression (e.g. <code>x instanceof java.lang.String</code>
-	 * <p>
-	 * This must be followed by createExpression for:
-	 * 	<code>INSTANCEOF_VALUE</code>
-	 * @param forExpression
-	 * @param type This is the type.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createInstanceofExpression(ForExpression forExpression, IProxyBeanType type) throws IllegalStateException, IllegalArgumentException;
-	
-	/**
-	 * Create a method invocation expression (e.g. <code>java.lang.String.valueOf(10)</code>).
-	 * When using a string the method invoked will be the one most compatible with the arguments sent. 
-	 * This allows overloading a method to occur when coming in from a parse tree, since the parse tree
-	 * doesn't know the exact method to use.
-	 * <p>
-	 * Note: At this time we require a receiver. In the future it may be possible to not have one, but
-	 * for that we need a <code>this</code> object to know who the receiver implicitly is.
-	 * The receiver may be a "type receiver" if it is a type, e.g. <code>java.awt.Color</code>.
-	 * <p>
-	 * This must be followed by createExpression for:
-	 * 	<code>METHOD_RECEIVER</code>
-	 * 	argumentCounts times expressions for: <code>METHOD_ARGUMENT</code>
-	 * 
-	 * @param forExpression
-	 * @param name The name of the method
-	 * @param hasReceiver Has a receiver flag. Currently this must always be true.
-	 * @param argumentCount Count of number of arguments. May be zero.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @see IExpression#createTypeReceiver(String)
-	 * @since 1.0.0
-	 */
-	public void createMethodInvocation(ForExpression forExpression, String name, boolean hasReceiver, int argumentCount) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * Create a method invocation expression (e.g. <code>java.lang.String.valueOf(10)</code>)
-	 * <p>
-	 * Note: At this time we require a receiver. In the future it may be possible to not have one, but
-	 * for that we need a <code>this</code> object to know who the receiver implicitly is.
-	 * The receiver may be a "type receiver" if it is a type, e.g. <code>java.awt.Color</code>.
-	 * <p>
-	 * This must be followed by createExpression for:
-	 * 	<code>METHOD_RECEIVER</code>
-	 * 	argumentCounts times expressions for: <code>METHOD_ARGUMENT</code>
-	 * 
-	 * @param forExpression
-	 * @param methodProxy The proxy of the method
-	 * @param hasReceiver Has a receiver flag. Currently this must always be true.
-	 * @param argumentCount Count of number of arguments. May be zero.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @see IExpression#createTypeReceiver(String)
-	 * @since 1.0.0
-	 */
-	public void createMethodInvocation(ForExpression forExpression, IProxyMethod methodProxy, boolean hasReceiver, int argumentCount) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * Create a prefix expression (e.g. <code>!flag</code> or <code>-(3+4)</code>).
-	 * If you are just trying to create a signed numeric literal, just use the createPrimitiveLiteral passing in a
-	 * negative value. You don't need to use prefix expression for that.
-	 * <p>
-	 * <pre>
-	 * This must be followed by createExpressions for:
-	 * 	<code>PREFIX_OPERAND</code>
-	 * </pre>
-	 * @param forExpression
-	 * @param operator The operator. The values come from IExpressionConstants, the prefix constants.
-	 * @throws IllegalStateException
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.common.IExpressionConstants#PRE_PLUS
-	 * @since 1.0.0
-	 */
-	public void createPrefixExpression(ForExpression forExpression, PrefixOperator operator) throws IllegalStateException;
-	
-	/**
-	 * Create a reference to <code>null</code>.
-	 * 
-	 * @param forExpression
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createNull(ForExpression forExpression) throws IllegalStateException;
-	
-	/**
-	 * Create a type literal (e.g. <code>java.lang.String.class</code>). This is used when the type is being used as value itself, not
-	 * as a receiver for a field or method or constructor or instanceof. Like as an argument to a method.
-	 * <p>
-	 * Note: If you want a type literal to be an IProxyBeanType, just use {@link IExpression#createProxyExpression(ForExpression, IProxy)} and pass in the
-	 * IProxyBeanType.
-	 * 
-	 * @param forExpression
-	 * @param type This is the type. It must be fully-qualified and if an inner class, it must have the "$" format.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createTypeLiteral(ForExpression forExpression, String type) throws IllegalStateException;
-	
-	/**
-	 * Create a type receiver. This is where a type is used as the receiver of a field access or a method invocation.
-	 * (e.g. <code>java.lang.String.valueOf(10)</code>). For this the "java.lang.String" IBeanTypeProxy is the type receiver.
-	 * <p>
-	 * This is unusual in that there is no forExpression. It isn't needed because these are only valid
-	 * in certain situations (method or field receiver) and if used anywhere else it is an error.
-	 * 
-	 * @param type This is the type. It must be fully-qualified and if an inner class, it must have the "$" format.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createTypeReceiver(String type) throws IllegalStateException;
-
-	/**
-	 * Create a type receiver. This is where a type is used as the receiver of a field access or a method invocation.
-	 * (e.g. <code>java.lang.String.valueOf(10)</code>). For this the "java.lang.String" IProxyBeanType is the type receiver.
-	 * <p>
-	 * This is unusual in that there is no forExpression. It isn't needed because these are only valid
-	 * in certain situations (method or field receiver) and if used anywhere else it is an error.
-	 * 
-	 * @param type This is the type proxy.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createTypeReceiver(IProxyBeanType type) throws IllegalStateException, IllegalArgumentException;
-	
-	/**
-	 * Create a boolean primitive literal (e.g. <code>true</code>).
-	 * 
-	 * @param forExpression
-	 * @param value The boolean value for the literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, boolean value) throws IllegalStateException;
-	
-	/**
-	 * Create a character literal (e.g. <code>'a'</code> or <code>'\n'</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The character value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, char value) throws IllegalStateException;
-
-	/**
-	 * Create a byte literal (e.g. <code>(byte)10</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The byte value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, byte value) throws IllegalStateException;
-
-	/**
-	 * Create a double literal (e.g. <code>10d</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The double value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, double value) throws IllegalStateException;
-
-	/**
-	 * Create a float literal (e.g. <code>10f</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The float value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, float value) throws IllegalStateException;
-	
-	/**
-	 * Create a int literal (e.g. <code>100000</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The int value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, int value) throws IllegalStateException;
-	
-	/**
-	 * Create a long literal (e.g. <code>10l</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The long value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, long value) throws IllegalStateException;
-	
-	/**
-	 * Create a short literal (e.g. <code>(short)10</code>)
-	 * 
-	 * @param forExpression
-	 * @param value The short value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createPrimitiveLiteral(ForExpression forExpression, short value) throws IllegalStateException;
-	
-	/**
-	 * Create a string literal (e.g. <code>"asdf"</code>). The value is the actual string, with escapes already
-	 * translated into the true character values.
-	 *  
-	 * @param forExpression
-	 * @param value The string value for this literal.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createStringLiteral(ForExpression forExpression, String value) throws IllegalStateException;
-	
-	/**
-	 * Create a subexpression.
-	 * <p>
-	 * A subexpression allows, at any time, to fork off the expression stack and do some other sets of expressions.
-	 * When the cooresponding {@link #createSubexpressionEnd()} is called, all of the expression results on the
-	 * stack that accumulated during the subexpression evaluation will be thrown away and the stack will be
-	 * what it was at the start of subexpression. Any ExpressionProxies that were resolved during the evaluation 
-	 * will not be thrown away and will still be valid.
-	 * <p>
-	 * This is useful if in the middle of an expression (such as method invocation and an argument is needed) to
-	 * go off and get the necessary value. This will allow expressions that require ROOTEXPRESSION state like a 
-	 * try/catch. If you know the expression doesn't need this, then it is more efficient to not use subexpression.
-	 * <p>
-	 * For example:
-	 * <pre><code>
-	 *   new XYZ(
-	 *     {(subexpression)
-	 *      try {
-	 *         x = 3*y.get();
-	 *      } catch (Exception e) {
-	 *         x =4;
-	 *      }
-	 *     (end subexpression)}
-	 *     x);
-	 * </code></pre>
-	 * 
-	 * In the above example, we needed to calculate "x" as the argument for XYZ, but it was too complicated and
-	 * could throw exceptions. So we used a subexpression instead. 
-	 * <p>
-	 * Of course the following would of been the better way to do it without subexpressions. But sometimes
-	 * your code is in a position that you don't know you need to do this until it is too late.
-	 *  <pre><code>
-	 *   try {
-	 *      x = 3*y.get();
-	 *   } catch (Exception e) {
-	 *      x =4;
-	 *   }
-	 *   new XYZ(x);
-	 * </code></pre>
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createSubexpression() throws IllegalStateException;
-	
-	public void createSubexpressionEnd() throws IllegalStateException;
-	
-	/**
-	 * Create an expression that has an existing bean proxy as its value.
-	 * 
-	 * @param forExpression This is for what expression this expression is being created.
-	 * @param proxy The proxy that should be used as a value, either a bean proxy or an expression proxy.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void createProxyExpression(ForExpression forExpression, IProxy proxy) throws IllegalStateException, IllegalArgumentException;
-		
-	/**
-	 * Create an assignment expression between a VariableReference and an expression. The left operand must be a variable reference (e.g. FieldAccess or
-	 * ArrayAccess). The right operand may be any expression that results in a value.
-	 * <p>
-	 * <pre>
-	 * This must be followed by createExpressions for:
-	 *  <code>ASSIGNMENT_LEFT</code>
-	 * 	<code>ASSIGNMENT_RIGHT</code>
-	 * </pre>
-	 * @param forExpression
-	 * @throws ThrowableProxy
-	 * @throws IllegalStateException
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createAssignmentExpression(ForExpression forExpression) throws IllegalStateException;
-	
-	/**
-	 * Create an assignment expression (e.g. x = 3+4) where x will be assigned to the ExpressionProxy. 
-	 * It may be used later on as a value in {@link IExpression#createExpressionProxyExpression(int, ExpressionProxy)}.
-	 * Or if callbacks were added, the callbacks would be called to return the true IBeanProxy value of the expression proxy when the complete
-	 * IExpression has been evaluated. The value of the assignment expression (e.g. x) will be passed on into the next expression.
-	 * <p>
-	 * <pre>
-	 * This must be followed by createExpressions for:
-	 * 	<code>ASSIGNMENT_RIGHT</code>
-	 * </pre>
-	 * <p>
-	 * <b>Note:</b> It is guarenteed as part of the contract that expression proxies will be notified through the listeners of the final state in the
-	 * order the expression proxies were created. 
-	 * @param forExpression This is for what expression this expression is being created.
-	 * @return a proxy to the expression value. 
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy createProxyAssignmentExpression(ForExpression forExpression) throws IllegalStateException;
-	
-	/**
-	 * Create a reassignment expression. This is like the original proxy assignment except that instead of returning a new proxy, it
-	 * reassigns the new value to the existing proxy. This cannot be used on IBeanTypeExpressionProxy's. That is because
-	 * they are controlled by the registry and severe errors would occur if they were reassigned.
-	 * <p>
-	 * <pre>
-	 * This must be followed by createExpressions for:
-	 * 	<code>ASSIGNMENT_RIGHT</code>
-	 * </pre>
-	 * <p>
-	 * <b>Note:</b> Since we are not creating a new proxy, the notification on the callbacks will be in the original order of proxies. This
-	 * does not change the notification position of this proxy.
-	 * 
-	 * @param forExpression
-	 * @param proxy
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException if the expression proxy is for a BeanType instead of just a standard expression proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createProxyReassignmentExpression(ForExpression forExpression, ExpressionProxy proxy) throws IllegalStateException, IllegalArgumentException;
-	
-	/**
-	 * A simple method invocation. This is a helper to make it easier for a simple method invoke. It uses only the 
-	 * method proxy (not a string to look it up), it uses a IBeanProxy receiver (not a complicated expression), and the
-	 * arguments are a mixture of IBeanProxies and ExpressionProxies. Also it can be called only when the next
-	 * expression must be a RootExpression.
-	 * 
-	 * @param method methodproxy of the method
-	 * @param receiver the receiver proxy or <code>null</code> if a static method
-	 * @param arguments array of arguments, where each element can only be either <code>null</code> for a null argument, <code>IProxy</code>. The array can be <code>null</code> if no arguments.
-	 * @param wantResult <code>true</code> if you want an ExpressionProxy back, otherwise it will return <code>null</code>. For performance reasons, only use <code>true</code> if you really need the expression proxy.
-	 * @return expression proxy if "wantResult" was true, else <code>null</code>.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy createSimpleMethodInvoke(IProxyMethod method, IProxy receiver, IProxy[] arguments, boolean wantResult) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * A simple field access. This is a helper to make it easier for a simple field access. It uses only the 
-	 * field proxy (not a string to look it up), and the bean proxy that is the receiver. Also it can be called only when the next
-	 * expression must be a RootExpression. It doesn't allow complicated field access, such as <code>fielda.fieldb.fieldc</code>.
-	 * Since this is a field access, it will always return an ExpressionProxy. It doesn't make sense to have a simple field access
-	 * that doesn't return one.
-	 * 
-	 * @param field field proxy of the field.
-	 * @param receiver the receiver proxy. It may be <code>null</code> for static fields.
-	 * @return expression proxy to the result of the access.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy createSimpleFieldAccess(IProxyField field, IProxy receiver) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * A simple field set. This is a helper to make it easier for a simple field access. It uses only the 
-	 * field proxy (not a string to look it up), and the bean proxy that is the receiver. Also it can be called only when the next
-	 * expression must be a RootExpression. It doesn't allow complicated field access setting, such as <code>fielda.fieldb.fieldc = 3</code>.
-	 * 
-	 * @param field field proxy of the field.
-	 * @param receiver the receiver proxy. It may be <code>null</code> if this is a static field.
-	 * @param value the value proxy to set it to or <code>null</code> if set to null value.
-	 * @param wantResult <code>true</code> if you want an ExpressionProxy back, otherwise it will return <code>null</code>. For performance reasons, only use <code>true</code> if you really need the expression proxy.
-	 * @return expression proxy if "wantResult" was true, else <code>null</code>.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy createSimpleFieldSet(IProxyField field, IProxy receiver, IProxy value, boolean wantResult) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * Begin a block. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * <p>
-	 * Eventually {@link Expression#createBlockEnd()} must be called. You should use this pattern:
-	 * <pre><code>
-	 * exp.createBeginBlock();
-	 * try {
-	 *   exp.create something else.
-	 *   ...
-	 * } finally {
-	 *   exp.createEndBlock();
-	 * }
-	 * </code></pre>
-	 * 
-	 * @return blocknumber for the block just opened. Can be used in {@link Expression#createBlockBreak(int)}.
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public int createBlockBegin() throws IllegalStateException;
-	
-	/**
-	 * Does a break for the specified block number. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * @param blockNumber
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createBlockBreak(int blockNumber) throws IllegalStateException;
-
-	/**
-	 * End a block. It will always end the inner most block that currently is on the stack. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * @throws IllegalStateException
-	 * 
-	 * @see Expression#createBlockBegin()
-	 * @since 1.1.0
-	 */
-	public void createBlockEnd() throws IllegalStateException;
-	
-	/**
-	 * Create a try/catch statement. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * There must be at least one catch or finally clause before try end or this is invalid.
-	 * <p>
-	 * This should be executed in the following way:
-	 * <pre><code>
-	 * exp.createTry();
-	 * try {
-	 *   ... create other exceptions ...
-	 *   ... create catch/finally clauses as needed.
-	 * } finally {
-	 *   if (exp.isValid())
-	 *     exp.createTryEnd();
-	 * }
-	 * </code></pre>
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createTry() throws IllegalStateException;
-	
-
-	/**
-	 * Create a catch clause for the inner most try statement. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * <p>
-	 * Using this you can get just the exception as a proxy and/or execute some expressions as part of the catch clause.
-	 * <p>
-	 * This can be followed by RootExpressions, or another catch, or a finally, or a try end.
-	 *  
-	 * @param exceptionType the type of the exception to catch on.
-	 * @param wantExceptionReturned <code>true</code> if you want an expression proxy for the exception.
-	 * @return the ExpressionProxy for the exception if <code>wantExceptionReturned</code> is <code>true</code>, <code>null</code> otherwise.
-	 * 
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy createTryCatchClause(IProxyBeanType exceptionType, boolean wantExceptionReturned) throws IllegalStateException, IllegalArgumentException;
-
-	/**
-	 * Create a catch clause for the inner most try statement. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * <p>
-	 * Using this you can get just the exception as a proxy and/or execute some expressions as part of the catch clause.
-	 * <p>
-	 * This can be followed by RootExpressions, or another catch, or a finally, or a try end.
-	 *  
-	 * @param exceptionType the type of the exception to catch on.
-	 * @param wantExceptionReturned <code>true</code> if you want an expression proxy for the exception.
-	 * @return the ExpressionProxy for the exception if <code>wantExceptionReturned</code> is <code>true</code>, <code>null</code> otherwise.
-	 * 
-	 * @throws IllegalStateException
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy createTryCatchClause(String exceptionType, boolean wantExceptionReturned) throws IllegalStateException;;
-
-	/**
-	 * Create a finally clause for the inner most try statement. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * There must be no more catch clauses for the try statement after this finally clause.
-	 * 
-	 * @throws IllegalStateException
-	 * @since 1.1.0
-	 */
-	public void createTryFinallyClause() throws IllegalStateException;;
-	
-	/**
-	 * Create the end of the inner most try statement. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * There must be no more catch/finally clauses after this except if a new try statement is started.
-	 * 
-	 * @throws IllegalStateException
-	 * @since 1.1.0
-	 */
-	public void createTryEnd() throws IllegalStateException;;
-	
-	/**
-	 * Create a throw. No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * The next expression is the exception to be thrown.
-	 * <p>
-	 * This must be followed by createExpression for:
-	 * 	<code>THROW_OPERAND</code>
-	 *  
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createThrow() throws IllegalStateException;
-	
-	/**
-	 * Create a rethrow. This must be within a catch clause or there is an error.
-	 * <p> 
-	 * This is a shortcut for:
-	 * <pre><code>
-	 * try {
-	 *   .. do something ..
-	 * } catch (AnException e) {
-	 *   .. do something ..
-	 *   throw e;
-	 * }
-	 * </code></pre>
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void createRethrow() throws IllegalStateException;
-
-	
-	/**
-	 * Mark the expression stack so that if there are IllegalStateExceptions errors that would make the
-	 * expression invalid, you can restore back to this mark point and the expression will now be valid
-	 * again and at the state it was when mark was created. All marks must be ended, and at the same nesting
-	 * level.
-	 * <p>
-	 * No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * <p>
-	 * It must be used in conjunction with endMark. You must use <code>mark;try/finally{endMark;}</code> because
-	 * the mark/endMark must match up. 
-	 * <pre><code>
-	 * int mark = expression.mark();
-	 * try {
-	 *   expression.create ...
-	 * } catch (IllegalStateException e) {
-	 *   process the error.
-	 * } finally {
-	 *   expression.endMark(mark); // After this, the expression will be valid again.
-	 * }
-	 * </code></pre>
-	 * <p>
-	 * However, the following code would be invalid nesting, and will throw an IllegalStateException on the createTryEnd. This is because
-	 * we tried to end the Try statement within the mark. This is invalid because if we let it go through it would
-	 * of popped the stack and when we got to the endMark the stack would of been popped past it and it could not
-	 * be restored to the same state as it was at the time of the mark. The try would of already been ended.
-	 * <pre><code>
-	 * expression.createTry();
-	 * int mark = expression.mark();
-	 * try {
-	 *   expression.create ...
-	 *   expression.createTryEnd();
-	 * } catch (IllegalStateException e) {
-	 *   process the error. The expression is now invalid.
-	 * } finally {
-	 *   expression.endMark(mark); // After this, the expression will be valid again, if it had gone invalid.
-	 * }
-	 * </code></pre>
-	 * <p>
-	 * If not at RootExpression at time of mark() request, an IllegalStateException will be thrown.
-	 * @return mark number, this number will be used in the cooresponding endMark.
-	 * @throws IllegalStateException
-	 * 
-	 * @see IExpression#endMark(int)
-	 * @since 1.1.0
-	 */
-	public int mark() throws IllegalStateException;
-	
-	/**
-	 * The end mark for a mark. 
-	 * <p>
-	 * No need for a forExpression because it must currently be at ROOTEXPRESSION.
-	 * @param markNumber
-	 * @throws IllegalStateException
-	 * 
-	 * @see IExpression#mark()
-	 * @since 1.1.0
-	 */
-	public void endMark(int markNumber) throws IllegalStateException;
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IExtensionRegistration.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IExtensionRegistration.java
deleted file mode 100644
index 3d138a7..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IExtensionRegistration.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IExtensionRegistration.java,v $
- *  $Revision: 1.1 $  $Date: 2005/06/15 20:19:11 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * Extensions point ("extensions" elements of the "org.eclipse.jem.proxy.contributors" extension point).
- * <p>
- * Implementers of this interface are called when the appropriate registry type for a given classPath/plugin is present.
- * It is used to register the registry type specific extensions.
- * @since 1.1.0
- */
-public interface IExtensionRegistration {
-	
-	/**
-	 * This will be called before any contributeToRegistry's have been called. Typically all that
-	 * should be done in here is to register extension factories or constants. It is best if no
-	 * actual proxy calls are made. This is because the registry does not yet have all of the 
-	 * appropriate extensions registered and it would be possible to accidently reference a bean type
-	 * that has not yet had its appropriate factory registered.
-	 * <p>
-	 * <b>Note:</b> This may be called more than once if used in more than one extension or if used in a plugin and a container path and both are found.
-	 * Should take this into account and not register twice.
-	 * @param baseRegistry
-	 * 
-	 * @since 1.1.0
-	 */
-	public void register(BaseProxyFactoryRegistry baseRegistry);
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IFieldProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IFieldProxy.java
deleted file mode 100644
index db0ac3e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IFieldProxy.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IFieldProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * A Proxy to a field that allows the field value to be retrieved and set
- * This allows target VM proxying of the field and is analagous to the java.lang.Reflect.Field
- * in the same way IMethodProxy is analagous to java.lang.Reflect.Method
- * Creation date: (1/17/00 12:17:52 PM)
- * @author: Joe Winchester
- */
-public interface IFieldProxy extends IAccessibleObjectProxy, IProxyField {
-/**
- * Return the type of the field.
- */
-IBeanTypeProxy getFieldType();
-
-/**
- * Return the value of us on the subject argument.
- * If the field is a primitive type, the return proxy
- * will be of the primitive type too.  
- * Creation date: (1/17/00 12:28:48 PM)
- */
-IBeanProxy get(IBeanProxy aSubject) throws ThrowableProxy;
-
-/**
- * Set the argument as the field value on the subject
- * Creation date: (1/17/00 12:28:48 PM)
- */
-void set(IBeanProxy aSubject, IBeanProxy argument) throws ThrowableProxy;
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IIntegerBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IIntegerBeanProxy.java
deleted file mode 100644
index 79be9fa..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IIntegerBeanProxy.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IIntegerBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Interface to an integer bean proxy.
- * We originally had only an Integer proxy,
- * so the use of it was throughout the system.
- * We are now supporting Number instead, but
- * because there were so many places using int,
- * we've left it in.
- * Creation date: (2/6/00 8:52:42 AM)
- * @author: Joe Winchester
- */
-public interface IIntegerBeanProxy extends INumberBeanProxy {
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IInvokable.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IInvokable.java
deleted file mode 100644
index f21904d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IInvokable.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IInvokable.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * Interface for invoking method calls on the vm.
- * IMethodProxy implements it for when you have a method proxy available,
- * but you can also get a straight invokable which will get the
- * proxy on the vm at the time of execution.
- * <p>
- * The method proxy factory can be used to return either method
- * proxies when the invokable will be used over and over, and
- * it can return IInvokable's when it is one shot deal. Though even
- * when one-shot deal it can be used over and over. There is just overhead because the 
- * method is looked up each time. So a reasonable compromise would be if
- * using it infrequently or use closely together once or twice it is better
- * to use a Invokable instead of a method proxy.
- * @since 1.0.0
- */
-public interface IInvokable {
-
-	/**
-	 * Invoke us on the subject
-	 * Creation date: (12/3/99 11:37:12 AM)
-	 * @author Joe Winchester
-	 */
-	IBeanProxy invoke(IBeanProxy subject) throws ThrowableProxy;
-
-	/**
-	 * Invoke us on the subject with the specified argument
-	 * Creation date: (12/3/99 11:37:12 AM)
-	 * @author Joe Winchester
-	 */
-	IBeanProxy invoke(IBeanProxy subject, IBeanProxy argument) throws ThrowableProxy;
-
-	/**
-	 * Invoke us on the subject with the specified arguments
-	 * Creation date: (12/3/99 11:37:12 AM)
-	 * @author Joe Winchester
-	 */
-	IBeanProxy invoke(IBeanProxy subject, IBeanProxy[] arguments) throws ThrowableProxy;
-
-	/**
-	 * Invoke us on the subject, however catch all exceptions
-	 * Only to be used when you don't want ThrowableExceptions. This should
-	 * not be the normal way to invoke.
-	 * Creation date: (12/3/99 11:37:12 AM)
-	 * @author Joe Winchester
-	 */
-	IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject);
-
-	/**
-	 * Invoke us on the subject with the specified argument, however catch all exceptions
-	 * Only to be used when you don't want ThrowableExceptions. This should
-	 * not be the normal way to invoke.
-	 * Creation date: (12/3/99 11:37:12 AM)
-	 * @author Joe Winchester
-	 */
-	IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy argument);
-
-	/**
-	 * Invoke us on the subject with the specified arguments, however catch all exceptions
-	 * Only to be used when you don't want ThrowableExceptions. This should
-	 * not be the normal way to invoke.
-	 * Creation date: (12/3/99 11:37:12 AM)
-	 * @author Joe Winchester
-	 */
-	IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy[] arguments);
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IMethodProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IMethodProxy.java
deleted file mode 100644
index c6121e9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IMethodProxy.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IMethodProxy.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-/**
- * Interface for Method Proxies Creation date: (12/3/99 11:36:29 AM)
- * 
- * @author: Joe Winchester
- */
-public interface IMethodProxy extends IAccessibleObjectProxy, IInvokable, IProxyMethod {
-
-	/**
-	 * Answer the class the method is defined in. Creation date: (12/3/99 11:37:12 AM)
-	 * 
-	 * @author Joe Winchester
-	 */
-	IBeanTypeProxy getClassType();
-
-	/**
-	 * Answer the name of the method Creation date: (12/3/99 11:37:12 AM)
-	 * 
-	 * @author Joe Winchester
-	 */
-	String getName();
-
-	/**
-	 * Answer the parameter types of the method Creation date: (12/3/99 11:37:12 AM)
-	 * 
-	 * @author Joe Winchester
-	 */
-	IBeanTypeProxy[] getParameterTypes();
-
-	/**
-	 * Answer the return type of the method Creation date: (12/3/99 11:37:12 AM)
-	 * 
-	 * @author Joe Winchester
-	 */
-	IBeanTypeProxy getReturnType();
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IMethodProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IMethodProxyFactory.java
deleted file mode 100644
index 8e0b1ba..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IMethodProxyFactory.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IMethodProxyFactory.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-/**
- * Factory for creating method proxies.
- * 
- * The factory exists for use, but generally it is better to go through the bean type proxy to get a method proxy. This is useful for setting up a
- * bunch of method proxies in initialization routines so you don't need to have a bean type proxy for each.
- * 
- * Creation date: (12/3/99 6:21:52 PM)
- * 
- * @author: Joe Winchester
- */
-public interface IMethodProxyFactory extends IBeanProxyFactory {
-
-	/**
-	 * Return a method proxy for the specified name, arguments from the class.
-	 * 
-	 * @param className
-	 * @param methodName
-	 * @param parameterTypes
-	 *            parameter type names or <code>null</code> for parameterTypes means no parameters.
-	 * @return a method proxy or null if can't be found. 
-	 * @since 1.0.0
-	 */
-	IMethodProxy getMethodProxy(String className, String methodName, String[] parameterTypes);
-	
-	/**
-	 * Return an IProxyMethod for the specified name, arguments from the given class.
-	 * @param expression
-	 * @param className
-	 * @param methodName
-	 * @param parameterTypes
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	IProxyMethod getMethodProxy(IExpression expression, String className, String methodName, String[] parameterTypes);
-
-	/**
-	 * Return an IProxyField for the specified name, arguments from the given class.
-	 * @param expression
-	 * @param className
-	 * @param fieldName
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	IProxyField getFieldProxy(IExpression expression, String className, String fieldName);
-
-	
-	/**
-	 * Return an invokable for the specified name, arguments from the class. The method proxy is not retrieved. Instead the method will be looked up
-	 * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should
-	 * be retrieved instead.
-	 * <p>
-	 * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise
-	 * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy.
-	 * <p>
-	 * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done.
-	 * 
-	 * @param className
-	 * @param methodName
-	 * @param parameterTypes
-	 *            parameter type names or <code>null</code> for parameterTypes means no parameters.
-	 * @return an invokable 
-	 * @since 1.0.0
-	 */
-	IInvokable getInvokable(String className, String methodName, String[] parameterTypes);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/INumberBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/INumberBeanProxy.java
deleted file mode 100644
index ca0426a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/INumberBeanProxy.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: INumberBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * Interface to an integer bean proxy.
- * Creation date: (2/6/00 8:52:42 AM)
- * @author: Joe Winchester
- */
-public interface INumberBeanProxy extends IBeanProxy {
-/**
- * Return the primitive byte value of the proxied Number
- * Creation date: (2/6/00 8:52:59 AM)
- */
-byte byteValue();
-/**
- * Return the primitive double value of the proxied Number
- * Creation date: (2/6/00 8:52:59 AM)
- */
-double doubleValue();
-/**
- * Return the primitive float value of the proxied Number
- * Creation date: (2/6/00 8:52:59 AM)
- */
-float floatValue();
-/**
- * Return the primitive int value of the proxied Number
- * Creation date: (2/6/00 8:52:59 AM)
- */
-int intValue();
-/**
- * Return the primitive long value of the proxied Number
- * Creation date: (2/6/00 8:52:59 AM)
- */
-long longValue();
-/**
- * Return the value as a Number.
- * Creation date: (2/6/00 8:52:59 AM)
- */
-Number numberValue();
-/**
- * Return the primitive short value of the proxied Number
- * Creation date: (2/6/00 8:52:59 AM)
- */
-short shortValue();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IPDEContributeClasspath.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IPDEContributeClasspath.java
deleted file mode 100644
index aad0c15..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IPDEContributeClasspath.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IPDEContributeClasspath.java,v $
- *  $Revision: 1.4 $  $Date: 2005/10/14 17:45:02 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.core.runtime.CoreException;
-
-
-/**
- * Contribute to classpath PDE entries that are needed for a launch.
- * <p> 
- * Use the <code>INSTANCE()</code> to access the contributor. If the value
- * is <code>null</code>, then PDE is not available.
- * 
- * @since 1.0.2
- */
-public interface IPDEContributeClasspath {
-	
-	public static IPDEContributeClasspath INSTANCE = PDEContributeClasspathInstance.getInstance();
-
-	/**
-	 * Return the classpath contributions for the plugins in the given project.
-	 * <p>
-	 * This will add in the libraries from any fragments of any plugin that this
-	 * project references, either directly or indirectly through other plugins.
-	 * <p>
-	 * It is used by launches to get the fragment libraries since these are not
-	 * added by default to the classpath for a project by PDE. That is because they
-	 * aren't needed for compilation purposes, but they are needed for running.
-	 * 
-	 * @param controller the controller to contribute to.
-	 * @param info configuration info for the project
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.2
-	 */
-	public abstract void getPDEContributions(IConfigurationContributionController controller, IConfigurationContributionInfo info) throws CoreException;
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IPointBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IPointBeanProxy.java
deleted file mode 100644
index b08ee19..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IPointBeanProxy.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IPointBeanProxy.java,v $
- *  $Revision: 1.2 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Interface to a Point bean proxy.
- * <p>
- * These are common for different windowing systems, e.g. AWT and SWT. So this here
- * is common interface for them.
- * Creation date: (4/7/00 3:46:39 PM)
- * @author: Administrator
- */
-public interface IPointBeanProxy extends IBeanProxy {
-	public int getX();
-	public int getY();
-	public void setX(int x);
-	public void setY(int y);
-	public void setLocation(int x, int y);
-	public void setLocation(IPointBeanProxy point);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxy.java
deleted file mode 100644
index 5c963ec..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxy.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * A common interface for proxies. It is used by the expression processor to easily distinquish between
- * a proxy and an Expression proxy. 
- * @since 1.1.0
- */
-public interface IProxy {
-
-	/**
-	 * Return the registry this proxy was created with.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public ProxyFactoryRegistry getProxyFactoryRegistry();
-	
-	/**
-	 * Is this a bean proxy (including all of the subinterfaces of it, like IMethodProxy).
-	 * @return <code>true</code> if this is a bean proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isBeanProxy();
-
-	/**
-	 * Is this an expression proxy.
-	 * @return <code>true</code> if this is an expression proxy.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isExpressionProxy();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyBeanType.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyBeanType.java
deleted file mode 100644
index 372e4e8..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyBeanType.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IProxyBeanType.java,v $
- *  $Revision: 1.2 $  $Date: 2005/05/18 18:41:20 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * This interface is for IBeanTypeProxy's and BeanTypeExpressionProxy's so that we can lazily
- * get the beantype proxy and have the expression process it when needed.
- * 
- * @since 1.1.0
- */
-public interface IProxyBeanType extends IProxy {
-
-	/**
-	 * Answer the name of the type we are proxying This is the fully qualified name. For arrays it will return the format: [Lclassname; 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public String getTypeName();
-	
-	/**
-	 * Get the IProxyMethod for the method from this beantype. It may be either a resolved method proxy (if already resolved) or
-	 * it may be an ExpressionProxy if not yet resolved.
-	 * 
-	 * @param expression
-	 * @param methodName
-	 * @param parameterTypes array of parameter types or <code>null</code> if no parameters.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameterTypes);
-	
-	/**
-	 * Get the IProxyMethod for the method from this beantype where the method has no arguments. It may be either a resolved method proxy (if already resolved) or
-	 * it may be an ExpressionProxy if not yet resolved.
-	 * <p>
-	 * This is a shortcut for getMethodProxy() that takes arguments names where the names have been sent as null.
-	 * 
-	 * @param expression
-	 * @param methodName
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName);
-	
-	/**
-	 * Get the IProxyMethod for the method from this beantype. It may be either a resolved method proxy (if already resolved) or
-	 * it may be an ExpressionProxy if not yet resolved.
-	 * 
-	 * @param expression
-	 * @param methodName
-	 * @param parameterTypes array of parameter types or <code>null</code> if no parameters.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes);
-	
-	/**
-	 * Get the IProxyyField for the field from this beantype. It may be either a resolved field proxy (if already resolved) or
-	 * it may be an ExpressionProxy if not yet resolved.
-	 * 
-	 * @param expression
-	 * @param fieldName
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyField getFieldProxy(IExpression expression, String fieldName);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyConstants.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyConstants.java
deleted file mode 100644
index 9887e00..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyConstants.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IProxyConstants.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-/**
- * Constants used with the plugin xml.
- * 
- * @since 1.0.0
- */
-public interface IProxyConstants {
-	
-	/**
-	 * Launch group id for proxy launch configurations.
-	 */	
-	public static final String ID_PROXY_LAUNCH_GROUP = "org.eclipse.jem.proxy"; //$NON-NLS-1$
-	
-	/**
-	 * Launch configuration type for local proxy. It is local in that it is on the same machine, but a different
-	 * VM then the one running the IDE. 
-	 * 
-	 * It here because this is the default config type when no launch config specified for a project.
-	 */
-	public static final String LOCAL_LAUNCH_TYPE = "org.eclipse.jem.proxy.LocalProxyLaunchConfigurationType"; //$NON-NLS-1$
-	
-	/**
-	 * Attribute on Proxy Launch Configuration:
-	 * 
-	 * Key used in Launch Configuration for attaching AWT/Swing to the registry. This means simply
-	 * that AWT/Swing should be treated as being in the registry or not. It doesn't actually prevent
-	 * them from being there.
-	 *
-	 * The default value for this attribute is "true", so it should be set only to "false".
-	 */
-	public static final String ATTRIBUTE_AWT_SWING = "org.eclipse.jem.proxy.AWT/Swing"; //$NON-NLS-1$
-	
-	/**
-	 * Attribute on Proxy Launch Configuration:
-	 * 
-	 * Key used in Launch Configuration for the contributors and returning the registry. After retrieving key,
-	 * go back to ProxyLaunchSupport to retrieve the contributors. And it uses it to return the registry.
-	 * 
-	 * Not to be set by contributors. This will be set only by the ProxyLaunchSupport start implementation methods.
-	 * It is here only because external developer's launch configurations will need to be able to access this.
-	 */
-	public static final String ATTRIBUTE_LAUNCH_KEY = "org.eclipse.jem.proxy.LaunchKey"; //$NON-NLS-1$
-	
-	/**
-	 * Attribute on Proxy Launch Configuration:
-	 *  
-	 * VM title used for the launch registry.
-	 * 
-	 * Not to be set by contributors. This will be set only by the ProxyLaunchSupport start implementation methods.
-	 * It is here only because external developer's launch configurations will need to be able to access this.
-	 */
-	public static final String ATTRIBUTE_VM_TITLE = "org.eclipse.jem.proxy.vmtitle"; //$NON-NLS-1$
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyField.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyField.java
deleted file mode 100644
index 24ef953..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyField.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IProxyField.java,v $
- *  $Revision: 1.1 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * This interface is for IFieldProxy's and FieldExpressionProxy's so that we can lazily
- * get the field proxy and have the expression process it when needed.
- * @since 1.1.0
- */
-public interface IProxyField extends IProxy {
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyMethod.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyMethod.java
deleted file mode 100644
index 2268869..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IProxyMethod.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IProxyMethod.java,v $
- *  $Revision: 1.1 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
- 
-
-/**
- * This interface is for IMethodProxy's and MethodExpressionProxy's so that we can lazily
- * get the method proxy and have the expression process it when needed.
- * 
- * @since 1.1.0
- */
-public interface IProxyMethod extends IProxy {
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IRectangleBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IRectangleBeanProxy.java
deleted file mode 100644
index fcfbf39..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IRectangleBeanProxy.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IRectangleBeanProxy.java,v $
- *  $Revision: 1.2 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Interface to a Rectangle bean proxy.
- * <p>
- * These are common for different windowing systems, e.g. AWT and SWT. So this here
- * is common interface for them.
- * Creation date: (4/7/00 3:46:39 PM)
- * @author: Administrator
- */
-public interface IRectangleBeanProxy extends IBeanProxy {
-	public int getX();
-	public int getY();
-	public void setX(int x);
-	public void setY(int y);
-	public void setLocation(int x, int y);
-	public void setLocation(IPointBeanProxy point);
-	
-	public int getHeight();
-	public int getWidth();
-	public void setHeight(int height);
-	public void setWidth(int width);
-	public void setSize(int width, int height);
-	public void setSize(IDimensionBeanProxy dim);
-	
-	public void setBounds(int x, int y, int width, int height);
-	public void setBounds(IRectangleBeanProxy rect);	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStandardBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStandardBeanProxyFactory.java
deleted file mode 100644
index 8340397..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStandardBeanProxyFactory.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-
-
-/*
- *  $RCSfile: IStandardBeanProxyFactory.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * The Standard base bean proxy factory.
- * This is the Interface that the desktop will talk
- * to.
- * Creation date: (12/3/99 11:52:09 AM)
- * @author: Joe Winchester
- */
-public interface IStandardBeanProxyFactory extends IBeanProxyFactory {
-	
-/**
- * Get the {@link org.eclipse.jem.internal.proxy.common.IVMServer} proxy for the
- * this registry. This is only needed if you need to give the IVMserver to a proxy so that
- * it can access it.
- * <p>
- * <b>Note:</b> Does not need to be given to callback proxies because they are given
- * an {@link org.eclipse.jem.internal.proxy.common.IVMCallbackServer} on initialization, and
- * that interface implements the IVMServer interface too.
- * 
- * @return
- * 
- * @since 1.1.0
- */
-public IBeanProxy getIVMServerProxy();
-/**
- * Return a new bean proxy for the primitive integer argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IIntegerBeanProxy createBeanProxyWith(int aPrimitiveInteger);
-/**
- * Return a new bean proxy for the primitive character argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public ICharacterBeanProxy createBeanProxyWith(char aPrimitiveCharacter);
-/**
- * Return a new bean proxy for the primitive byte argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public INumberBeanProxy createBeanProxyWith(byte aPrimitiveByte);
-/**
- * Return a new bean proxy for the primitive short argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public INumberBeanProxy createBeanProxyWith(short aPrimitiveShort);
-/**
- * Return a new bean proxy for the primitive long argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public INumberBeanProxy createBeanProxyWith(long aPrimitiveLong);
-/**
- * Return a new bean proxy for the primitive float argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public INumberBeanProxy createBeanProxyWith(float aPrimitiveFloat);
-/**
- * Return a new bean proxy for the primitive double argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public INumberBeanProxy createBeanProxyWith(double aPrimitiveDouble);
-/**
- * Return a new bean proxy for the Boolean argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IBooleanBeanProxy createBeanProxyWith(Boolean aBoolean);
-/**
- * Return a new bean proxy for the Integer argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IIntegerBeanProxy createBeanProxyWith(Integer anInteger);
-/**
- * Return a new bean proxy for the Character argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public ICharacterBeanProxy createBeanProxyWith(Character aCharacter);
-/**
- * Return a new bean proxy for the Number argument, can handle any of the numbers.
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public INumberBeanProxy createBeanProxyWith(Number aNumber);
-/**
- * Return a new bean proxy for the string argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IStringBeanProxy createBeanProxyWith(String aString);
-
-/**
- * Convert the non-primitive proxy to a primitive proxy, if it
- * of one of the wrapper types. If not, then just return the proxy as is.
- * <p>
- * I.E. BooleanClassProxy will convert to BooleanTypeProxy, but ObjectClassProxy will just return unchanged.
- * @param nonPrimitiveProxy
- * @return either the primitive proxy that nonPrimitive wrappers, or the non-primitive if not a wrapper type.
- * 
- * @since 1.0.0
- */
-public IBeanProxy convertToPrimitiveBeanProxy(IBeanProxy nonPrimitiveProxy);
-/**
- * Return a new bean proxy for the boolean argument
- * Creation date: (12/3/99 11:52:20 AM)
- * @author Joe Winchester
- */
-public IBooleanBeanProxy createBeanProxyWith(boolean aBoolean);
-/**
- * Create an array bean proxy.
- *
- *   - (int, new int[2] {3, 4}) will create:
- *      int [3] [4]
- *
- *   - (int[], new int[1] {1})
- *      int [1]
- *
- *   - (int[], new int[2] {2,3})
- *      int [2] [3]
- * 
- *
- *   - (int[], null) or (int[], new int[0]) or (int, null) or (int, new int[0])
- *      int [0]...
- *     or
- *     (int[][]..., null) or (int[][]..., new int[0])
- *      int[0][]...
- *     This is because an array instance with no specified dimensions is not valid. 
- *
- *   - (int[][], new int[1] {3})
- *      int[3][]
- */
-public IArrayBeanProxy  createBeanProxyWith(IBeanTypeProxy type, int[] dimensions) throws ThrowableProxy;
-/**
- * Create a one-dimensional array. 
- * The result will be the same as calling 
- *   createBeanProxyWith(IBeanTypeProxy type, new int[1] {x})
- * where 'x' is the value passed in as the dimension.
- */
-public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int dimension) throws ThrowableProxy;
-
-/**
- * Create a bean proxy from an initialization string. 
- * <p>
- * It is not recommended that this method be commonly used. That is because no type checking will be performed
- * on the result. Whatever it evaluates to be will be what it is. It is useful for the rare cases where the desired
- * result type is not known.
- * <p>
- * It is recommended instead to use the newInstance(initString) method on the appropriate IBeanTypeProxy so that the
- * result can be type-checked to make sure the string evaluates to something of that type.
- * 
- * @param initializationString
- * @return
- * @throws ThrowableProxy
- * @throws InstantiationException
- * @throws ClassCastException
- * 
- * @since 1.0.0
- */
-public IBeanProxy createBeanProxyFrom(String initializationString) throws ThrowableProxy, InstantiationException, ClassCastException;
-
-/**
- * Release the proxy. In the case of Remote VM, this means
- * it will remove the proxy on the client side, and remove
- * the reference to the real object on the server side. On the server
- * side the real object may not go away because something else could
- * be holding onto it, but it won't be held simply because the client
- * is holding onto it.
- */
-public void releaseProxy(IBeanProxy proxy);
-
-/**
- * Create an expression.
- * @return The expression.
- * 
- * @since 1.0.0
- */
-public IExpression createExpression();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStandardBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStandardBeanTypeProxyFactory.java
deleted file mode 100644
index 53d3039..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStandardBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IStandardBeanTypeProxyFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-import java.util.Set;
-/**
- * The standard bean type proxy factory.
- * This is the Interface that the desktop will talk
- * to, the one that is returned when getCurrent() is called.
- * Creation date: (3/10/00 11:00:50 AM)
- * @author: Richard Lee Kulp
- */
-public interface IStandardBeanTypeProxyFactory extends IBeanProxyFactory {
-	
-/**
- * Used by other registered bean type proxy factories to
- * register their bean type proxies with the standard factory
- * so that it will be cached there. 
- * <p><b>Note:</b> This is not meant to be called by customers. It is here for the usage
- * of registry extensions.
- * @param aBeanTypeProxy
- * @param permanent indicates that beantype will never be released,
- * not even if explicit request is made.
- * 
- * @since 1.1.0
- */
-void registerBeanTypeProxy(IBeanTypeProxy aBeanTypeProxy, boolean permanent);
-
-/**
- * Used by other registered bean type proxy factories to
- * register their proxy bean type with the standard factory
- * so that it will be cached there. 
- * <p><b>Note:</b> This is not meant to be called by customers. It is here for the usage
- * of registry extensions.
- * @param aBeanTypeProxy
- * @param permanent indicates that beantype will never be released,
- * not even if explicit request is made.
- * 
- * @since 1.1.0
- */
-void registerBeanTypeProxy(IProxyBeanType aBeanTypeProxy, boolean permanent);
-
-/**
- * Return the beanType proxy for the given class name.
- * It must be fully qualified. And for arrays it can handle
- * either the jni type ([Ljava.lang.Object;) or the Java EMF Model
- * formal type (java.lang.Object[]).
- */
-IBeanTypeProxy getBeanTypeProxy(String className);
-
-/**
- * Get the beantype proxy suitable for an expression.
- * 
- * @param expression
- * @param typeName
- * @return
- * 
- * @since 1.1.0
- */
-IProxyBeanType getBeanTypeProxy(IExpression expression, String typeName);
-
-/**
- * Return an Array type proxy for the given class name of
- * the specified dimensions. This is a helper method. The
- * same result can be gotton from getBeanTypeProxy.
- * e.g.
- *      getBeanTypeProxy("java.lang.Object", 3)
- *    is the same as:
- *      getBeanTypeProxy("[[[Ljava.lang.Object;")
- *
- *    They both result in a type of:
- *      Object [][][]
- * 
- *    or if using the JNI format (proxy format)
- *      getBeanTypeProxy("[Ljava.langObject;", 3)
- *    becomes
- *      Object [][][][] 
- * 
- *    or if using the standard java format (as in actual code)
- *      getBeanTypeProxy("java.langObject[];", 3)
- *    becomes
- *      Object [][][][]
- */
-IBeanTypeProxy getBeanTypeProxy(String componentClassName, int dimensions);
-
-/**
- * Return an Array type proxy for the given class name of
- * the specified dimensions. This is a helper method. The
- * same result can be gotton from getBeanTypeProxy.
- * e.g.
- *      getBeanTypeProxy("java.lang.Object", 3)
- *    is the same as:
- *      getBeanTypeProxy("[[[Ljava.lang.Object;")
- *
- *    They both result in a type of:
- *      Object [][][]
- * 
- *    or if using the JNI format (proxy format)
- *      getBeanTypeProxy("[Ljava.langObject;", 3)
- *    becomes
- *      Object [][][][] 
- * 
- *    or if using the standard java format (as in actual code)
- *      getBeanTypeProxy("java.langObject[];", 3)
- *    becomes
- *      Object [][][][]
- * 
- * @param expression
- * @param componentClassName
- * @param dimensions
- * @return
- * 
- * @since 1.1.0
- */
-IProxyBeanType getBeanTypeProxy(IExpression expression, String componentClassName, int dimensions);
-
-/**
- * Test if a specific bean type has been registered. Don't access and create
- * if it isn't currently registered.
- */
-boolean isBeanTypeRegistered(String className);
-
-/**
- * Registered types. Return a set of strings that are the registered classes.
- * This Set isn't synchronized, there may be changes while accessing it.
- */
-Set registeredTypes();
-
-/**
- * Maintain list of not found types. This list is types that were requested,
- * but didn't exist. This method sets whether list should be maintained or not.
- * If set to false, the list will be empty. The default is false.
- * 
- * @param maintain
- */
-void setMaintainNotFoundTypes(boolean maintain);
-
-/**
- * Maintain list of not found types. This list is types that were requested,
- * but didn't exist. This method returns whether list should be maintained or not.
- * If false, the list will be empty. The default is false.
- * 
- * @return maintaining not found types.
- */
-boolean isMaintainNotFoundTypes();
-
-/**
- * Maintain list of not found types. This list is types that were requested,
- * but didn't exist. 
- *
- * @param className Classname to search for to see if ever not found.
- * @return true if the bean type had been searched for but was not found. If not maintaining, then result will be false.
- */
-boolean isBeanTypeNotFound(String className);
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStringBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStringBeanProxy.java
deleted file mode 100644
index 177d454..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IStringBeanProxy.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IStringBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * Optimized implementation that should be used for string proxies that
- * allows the IDE VM to get the string value easily
- * Creation date: (2/6/00 8:58:22 AM)
- * @author: Joe Winchester
- */
-public interface IStringBeanProxy extends IBeanProxy {
-/**
- * Return the proxied string as a string that the IDE can use
- * Creation date: (2/6/00 8:58:32 AM)
- */
-String stringValue();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IUIRunner.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IUIRunner.java
deleted file mode 100644
index e1bba97..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IUIRunner.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IUIRunner.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
- 
-
-/**
- * Interface that doesn't require UI. The implementation will. This will
- * only be used if within UI environment.
- * 
- * <package-protected> because should only be used within here.
- * 
- * @since 1.0.0
- */
-interface IUIRunner {
-	/**
-	 * Handle the build. If not in UI thread, just call back to ProxyLaunchSupport
-	 * to handle the build. If on UI thread, then use the IProgressService to do it.
-	 * This will keep the UI from "locking", though it will be disabled it won't deadlock.
-	 * 
-	 * @param pm
-	 * 
-	 * @since 1.0.0
-	 */
-	public void handleBuild(IProgressMonitor pm) throws CoreException;
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IteratorBeanProxyWrapper.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IteratorBeanProxyWrapper.java
deleted file mode 100644
index 2fd0550..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/IteratorBeanProxyWrapper.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: IteratorBeanProxyWrapper.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-import java.text.MessageFormat;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-/**
- * This is a wrapper for an java.util.Iterator proxy.
- * It provides the iterator methods to interface to
- * the proxy.
- */
-
-public class IteratorBeanProxyWrapper {
-	protected final IBeanProxy fIterator;
-	protected final JavaStandardBeanProxyConstants fConstants;
-	
-	/**
-	 * Construct with the collection.
-	 */
-	public IteratorBeanProxyWrapper(IBeanProxy anIteratorProxy) {
-		if (!anIteratorProxy.getTypeProxy().isKindOf(anIteratorProxy.getProxyFactoryRegistry().getBeanTypeProxyFactory().getBeanTypeProxy("java.util.Iterator"))) //$NON-NLS-1$
-			throw new ClassCastException(MessageFormat.format(ProxyMessages.ClassCast_EXC__IncorrectType, new Object[] {anIteratorProxy.getTypeProxy().getTypeName(), "java.util.Iterator"})); 
-		else
-			fIterator = anIteratorProxy;
-			
-		fConstants = JavaStandardBeanProxyConstants.getConstants(anIteratorProxy.getProxyFactoryRegistry());
-	}
-	
-	/**
-	 * Answer the iterator proxy that this is wrappering.
-	 */
-	public IBeanProxy getBeanProxy() {
-		return fIterator;
-	}
-
-	/**
-	 * equals - Pass it on to the proxy to handle this.
-	 */
-	public boolean equals(Object object) {
-		return fIterator.equals(object);
-	}
-	
-	/**
-	 * hashCode - Pass it on to the proxy to handle this.
-	 */
-	public int hashCode() {
-		return fIterator.hashCode();
-	}
-	
-	/**
-	 * Iterator accessors
-	 */
-	public boolean hasNext() {
-		try {
-			return ((IBooleanBeanProxy) fConstants.getIteratorHasNext().invoke(fIterator)).booleanValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return false;
-		}			
-	}
-	public IBeanProxy next() throws ThrowableProxy {
-		return fConstants.getIteratorNext().invoke(fIterator);
-	}	
-	public void remove() throws ThrowableProxy {
-		fConstants.getIteratorRemove().invoke(fIterator);
-	}	
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/JavaStandardBeanProxyConstants.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/JavaStandardBeanProxyConstants.java
deleted file mode 100644
index 37250cf..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/JavaStandardBeanProxyConstants.java
+++ /dev/null
@@ -1,347 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: JavaStandardBeanProxyConstants.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * Standard Proxy constants.
- *
- * Use the static accessor method (getConstants()) to get the appropriate 
- * constants instance for the registry. This is done so that until the
- * the constants are needed, they aren't registered.
- *
- * There are some standard utility functions too.
- *
- * NOTE: Since everything in here just proxies, there is
- *       no need to have them separated by VM. That is why
- *       this in the Proxy package.
- *
- * This is final because this can't be extended. This specific one
- * will be registered with the factory for this key. Any extensions
- * must be done in their own constants and registry key.
- *
- * Creation date: (4/7/00 4:47:48 PM)
- * @author: Administrator
- */
-public final class JavaStandardBeanProxyConstants {
-	public static final Object REGISTRY_KEY = new Object();
-		
-	final IBeanTypeProxy fCollectionType;
-	final IBeanTypeProxy fListType;
-	final IBeanTypeProxy fIteratorType;
-	final IBeanTypeProxy fListIteratorType;
-	final IBeanTypeProxy fEnumerationType;	
-	final IBeanTypeProxy fSystemType;
-	final IBeanTypeProxy fStringType;
-	
-	IMethodProxy fCollectionAdd, fCollectionAddAll, fCollectionClear, fCollectionContains,
-		fCollectionContainsAll, fCollectionIsEmpty, fCollectionIterator, fCollectionRemove,
-		fCollectionRemoveAll, fCollectionRetainAll, fCollectionSize, fCollectionToArray,
-		fCollectionToArrayWithArray;
-		
-	IMethodProxy fListAddWithInt, fListAddAllWithInt, fListGet, fListIndexOf, fListLastIndexOf,
-		fListListIterator, fListListIteratorWithInt, fListRemoveInt, 
-		fListSet, fListSubList;
-		
-	IMethodProxy fIteratorHasNext, fIteratorNext, fIteratorRemove;
-
-	IMethodProxy fListIteratorAdd, fListIteratorHasPrevious, fListIteratorNextIndex, fListIteratorPrevious,
-		fListIteratorPreviousIndex, fListIteratorRemove, fListIteratorSet;
-		
-	IMethodProxy fEnumerationHasMoreElements, fEnumerationNextElement;
-	
-	IMethodProxy fSystemArraycopy;
-
-/**
- * Get the constants instance for the specified registry.
- */
-public static JavaStandardBeanProxyConstants getConstants(ProxyFactoryRegistry registry) {
-	JavaStandardBeanProxyConstants constants = (JavaStandardBeanProxyConstants) registry.getConstants(REGISTRY_KEY);
-	if (constants == null)
-		registry.registerConstants(REGISTRY_KEY, constants = new JavaStandardBeanProxyConstants(registry));	
-	return constants;
-}
-
-
-/**
- * IDEJavaBeanConstants constructor comment.
- */
-private JavaStandardBeanProxyConstants(ProxyFactoryRegistry registry) {
-	super();
-	
-	IStandardBeanTypeProxyFactory typeFactory = registry.getBeanTypeProxyFactory();
-	fCollectionType = typeFactory.getBeanTypeProxy("java.util.Collection");//$NON-NLS-1$
-	fListType = typeFactory.getBeanTypeProxy("java.util.List"); //$NON-NLS-1$
-	fIteratorType = typeFactory.getBeanTypeProxy("java.util.Iterator"); //$NON-NLS-1$
-	fListIteratorType = typeFactory.getBeanTypeProxy("java.util.ListIterator"); //$NON-NLS-1$
-	fEnumerationType = typeFactory.getBeanTypeProxy("java.util.Enumeration");	 //$NON-NLS-1$
-	fSystemType = typeFactory.getBeanTypeProxy("java.lang.System"); //$NON-NLS-1$
-	fStringType = typeFactory.getBeanTypeProxy("java.lang.String"); //$NON-NLS-1$
-}
-
-public IBeanTypeProxy getStringType() {
-	return fStringType;
-}
-
-/**
- * Collection method accessors
- */
-public IMethodProxy getCollectionAdd() {
-	if (fCollectionAdd == null)
-		fCollectionAdd = fCollectionType.getMethodProxy("add", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionAdd;
-}
-	
-public IMethodProxy getCollectionAddAll(){
-	if (fCollectionAddAll == null)
-		fCollectionAddAll = fCollectionType.getMethodProxy("addAll", "java.util.Collection"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionAddAll;
-}
-
-public IMethodProxy getCollectionClear() {
-	if (fCollectionClear == null)
-		fCollectionClear = fCollectionType.getMethodProxy("clear"); //$NON-NLS-1$
-	return fCollectionClear;
-}
-
-public IMethodProxy getCollectionContains() {
-	if (fCollectionContains == null)
-		fCollectionContains = fCollectionType.getMethodProxy("contains", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionContains;
-}
-	
-public IMethodProxy getCollectionContainsAll() {
-	if (fCollectionContainsAll == null)
-		fCollectionContainsAll = fCollectionType.getMethodProxy("containsAll", "java.util.Collection"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionContainsAll;
-}
-
-public IMethodProxy getCollectionIsEmpty() {
-	if (fCollectionIsEmpty == null)
-		fCollectionIsEmpty = fCollectionType.getMethodProxy("isEmpty"); //$NON-NLS-1$
-	return fCollectionIsEmpty;
-}
-
-public IMethodProxy getCollectionIterator() {
-	if (fCollectionIterator == null)
-		fCollectionIterator = fCollectionType.getMethodProxy("iterator"); //$NON-NLS-1$
-	return fCollectionIterator;
-}
-
-public IMethodProxy getCollectionRemove() {
-	if (fCollectionRemove == null)
-		fCollectionRemove = fCollectionType.getMethodProxy("remove", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionRemove;
-}
-
-public IMethodProxy getCollectionRemoveAll() {
-	if (fCollectionRemoveAll == null)
-		fCollectionRemoveAll = fCollectionType.getMethodProxy("removeAll", "java.util.Collection"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionRemoveAll;
-}
-
-public IMethodProxy getCollectionRetainAll() {
-	if (fCollectionRetainAll == null)
-		fCollectionRetainAll = fCollectionType.getMethodProxy("retainAll", "java.util.Collection"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionRetainAll;
-}
-
-public IMethodProxy getCollectionSize()  {
-	if (fCollectionSize == null)
-		fCollectionSize = fCollectionType.getMethodProxy("size"); //$NON-NLS-1$
-	return fCollectionSize;
-}
-
-public IMethodProxy getCollectionToArray() {
-	if (fCollectionToArray == null)
-		fCollectionToArray = fCollectionType.getMethodProxy("toArray"); //$NON-NLS-1$
-	return fCollectionToArray;
-}
-
-public IMethodProxy getCollectionToArrayWithArray() {
-	if (fCollectionToArrayWithArray == null)
-		fCollectionToArrayWithArray = fCollectionType.getMethodProxy("toArray", "[Ljava.lang.Object;"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fCollectionToArrayWithArray;
-}
-
-/**
- * Iterator accessors
- */
-
-public IMethodProxy getIteratorHasNext() {
-	if (fIteratorHasNext == null)
-		fIteratorHasNext = fIteratorType.getMethodProxy("hasNext"); //$NON-NLS-1$
-	return fIteratorHasNext;
-}
-
-public IMethodProxy getIteratorNext() {
-	if (fIteratorNext == null)
-		fIteratorNext = fIteratorType.getMethodProxy("next"); //$NON-NLS-1$
-	return fIteratorNext;
-}
-
-public IMethodProxy getIteratorRemove() {
-	if (fIteratorRemove == null)
-		fIteratorRemove = fIteratorType.getMethodProxy("remove"); //$NON-NLS-1$
-	return fIteratorRemove;
-}
-
-/**
- * Listaccessors
- */
-
-public IMethodProxy getListAddWithInt() {
-	if (fListAddWithInt == null)
-		fListAddWithInt = fListType.getMethodProxy("add", new String[] {"int", "java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fListAddWithInt;
-}
-
-public IMethodProxy getListAddAllWithInt() {
-	if (fListAddAllWithInt == null)
-		fListAddAllWithInt = fListType.getMethodProxy("addAll", new String[] {"int", "java.util.Collection"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fListAddAllWithInt;
-}
-
-public IMethodProxy getListGet() {
-	if (fListGet == null)
-		fListGet = fListType.getMethodProxy("get", "int"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListGet;
-}
-
-public IMethodProxy getListIndexOf() {
-	if (fListIndexOf == null)
-		fListIndexOf = fListType.getMethodProxy("indexOf", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListIndexOf;
-}
-
-public IMethodProxy getListLastIndexOf() {
-	if (fListLastIndexOf == null)
-		fListLastIndexOf = fListType.getMethodProxy("lastIndexOf", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListLastIndexOf;
-}
-
-public IMethodProxy getListListIterator() {
-	if (fListListIterator == null)
-		fListListIterator = fListType.getMethodProxy("listIterator"); //$NON-NLS-1$
-	return fListListIterator;
-}
-
-public IMethodProxy getListListIteratorWithInt() {
-	if (fListListIteratorWithInt == null)
-		fListListIteratorWithInt = fListType.getMethodProxy("listIterator", "int"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListListIteratorWithInt;
-}
-
-public IMethodProxy getListRemoveInt() {
-	if (fListRemoveInt == null)
-		fListRemoveInt = fListType.getMethodProxy("remove", "int"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListRemoveInt;
-}
-
-public IMethodProxy getListSet() {
-	if (fListSet == null)
-		fListSet = fListType.getMethodProxy("set", new String[] {"int", "java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fListSet;
-}
-
-public IMethodProxy getListSubList() {
-	if (fListSubList == null)
-		fListSubList = fListType.getMethodProxy("subList", new String[] {"int", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fListSubList;
-}
-
-/**
- * ListIterator accessors
- */
- 
-public IMethodProxy getListIteratorAdd() {
-	if (fListIteratorAdd == null)
-		fListIteratorAdd = fListIteratorType.getMethodProxy("add", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListIteratorAdd;
-}
-
-public IMethodProxy getListIteratorHasPrevious() {
-	if (fListIteratorHasPrevious == null)
-		fListIteratorHasPrevious = fListIteratorType.getMethodProxy("hasPrevious"); //$NON-NLS-1$
-	return fListIteratorHasPrevious;
-}
-
-public IMethodProxy getListIteratorNextIndex() {
-	if (fListIteratorNextIndex == null)
-		fListIteratorNextIndex = fListIteratorType.getMethodProxy("nextIndex"); //$NON-NLS-1$
-	return fListIteratorNextIndex;
-}
-
-public IMethodProxy getListIteratorPrevious() {
-	if (fListIteratorPrevious == null)
-		fListIteratorPrevious = fListIteratorType.getMethodProxy("previous"); //$NON-NLS-1$
-	return fListIteratorPrevious;
-}
-
-public IMethodProxy getListIteratorPreviousIndex() {
-	if (fListIteratorPreviousIndex == null)
-		fListIteratorPreviousIndex = fListIteratorType.getMethodProxy("previousIndex"); //$NON-NLS-1$
-	return fListIteratorPreviousIndex;
-}
-
-public IMethodProxy getListIteratorSet() {
-	if (fListIteratorSet == null)
-		fListIteratorSet = fListIteratorType.getMethodProxy("set", "java.lang.Object"); //$NON-NLS-1$ //$NON-NLS-2$
-	return fListIteratorSet;
-}
-
-public IMethodProxy getListIteratorRemove() {
-	if (fListIteratorRemove == null)
-		fListIteratorRemove = fListIteratorType.getMethodProxy("remove"); //$NON-NLS-1$
-	return fListIteratorRemove;
-}
-
-protected IMethodProxy getSystemArraycopy() {
-	if (fSystemArraycopy == null)
-		fSystemArraycopy = fSystemType.getMethodProxy("arraycopy", new String[] {"java.lang.Object", "int", "java.lang.Object", "int", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
-	return fSystemArraycopy;
-}
-
-/**
- * Enumeration accessors
- */
-public IMethodProxy getEnumerationHasMoreElements() {
-	if (fEnumerationHasMoreElements == null)
-		fEnumerationHasMoreElements = fEnumerationType.getMethodProxy("hasMoreElements"); //$NON-NLS-1$
-	return fEnumerationHasMoreElements;
-}
-
-public IMethodProxy getEnumerationNextElement() {
-	if (fEnumerationNextElement == null)
-		fEnumerationNextElement = fEnumerationType.getMethodProxy("nextElement"); //$NON-NLS-1$
-	return fEnumerationNextElement;
-}
-
-/**
- * Utility function to copy an array.
- */
-public void arraycopy(IBeanProxy src, int srcPosition, IBeanProxy dest, int destPosition, int length) throws ThrowableProxy {
-	IStandardBeanProxyFactory factory = src.getProxyFactoryRegistry().getBeanProxyFactory();
-	IBeanProxy[] args = new IBeanProxy[] {
-		src,
-		factory.createBeanProxyWith(srcPosition),
-		dest,
-		factory.createBeanProxyWith(destPosition),
-		factory.createBeanProxyWith(length)		
-	};
-	
-	getSystemArraycopy().invoke(null, args);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListBeanProxyWrapper.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListBeanProxyWrapper.java
deleted file mode 100644
index f9a2518..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListBeanProxyWrapper.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ListBeanProxyWrapper.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import java.text.MessageFormat;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-/**
- * This is a wrapper for an java.util.Collection proxy.
- * It provides the collection methods to interface to
- * the proxy.
- */
-
-public class ListBeanProxyWrapper extends CollectionBeanProxyWrapper {
-	/**
-	 * Construct with the List.
-	 */
-	public ListBeanProxyWrapper(IBeanProxy aListProxy) {
-		super(aListProxy);
-		
-		if (!aListProxy.getTypeProxy().isKindOf(aListProxy.getProxyFactoryRegistry().getBeanTypeProxyFactory().getBeanTypeProxy("java.util.List"))) //$NON-NLS-1$
-			throw new ClassCastException(MessageFormat.format(ProxyMessages.ClassCast_EXC__IncorrectType, new Object[] {aListProxy.getTypeProxy().getTypeName(), "java.util.List"})); 
-	}
-	
-	
-	/**
-	 * List accessors
-	 */
-	public void add(int index, IBeanProxy object) throws ThrowableProxy {
-		fConstants.getListAddWithInt().invoke(fCollection, new IBeanProxy[] {fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(index), object});
-	}
-	public boolean addAll(int index, IBeanProxy aCollection) throws ThrowableProxy {
-		return ((IBooleanBeanProxy) fConstants.getListAddAllWithInt().invoke(fCollection, new IBeanProxy[] {fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(index), aCollection})).booleanValue();
-	}
-	public IBeanProxy get(int index) throws ThrowableProxy {
-		return fConstants.getListGet().invoke(fCollection, fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(index));
-	}
-	public int indexOf(IBeanProxy object) {
-		try {
-			return ((IIntegerBeanProxy) fConstants.getListIndexOf().invoke(fCollection, object)).intValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return -1;
-		}			
-	}
-	public int lastIndexOf(IBeanProxy object) {
-		try {
-			return ((IIntegerBeanProxy) fConstants.getListLastIndexOf().invoke(fCollection, object)).intValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return -1;
-		}			
-	}
-	public ListIteratorBeanProxyWrapper listIterator() {
-		try {
-			IBeanProxy itr = fConstants.getListListIterator().invoke(fCollection);
-			if (itr != null)
-				return new ListIteratorBeanProxyWrapper(itr);
-			else
-				return null;
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return null;
-		}			
-	}
-	public ListIteratorBeanProxyWrapper listIterator(int index) {
-		try {
-			IBeanProxy itr = fConstants.getListListIteratorWithInt().invoke(fCollection, fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(index));
-			if (itr != null)
-				return new ListIteratorBeanProxyWrapper(itr);
-			else
-				return null;
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return null;
-		}			
-	}
-	public IBeanProxy remove(int index, IBeanProxy object) throws ThrowableProxy {
-		return fConstants.getListSet().invoke(fCollection, fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(index));
-	}
-	public IBeanProxy set(int index, IBeanProxy object) throws ThrowableProxy {
-		return fConstants.getListRemoveInt().invoke(fCollection, new IBeanProxy[] {fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(index), object});
-	}											
-	public ListBeanProxyWrapper subList(int fromIndex, int toIndex) throws ThrowableProxy {
-		IBeanProxy list = fConstants.getListSubList().invoke(fCollection, new IBeanProxy[] {fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(fromIndex), fCollection.getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(toIndex)});
-		if (list != null)
-			return new ListBeanProxyWrapper(list);
-		else
-			return null;		
-	}
-												
-		
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListIteratorBeanProxyWrapper.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListIteratorBeanProxyWrapper.java
deleted file mode 100644
index 9e5b5a8..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListIteratorBeanProxyWrapper.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ListIteratorBeanProxyWrapper.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-import java.text.MessageFormat;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-/**
- * This is a wrapper for an java.util.ListIterator proxy.
- * It provides the ListIterator methods to interface to
- * the proxy.
- */
-
-public class ListIteratorBeanProxyWrapper extends IteratorBeanProxyWrapper {
-
-	/**
-	 * Construct with the ListIterator.
-	 */
-	public ListIteratorBeanProxyWrapper(IBeanProxy anIteratorProxy) {
-		super(anIteratorProxy);
-		
-		if (!anIteratorProxy.getTypeProxy().isKindOf(anIteratorProxy.getProxyFactoryRegistry().getBeanTypeProxyFactory().getBeanTypeProxy("java.util.ListIterator"))) //$NON-NLS-1$
-			throw new ClassCastException(MessageFormat.format(ProxyMessages.ClassCast_EXC__IncorrectType, new Object[] {anIteratorProxy.getTypeProxy().getTypeName(), "java.util.ListIterator"})); 
-	}
-	
-	
-	/**
-	 * ListIterator accessors
-	 */
-	public void add(IBeanProxy object) throws ThrowableProxy {
-		fConstants.getListIteratorAdd().invoke(fIterator, object);
-	}
-	public boolean hasPrevious() {
-		try {
-			return ((IBooleanBeanProxy) fConstants.getListIteratorHasPrevious().invoke(fIterator)).booleanValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return false;
-		}			
-	}
-	public int nextIndex() {
-		try {
-			return ((IIntegerBeanProxy) fConstants.getListIteratorNextIndex().invoke(fIterator)).intValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return -1;
-		}			
-	}			
-	public IBeanProxy previous() throws ThrowableProxy {
-		return fConstants.getListIteratorPrevious().invoke(fIterator);
-	}
-	public int previousIndex() {
-		try {
-			return ((IIntegerBeanProxy) fConstants.getListIteratorPreviousIndex().invoke(fIterator)).intValue();
-		} catch (ThrowableProxy e) {
-			// This shouldn't occur, so just log it.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.UnexpectedException_EXC_, e)); 
-			return -1;
-		}
-	}
-	public void remove() throws ThrowableProxy {
-		fConstants.getListIteratorRemove().invoke(fIterator);
-	}
-	public void set(IBeanProxy object) throws ThrowableProxy {
-		fConstants.getListIteratorSet().invoke(fIterator, object);
-	}				
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListenerList.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListenerList.java
deleted file mode 100644
index ecd90a0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ListenerList.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ListenerList.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-/**
- * This class is used to maintain a list of listeners, and
- * is used in the implementations of several classes within jem
- * which allow you to register listeners of various kinds.
- * It is a fairly lightweight object, occupying minimal space when
- * no listeners are registered.
- * <p>
- * Note that the <code>add</code> method checks for and eliminates 
- * duplicates based on identity (not equality).  Likewise, the
- * <code>remove</code> method compares based on identity.
- * </p>
- * <p>
- * Use the <code>getListeners</code> method when notifying listeners.
- * Note that no garbage is created if no listeners are registered.
- * The recommended code sequence for notifying all registered listeners
- * of say, <code>FooListener.eventHappened</code>, is:
- * <pre>
- * Object[] listeners = myListenerList.getListeners();
- * for (int i = 0; i < listeners.length; ++i) {
- *    ((FooListener) listeners[i]).eventHappened(event);
- * }
- * </pre>
- * </p>
- */
-
-public class ListenerList {
-
-	/**
-	 * The initial capacity of the list. Always >= 1.
-	 */
-	private int capacity;
-
-	/**
-	 * The current number of listeners.
-	 * Maintains invariant: 0 <= size <= listeners.length.
-	 */
-	private int size;
-
-	/**
-	 * The list of listeners.  Initially <code>null</code> but initialized
-	 * to an array of size capacity the first time a listener is added.
-	 * Maintains invariant: listeners != null IFF size != 0
-	 */
-	private Object[] listeners = null;
-
-	/**
-	 * The empty array singleton instance, returned by getListeners()
-	 * when size == 0.
-	 */
-	private static final Object[] EmptyArray = new Object[0];
-
-	/**
-	 * Creates a listener list with an initial capacity of 1.
-	 */
-	public ListenerList() {
-		this(1);
-	}
-
-	/**
-	 * Creates a listener list with the given initial capacity.
-	 *
-	 * @param capacity the number of listeners which this list can initially accept 
-	 *    without growing its internal representation; must be at least 1
-	 */
-	public ListenerList(int capacity) {
-		if (!(capacity >= 1))
-			throw new IllegalArgumentException();
-		this.capacity = capacity;
-	}
-
-	/**
-	 * Adds the given listener to this list. Has no effect if an identical listener
-	 * is already registered.
-	 *
-	 * @param listener the listener
-	 */
-	public void add(Object listener) {
-		if (listener == null)
-			throw new IllegalArgumentException();
-		if (size == 0) {
-			listeners = new Object[capacity];
-		} else {
-			// check for duplicates using identity
-			for (int i = 0; i < size; ++i) {
-				if (listeners[i] == listener) {
-					return;
-				}
-			}
-			// grow array if necessary
-			if (size == listeners.length) {
-				System.arraycopy(
-					listeners,
-					0,
-					listeners = new Object[size * 2 + 1],
-					0,
-					size);
-			}
-		}
-		listeners[size++] = listener;
-	}
-
-	/**
-	 * Removes all listeners from this list.
-	 */
-	public void clear() {
-		size = 0;
-		listeners = null;
-	}
-
-	/**
-	 * Returns an array containing all the registered listeners,
-	 * in the order in which they were added.
-	 * <p>
-	 * The resulting array is unaffected by subsequent adds or removes.
-	 * If there are no listeners registered, the result is an empty array
-	 * singleton instance (no garbage is created).
-	 * Use this method when notifying listeners, so that any modifications
-	 * to the listener list during the notification will have no effect on the
-	 * notification itself.
-	 * </p>
-	 *
-	 * @return the list of registered listeners
-	 */
-	public Object[] getListeners() {
-		if (size == 0)
-			return EmptyArray;
-		Object[] result = new Object[size];
-		System.arraycopy(listeners, 0, result, 0, size);
-		return result;
-	}
-
-	/**
-	 * Returns whether this listener list is empty.
-	 *
-	 * @return <code>true</code> if there are no registered listeners, and
-	 *   <code>false</code> otherwise
-	 */
-	public boolean isEmpty() {
-		return size == 0;
-	}
-
-	/**
-	 * Removes the given listener from this list. Has no effect if an identical
-	 * listener was not already registered.
-	 *
-	 * @param listener the listener
-	 */
-	public void remove(Object listener) {
-		if (listener == null)
-			throw new IllegalArgumentException();
-		for (int i = 0; i < size; ++i) {
-			if (listeners[i] == listener) {
-				if (size == 1) {
-					listeners = null;
-					size = 0;
-				} else {
-					System.arraycopy(
-						listeners,
-						i + 1,
-						listeners,
-						i,
-						--size - i);
-					listeners[size] = null;
-				}
-				return;
-			}
-		}
-	}
-
-	/**
-	 * Returns the number of registered listeners.
-	 *
-	 * @return the number of registered listeners
-	 */
-	public int size() {
-		return size;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/MapJNITypes.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/MapJNITypes.java
deleted file mode 100644
index e1be81d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/MapJNITypes.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: MapJNITypes.java,v $
- *  $Revision: 1.3 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.jem.internal.proxy.common.MapTypes;
- 
-
-/**
- * This is a public class to map between JNI and normal format (e.g. "[Ljava.lang.String;" to "java.lang.String[]") and back again.
- * This is for arrays, non-arrays will be left alone since they are already correct.
- * @since 1.1.0
- */
-public class MapJNITypes {
-
-	/**
-	 * Convert the formal type name to the JNI format.
-	 * @param formalTypeName
-	 * @return JNI format
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String getJNITypeName(String formalTypeName) {
-		return MapTypes.getJNIFormatName(formalTypeName);
-	}
-	
-	/**
-	 * Convert the JNI format to the formal type name.
-	 * @param jniTypeName
-	 * @return formal type name or "" if not valid.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String getFormalTypeName(String jniTypeName) {
-		return MapTypes.getFormalTypeName(jniTypeName);
-	}
-	
-	/**
-	 * Return whether the formal type name is for a primitive or not.
-	 * @param formalType
-	 * @return <code>true</code> if for a primitive.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static boolean isFormalTypePrimitive(String formalType) {
-		return MapTypes.MAP_TYPENAME_TO_SHORTSIG.get(formalType) != null;
-	}
-	
-	/**
-	 * Convert the formal type name, with the given number of dimensions,
-	 * to an array JNI type.
-	 * @param finalComponent final component name, should not be an array type.
-	 * @param dimensions number of dimensions for the array.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String getJNITypeName(String finalComponent, int dimensions) {
-		return MapTypes.getJNITypeName(finalComponent, dimensions);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEContributeClasspath.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEContributeClasspath.java
deleted file mode 100644
index 0ddc64a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEContributeClasspath.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PDEContributeClasspath.java,v $
- *  $Revision: 1.5 $  $Date: 2005/10/14 17:45:02 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.io.File;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.*;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.pde.core.plugin.*;
-import org.eclipse.pde.internal.core.*;
-
- 
-
-/**
- * Contribute to classpath PDE entries that are needed for a launch.
- * <p>
- * This is a special class that should not be referenced directly from code. Reference it through the
- * interface that it implements. 
- * 
- * @see org.eclipse.jem.internal.proxy.core.IPDEContributeClasspath
- * @since 1.0.2
- */
-class PDEContributeClasspath implements IPDEContributeClasspath {
-
-	public void getPDEContributions(IConfigurationContributionController controller, IConfigurationContributionInfo info) throws CoreException {
-		if (!info.getPluginIds().isEmpty()) {
-			Collection pluginIds = info.getPluginIds().keySet();
-			PluginModelManager modelManager = PDECore.getDefault().getModelManager();
-			IFragmentModel[] fragments = modelManager.getFragments();
-			for (int i = 0; i < fragments.length; i++) {
-				IFragment fragment = fragments[i].getFragment();
-				if (pluginIds.contains(fragment.getPluginId())) {
-					// We'll do a cheat for now and assume fragment is for same version of plugin. PDECore actually
-					// checks the version of the fragment against the version of the plugin to see they are for each
-					// other, but we'll just assume they are for now. Change this later if we actually do run into this case.
-					IResource resource = fragment.getModel().getUnderlyingResource();
-					if (resource != null) {
-						IProject fragProject = resource.getProject();
-						if (fragProject.hasNature(JavaCore.NATURE_ID)) {
-							controller.contributeProject(fragProject);
-						}
-						continue;
-					}
-
-					IPluginLibrary[] libraries = fragment.getLibraries();
-					for (int j = 0; j < libraries.length; j++) {
-						IPluginLibrary library = libraries[j];
-						String name = library.getName();
-						String expandedName = ClasspathUtilCore.expandLibraryName(name);
-
-						IPluginModelBase model = library.getPluginModel();
-						URL url = getPath(model, expandedName);
-						if (url != null)
-							controller.contributeClasspath(url, IConfigurationContributionController.APPEND_USER_CLASSPATH);
-					}
-				}
-			}
-		}
-		
-		return;
-	}
-	
-	private URL getPath(IPluginModelBase model, String libraryName) {
-		try {
-			IResource resource = model.getUnderlyingResource();
-			if (resource != null) {
-				IResource jarFile = resource.getProject().findMember(libraryName);
-				if (jarFile != null)
-					return jarFile.getFullPath().toFile().toURL();
-			} else {
-				File file = new File(model.getInstallLocation(), libraryName);
-				if (file.exists())
-					return file.toURL();
-			}
-		} catch (MalformedURLException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-		}
-		return null;
-	}
-	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEContributeClasspathInstance.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEContributeClasspathInstance.java
deleted file mode 100644
index 304b714..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEContributeClasspathInstance.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PDEContributeClasspathInstance.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.util.logging.Level;
-
-import org.eclipse.core.runtime.Platform;
-
- 
-
-/**
- * Accessor to the IPDEContributeClasspath instance to use.
- * <pacakge-protected> because only IPDEContributeClasspath should access it.
- * 
- * @since 1.0.2
- */
-class PDEContributeClasspathInstance {
-
-	/**
-	 * Get the instance to use. 
-	 * @return the instance to use or <code>null</code> if PDE not available.
-	 * 
-	 * @since 1.0.2
-	 */
-	public static IPDEContributeClasspath getInstance() {
-		if (Platform.getBundle("org.eclipse.pde.core") != null) { //$NON-NLS-1$
-			try {
-				Class pdeClass = Class.forName("org.eclipse.jem.internal.proxy.core.PDEContributeClasspath"); //$NON-NLS-1$
-				return (IPDEContributeClasspath) pdeClass.newInstance();
-			} catch (ClassNotFoundException e) {
-				// PDE not available, this is ok.
-			} catch (InstantiationException e) {
-				ProxyPlugin.getPlugin().getLogger().log(e.getCause(), Level.WARNING);
-			} catch (IllegalAccessException e) {
-				ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-			}
-		}
-		return null;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEProcessForPlugin.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEProcessForPlugin.java
deleted file mode 100644
index 8095aca..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/PDEProcessForPlugin.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PDEProcessForPlugin.java,v $
- *  $Revision: 1.7 $  $Date: 2005/10/14 17:45:02 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.pde.core.plugin.*;
-import org.eclipse.pde.internal.core.PDECore;
-
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin.FoundIDs;
- 
-
-/*
- * Used for PDE Processing for the Proxy Plugin class. It will be optionally loaded
- * if PDE plugin is installed. This allows usage in an installation that doesn't have
- * PDE installed.
- * 
- * @since 1.0.2
- */
-class PDEProcessForPlugin implements ProxyPlugin.IPDEProcessForPlugin {
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.ProxyPlugin.IPDEProcessForPlugin#processPlugin(org.eclipse.jdt.core.IJavaProject, java.util.Map, boolean, boolean)
-	 */
-	public void findPlugins(IJavaProject project, FoundIDs foundIds, boolean visible, boolean first) {
-		IPluginModelBase m = PDECore.getDefault().getModelManager().findModel(project.getProject());
-		if (m instanceof IPluginModel) {
-			// it is a plugin, process it.
-			IPlugin plugin = ((IPluginModel) m).getPlugin();
-			if (foundIds.pluginIds.containsKey(plugin.getId()))
-				return;	// already processed it
-			foundIds.pluginIds.put(plugin.getId(), first || visible ? Boolean.TRUE : Boolean.FALSE);			
-			expandPlugin(plugin, foundIds, visible, first);
-		}
-		return;
-	}
-	
-	private void expandPlugin(IPlugin plugin, FoundIDs foundIds, boolean visible, boolean first) {
-		IPluginImport[] imports = plugin.getImports();
-		for (int i = 0; i < imports.length; i++) {
-			IPluginImport pi = imports[i];
-			Boolean piValue = (Boolean) foundIds.pluginIds.get(pi.getId());
-			boolean importVisible = first || (visible && pi.isReexported());
-			if (piValue != null && (!importVisible || piValue.booleanValue()))
-				continue;	// we already processed it, this time not visible, or this time visible and was previously visible.
-			// Now either first time, or it was there before, but now visible, but this time it is visible.
-			// We want it to become visible in that case. 
-			foundIds.pluginIds.put(pi.getId(), importVisible ? Boolean.TRUE : Boolean.FALSE);			
-			IPlugin pb = PDECore.getDefault().findPlugin(pi.getId(),
-				pi.getVersion(),
-				pi.getMatch());
-			if (pb != null)
-				expandPlugin(pb, foundIds, importVisible, false);
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFactoryRegistry.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFactoryRegistry.java
deleted file mode 100644
index a4642fc..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFactoryRegistry.java
+++ /dev/null
@@ -1,327 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ProxyFactoryRegistry.java,v $
- *  $Revision: 1.14 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import java.util.Hashtable;
-import java.util.Iterator;
-
-import org.eclipse.jem.util.TimerTests;
-
-/**
- * Registry of proxy factories on a per-VM basis.
- * There can be multiple VM's, this would be required by the
- * desktop because more than one project could be open, and each
- * would require their own VM because the classpaths would be different.
- * This class may be subclassed to provide more factories for a particular
- * VM. 
- * Creation date: (3/13/00 10:48:10 AM)
- * @author: Richard Lee Kulp
- */
-public abstract class ProxyFactoryRegistry {
-	
-	protected boolean fIsValid = true;	// The registry is valid until terminated.
-	protected ListenerList registryListeners = new ListenerList();
-	
-	/**
-	 * IRegistryListener
-	 * Listen for the registry being terminated.
-	 */
-	public interface IRegistryListener {
-		/**
-		 * Method registryTerminated.
-		 * 
-		 * The registry has been terminated. When this is called the registry
-		 * is no longer valid. It should not be assumed any calls can be made
-		 * to the registry.
-		 * 
-		 * @param registry
-		 */
-		public void registryTerminated(ProxyFactoryRegistry registry);
-	}
-		
-
-	// Factory registration IS NOT a dynamic registration. Once registered for a VM or an instance
-	// they should not be changed. This is because references are cached in other objects.
-	// The VM associated with this Registry shouldn't exited and restarted because
-	// the cached object will then have invalid references to no longer existing objects.
-	// If the VM needs to be restarted, then all proxies need to be tossed.
-	
-	//
-	// Individual ProxyFactoryRegistry, applies to a particular VM.
-	//
-
-	// ***************************
-	//
-	// IBeanProxyFactory Registry
-	//
-	
-	// The standard bean  proxy factory, the one the desktop will use for packages that have not
-	// been extended and registered by customization developers.
-	protected IStandardBeanProxyFactory fCurrentStandardBeanProxyFactory;
-
-	// The directory of registered extension factories, typically registered by package.
-	final protected Hashtable fRegisteredExtensionBeanProxyFactories = new Hashtable();
-
-	// ***************************
-	//
-	// IBeanTypeProxyFactory Registry
-	//
-	
-	// The standard bean type proxy factory, the one the desktop will use for packages that have not
-	// been extended and registered by customization developers.
-	protected IStandardBeanTypeProxyFactory fCurrentStandardBeanTypeProxyFactory;
-
-	// The directory of registered extension factories, typically registered by package.
-	final protected Hashtable fRegisteredExtensionBeanTypeProxyFactories = new Hashtable();
-	
-
-	// ***************************
-	//
-	// Other factories
-	//
-		
-	protected IMethodProxyFactory fMethodProxyFactory = null;	// Method Proxy Factory
-
-	// ***************************
-	//
-	// Constants Registry. Different extensions can store
-	// objects by key as a registry of constants.
-	// For example, java.awt extension will store an object
-	// which has some pre-fetched method proxies stored in it so
-	// that they don't need to be continually recreated.
-	//
-	// This feature should be used with care, so that
-	// only proxies that really need to be cached should
-	// be cached.
-	//
-	// Don't store proxies to live beans in here because
-	// those will be created and destroyed over and over,
-	// and the instance in this cache will get stale.
-	// Should only store things like often used method
-	// proxies that once created are rarely changed.
-	//
-	// Since the proxies can be on any VM, you should have
-	// an interface defining what's available in your
-	// constants entry, and access it through that.
-
-	protected final Hashtable fRegisteredConstants = new Hashtable();		
-
-	/**
-	 * ProxyFactoryRegistry constructor comment.
-	 */
-	public ProxyFactoryRegistry() {
-		super();
-	}
-	
-	/**
-	 * Method addRegistryListener.
-	 * @param listener
-	 */
-	public void addRegistryListener(IRegistryListener listener) {
-		registryListeners.add(listener);
-	}
-	
-	/**
-	 * Method removeRegistryListener.
-	 * @param listener
-	 */
-	public void removeRegistryListener(IRegistryListener listener) {
-		registryListeners.remove(listener);
-	}
-	
-	protected void fireRegistryTerminated() {
-		if (!registryListeners.isEmpty()) {
-			Object[] list = registryListeners.getListeners();
-			for (int i = 0; i < list.length; i++) {
-				((IRegistryListener) list[i]).registryTerminated(this);
-			}
-		}
-	}
-	
-	/**
-	 Return the current factory to be used for creating IBeanProxy instances
-	 */
-	public IStandardBeanProxyFactory getBeanProxyFactory() {
-		if (fCurrentStandardBeanProxyFactory == null) {
-			throw new RuntimeException(ProxyMessages.ProxyFactory_EXC__NoBeanProxyFactory);
-		}
-		return fCurrentStandardBeanProxyFactory;
-	}
-	/**
-	 Return the current registered bean proxy factory to be used for creating IBeanProxy instances
-	 */
-	public IBeanProxyFactory getBeanProxyFactoryExtension(String packageName) {
-		return (IBeanProxyFactory)fRegisteredExtensionBeanProxyFactories.get(packageName);
-	}
-	
-	/**
-	 Return the current factory to be used for creating IBeanTypeProxy instances
-	 */
-	public IStandardBeanTypeProxyFactory getBeanTypeProxyFactory() {
-		if (fCurrentStandardBeanTypeProxyFactory == null) {
-			throw new RuntimeException(ProxyMessages.ProxyFactory_EXC__NoBeanTypeProxyFactory);
-		}
-		return fCurrentStandardBeanTypeProxyFactory;
-	}
-	/**
-	 Return the current registered bean type proxy factory to be used for creating IBeanTypeProxy instances
-	 */
-	public IBeanTypeProxyFactory getBeanTypeProxyFactoryExtension(String packageName) {
-		return (IBeanTypeProxyFactory)fRegisteredExtensionBeanTypeProxyFactories.get(packageName);
-	}
-	/**
-	 * Return the requested constants entry
-	 */
-	public Object getConstants(Object key) {
-		return fRegisteredConstants.get(key);
-	}
-	/**
-	 * Return the MethodProxyFactory for this VM.
-	 * Creation date: (3/13/00 10:54:59 AM)
-	 * @return org.eclipse.jem.internal.proxy.core.IMethodProxyFactory
-	 */
-	public IMethodProxyFactory getMethodProxyFactory() {
-		return fMethodProxyFactory;
-	}
-	
-	
-	/**
-	 * Set the requested constants entry for this VM.
-	 */
-	public void registerConstants(Object key, Object constant) {
-		fRegisteredConstants.put(key, constant);
-	}
-    
-    /**
-     * Remove the constants for the given key.
-     * @param key
-     * 
-     * @since 1.1.0
-     */
-    public void deregisterConstants(Object key) {
-        fRegisteredConstants.remove(key);
-    }
-	/**
-	 * Release the proxy, no longer needed.
-	 * This is a helper method to easily access the release from the bean proxy factory.
-	 */
-	public void releaseProxy(IBeanProxy proxy) {
-		// To simply things if release is called when the factory is down (invalid), then just
-		// go on because the proxy is already released.
-		if (fCurrentStandardBeanProxyFactory != null)
-			fCurrentStandardBeanProxyFactory.releaseProxy(proxy);
-	} 
-
-	/**
-	 * Is this a valid registry, i.e. is it not terminated.
-	 */
-	public boolean isValid() {
-		return fIsValid;
-	}
-	
-	/**
-	 * Terminate the registry without waiting.
-	 * <p>
-	 * Terminate the registry, but don't necessarily wait for it.
-	 *
-	 * @see #terminateRegistry(boolean)
-	 * @since 1.0.0
-	 */
-	public final void terminateRegistry() {
-		terminateRegistry(false);
-	}
-		
-	/**
-	 * Terminate the registry.
-	 * <p>
-	 * This will go through each factory and terminate it, and
-	 * let the subclass terminate. It will then remove all of the factories so that
-	 * if there are any proxies still hanging around they won't hold onto everything,
-	 * just the this registry will be held onto.
-	 *<p>
-	 * Note during termination, the factories should not reference any other factory.
-	 * It can assume that the factories will take care of themselves and they should
-	 * only release their resources.
-	 * <p>
-	 * The constants registry will not be terminated because they aren't factories.
-	 * However, they will be cleared (no longer referenced) from here so that they
-	 * can be GC'd.
-	 * 
-	 * @param wait <code>true</code> to wait for complete termination, <code>false</code> to kick off termination but return ASAP.
-	 * @since 1.0.2
-	 */
-	public final void terminateRegistry(boolean wait) {
-		if (!fIsValid)
-			return;	// Already or are already terminating. Don't do it again and don't notify again.
-		fIsValid = false;
-		if (fCurrentStandardBeanTypeProxyFactory != null) {
-//			TimerTests.basicTest.startStep("Terminate Bean Type Factory");
-			fCurrentStandardBeanTypeProxyFactory.terminateFactory(wait);
-//			TimerTests.basicTest.stopStep("Terminate Bean Type Factory");
-			fCurrentStandardBeanTypeProxyFactory = null;
-		}
-		if (fCurrentStandardBeanProxyFactory != null) {
-			fCurrentStandardBeanProxyFactory.terminateFactory(wait);
-			fCurrentStandardBeanProxyFactory = null;
-		}
-		if (fMethodProxyFactory != null) {
-			fMethodProxyFactory.terminateFactory(wait);
-			fMethodProxyFactory = null;
-		}
-		
-		Iterator itr = fRegisteredExtensionBeanTypeProxyFactories.values().iterator();
-		while (itr.hasNext()) {
-			((IBeanProxyFactory) itr.next()).terminateFactory(wait);
-		}
-		fRegisteredExtensionBeanTypeProxyFactories.clear();
-		
-		itr = fRegisteredExtensionBeanProxyFactories.values().iterator();
-		while (itr.hasNext()) {
-			((IBeanProxyFactory) itr.next()).terminateFactory(wait);
-		}
-		fRegisteredExtensionBeanProxyFactories.clear();
-		
-		fRegisteredConstants.clear();
-		
-		TimerTests.basicTest.startStep("Registry Terminated"); //$NON-NLS-1$
-		registryTerminated(wait);
-		TimerTests.basicTest.stopStep("Registry Terminated"); //$NON-NLS-1$
-		
-//		TimerTests.basicTest.startStep("Registry Terminated Notification");
-		fireRegistryTerminated();	// Let everyone know that we are gone. This is fired even if wait is false because at this point in time the registry is invalid.
-//		TimerTests.basicTest.stopStep("Registry Terminated Notification");
-	}
-	
-
-	/**
-	 * Terminate the Registry. 
-	 * <p>
-	 * It is up to each registry to determine what this means.
-	 * <p>
-	 * The wait parm is a suggestion if it is <code>false</code>, but it must be honoured if <code>true</code>
-	 * 
-	 * @param wait wait for registry to terminate flag.
-	 * 
-	 * @since 1.0.2
-	 */
-	protected abstract void registryTerminated(boolean wait);
-	
-	/**
-	 * Get the callback registry.
-	 */
-	public abstract ICallbackRegistry getCallbackRegistry();
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFindSupport.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFindSupport.java
deleted file mode 100644
index 9a4c4ac..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFindSupport.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ProxyFindSupport.java,v $
- *  $Revision: 1.2 $  $Date: 2005/10/26 22:14:01 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.io.*;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.Properties;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Platform;
-import org.osgi.framework.Bundle;
- 
-
-/**
- * Utility to help finding files. It is used to find them within plugins of the current platform or to find them in the PDE target platform.
- * Also if in the current platform and the current platform is in development mode it will find the bin directories for the jars instead since
- * there are no jars in that case.
- * It can also extract non-local files (such as files within a jar) and make a cache of them so that are a local file and not extracted everytime
- * they are needed.
- *
- * TODO If we ever get back to continuing development we should add to this PDE Target support. And test the code here 
- * since it hasn't been tested yet. Also note that in configuration contributor,
- * when we add the library path we expect it to be a folder. This would be a problem with jarred plugins because the directory containing the
- * libraries may be the root of the plugin and localizing a directory would extract and cache the entire plugin. Need to change to figure out
- * how to only extract the dll/so needed instead. Also, none of these handle the case where the bundle is actually non-local (e.g. "http:/").
- * @since 1.2.0
- */
-public class ProxyFindSupport {
-
-	
-	/**
-	 * Find the filename relative to the platform bundle. It will search in the bundle and in all fragments for the file name.
-	 * It will return a URL for each found file.
-	 * <p>
-	 * This is useful for NLS purposes. In NLS situations the main bundle would contain the main non-library jar with the default properties files.
-	 * Then a fragment for each set of languages will be installed. Within each fragment will be a jar with the same filepath, and it will
-	 * contain the properties files for that language. This would be done only for plugin non-library jars. 
-	 * The NLS for library jars of a plugin (i.e. those jars that are the <runtime> jars for the plugin) are usually library jars themselves in
-	 * the fragment, and they usually have a different name than the main library jar. So this should not be used for library jars.
-	 * <p>
-	 * If in development mode, then if the jar is not found it will look in the plugin project's build.properties to find the output directory
-	 * of the jar. If not in the build.properties (meaning it isn't being built by PDE), it will look in the proxy.jars file (if there is one).
-	 * This file is used for jars that are built in a separate project from the plugin but will be found in the plugin at execution.
-	 * 
-	 * @param bundle bundle and its fragments to look in.
-	 * @param filenameWithinBundle path to filename within the bundle and fragments. <b>This must be a file, not a directory.</b> 
-	 *   For finding the bundle itself (only when the bundle is packaged as a jar), use <@link #platformFind(Bundle)>. This does not use
-	 *   the platform shortcuts like "$os$". It finds the files exactly as specified.
-	 * @param asLocal <code>true</code> if the urls need to point to local filesystem files. This may cause caching of files locally. This
-	 * could happen if the file is within a plugin that is jarred. <code>false</code> if the url can be a non-local filesystem url. 
-	 * @return array of URL's for found files. 
-	 * 
-	 * @since 1.2.0
-	 */
-	public static URL[] platformFindAll(Bundle bundle, IPath filenameWithinBundle, boolean asLocal) {
-		Bundle[] fragments = Platform.getFragments(bundle);
-		ArrayList urls = new ArrayList((fragments == null ? 0 : fragments.length) + 1);
-		String filename = filenameWithinBundle.toString();
-		URL url = internalFindFromBundleOnly(bundle, filename, asLocal);
-		if (url != null)
-			urls.add(url);
-		if (fragments != null) {
-			for (int i = 0; i < fragments.length; i++) {
-				Bundle fragment = fragments[i];
-				url = internalFindFromBundleOnly(fragment, filename, asLocal);
-				if (url != null)
-					urls.add(url);
-			}
-		}
-		return (URL[]) urls.toArray(new URL[urls.size()]);
-	}
-	
-	/**
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @param asLocal
-	 * @return
-	 * 
-	 * @since 1.2.0
-	 */
-	private static URL internalFindFromBundleOnly(Bundle bundle, String filenameWithinBundle, boolean asLocal) {
-		try {
-			URL pvm = bundle.getEntry(filenameWithinBundle);
-			if (pvm != null)
-				return asLocal ? Platform.asLocalURL(pvm) : pvm;
-		} catch (IOException e) {
-		}
-		if (ProxyPlugin.getPlugin().isDevMode()) {
-			return findDev(bundle, filenameWithinBundle, asLocal);
-		} else
-			return null;
-	}
-
-	/**
-	 * Find the filename relative to the platform bundle. It will search in the bundle and in all fragments for the file name. It will return
-	 * URL for the file if found.
-	 * <p>
-	 * If in development mode, then if the jar is not found it will look in the plugin project's build.properties to find the output directory
-	 * of the jar. If not in the build.properties (meaning it isn't being built by PDE), it will look in the proxy.jars file (if there is one).
-	 * This file is used for jars that are built in a separate project from the plugin but will be found in the plugin at execution.
-	 * 
-	 * @param bundle bundle and its fragments to look in.
-	 * @param filenameWithinBundle path to filename within the bundle and fragments. <b>This must be a file, not a directory.</b> 
-	 *   For finding the bundle itself (only when the bundle is packaged as a jar), use <@link #platformFind(Bundle)>.
-	 * @param asLocal <code>true</code> if the urls need to point to local filesystem files. This may cause caching of files locally. This
-	 * could happen if the file is within a plugin that is jarred. <code>false</code> if the url can be a non-local filesystem url.  
-	 * @return the found url or <code>null</code> if not found.
-	 * 
-	 * @since 1.2.0
-	 */
-	public static URL platformFind(Bundle bundle, IPath filenameWithinBundle, boolean asLocal) {
-		try {
-			URL pvm = Platform.find(bundle, filenameWithinBundle);
-			if (pvm != null)
-				return asLocal ? Platform.asLocalURL(pvm) : pvm;
-		} catch (IOException e) {
-		}
-		if (ProxyPlugin.getPlugin().isDevMode()) {
-			return findDev(bundle, filenameWithinBundle.toString(), asLocal);
-		} else
-			return null;
-		
-	}
-	
-	private static final String BUILDPROPERTIES = "build.properties";	//$NON-NLS-1$
-	private static final String PROXYJARS = "proxy.jars";	//$NON-NLS-1$
-	
-	private static URL findDev(Bundle bundle, String filenameWithinBundle, boolean asLocal) {
-		// Got this far and in dev mode means it wasn't found, so we'll try for development style.
-		// It is assumed that in dev mode, we are running with the IDE as local and any 
-		// build outputs will be local so local file protocol will be returned
-		// from Platform.resolve(). We won't be running in dev mode with our entireplugin being in a jar,
-		// or on a separate system.
-		try {
-			URL bp = bundle.getEntry(BUILDPROPERTIES);
-			if (bp != null) {
-				InputStream ios = null;
-				try {
-					ios = bp.openStream();
-					Properties props = new Properties();
-					props.load(ios);
-					String pathString = props.getProperty("output."+filenameWithinBundle.toString());
-					if (pathString != null) {
-						URL pvm = bundle.getEntry(pathString);
-						if (pvm != null)
-							return asLocal ? Platform.asLocalURL(pvm) : pvm;
-					}
-				} finally {
-					if (ios != null)
-						ios.close();
-				}
-			}
-		} catch (IOException e) {
-		}
-
-		try {
-			URL pvm = bundle.getEntry(PROXYJARS);
-			if (pvm != null) {
-				InputStream ios = null;
-				try {
-					ios = pvm.openStream();
-					Properties props = new Properties();
-					props.load(ios);
-					String pathString = props.getProperty(filenameWithinBundle.toString());
-					if (pathString != null) {
-						URL url = Platform.resolve(bundle.getEntry("/"));	// It is assumed that if in debug mode, then this plugin is an imported plugin within the developement workspace. //$NON-NLS-1$
-						if (url.getProtocol().equals("file")) { //$NON-NLS-1$
-							File file = new File(url.getFile()).getParentFile();	// This gets us to workspace root of development workspace.
-							file = new File(file, pathString);
-							return file.toURL();
-						}
-					}
-				} finally {
-					if (ios != null)
-						ios.close();
-				}
-			}
-		} catch (IOException e) {
-		}
-		return null;
-	}
-
-	
-	/**
-	 * Find the bundle and all active fragments libraries. This should normally be used only when the bundle is packaged as a jar and not as a directory. It will
-	 * return the urls to the jars of the bundle and fragments. If in development mode it will find the bundle's "." output directory.
-	 * @param bundle
-	 * @return array of URL's for the jarred bundle and fragments. If the bundle/fragments are not packaged as jars, then the array will be empty.
-	 * 
-	 * @since 1.2.0
-	 */
-	public static URL[] platformFind(Bundle bundle) {
-		return null;
-	}
-	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyLaunchSupport.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyLaunchSupport.java
deleted file mode 100644
index fa1e87c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyLaunchSupport.java
+++ /dev/null
@@ -1,863 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ProxyLaunchSupport.java,v $
- *  $Revision: 1.30 $  $Date: 2005/10/26 14:24:51 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.io.File;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.text.MessageFormat;
-import java.util.*;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.IJobManager;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.debug.core.*;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo.ContainerPaths;
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin.FoundIDs;
-import org.eclipse.jem.util.PerformanceMonitorUtil;
-import org.eclipse.jem.util.TimerTests;
-
- 
-/**
- * This is the used to launch the proxy registries.
- * This is a static helper class, it is not meant to be instantiated.
- * 
- * @since 1.0.0
- */
-public class ProxyLaunchSupport {
-	
-	// The key for the persisten property is in ProxyPlugin so that it can set it on startup without
-	// causing this class to be initialized. We don't want this class initialized until the very last
-	// moment when needed. This is because it needs UI to be active when initialized to query some 
-	// values and if ProxyPlugin.start() causes this class to initialize, it may be too soon.
-	//
-	// If a project's persistent property is set with this value, that means there is at least one
-	// launch configuration with this project, but none are selected as the default. This is here
-	// so that we can check in the object contribution that if not set then don't show the menu
-	// item at all. This is to clean up the popup menu so not so cluttered.
-	// If the property is trully not set, then there is no default and there are no configurations for it.
-	public static final String NOT_SET = "...not..set..";	  //$NON-NLS-1$
-		
-	public static final String EXPRESSION_TRACING = "/debug/traceexpressions";	// Trace IExpressions. //$NON-NLS-1$
-	
-	/**
-	 * Timer threshold for indicating any expressions that took longer than this.
-	 * If not set, then threshold will default to 100ms.
-	 * It will only be used if traceexpressions is true.
-	 */
-	public static final String EXPRESSION_TRACEING_TIMER_THRESHOLD = "/debug/traceexpressionstimethreshold";	 //$NON-NLS-1$
-	
-	/*
-	 * Registry of launch key to LaunchInfo classes.
-	 */
-	private static Map LAUNCH_INFO = new HashMap(2);
-
-	/**
-	 * Public only for access by other launch delegates to set up if they go outside of ProxyLaunchSupport,
-	 * e.g. IDE proxy. Must not be used for any purpose.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static class LaunchSupportIConfigurationContributionInfo implements IConfigurationContributionInfo {
-		
-		/**
-		 * Construct with no settings. This is to be used by other launch delegates that
-		 * don't have a {@link FoundIDs} available to fill in the fields. Those 
-		 * delegates must fill the fields themselves.  
-		 * 
-		 * 
-		 * @since 1.2.0
-		 */
-		public LaunchSupportIConfigurationContributionInfo(IJavaProject javaProject) {
-			this.javaProject = javaProject;
-		}
-		
-		public LaunchSupportIConfigurationContributionInfo(IJavaProject javaProject, FoundIDs foundIDs) {
-			this(javaProject);
-			containerIds = foundIDs.containerIds;
-			containers = foundIDs.containers;
-			pluginIds = foundIDs.pluginIds;
-			projectPaths = foundIDs.projects;
-		}
-		
-		/* (non-Javadoc)
-		 * Map of containers (IClasspathContainer) found in classpath (including required projects).
-		 * This is for each project found. If there was a container in more than one project with the
-		 * id, this set will contain the container from each such project. They are not considered the
-		 * same because they come from a different project.
-		 * <p>
-		 * The key will be the containers, and the value will be a <code>Boolean</code>, where true means it
-		 * is visible to the top-level project.
-		 * <p>
-		 * This is used for determining if a project's container implements the desired contributor.
-		 * 
-		 * Will be empty if no project sent in to launch configuration.
-		 * 
-		 * @see org.eclipse.jdt.core.IClasspathContainer
-		 * 
-		 */
-		public Map containers = Collections.EMPTY_MAP;
-
-		
-		/* (non-Javadoc)
-		 * Map of unique container id strings found in classpath (including required projects).
-		 * If a container with the same id was found in more than one project, only one id will
-		 * be in this set since they are the same.
-		 * <p>
-		 * The key will be the container ids, and the value will be ContainerPaths
-		 * 
-		 * Will be empty if no project sent in to launch configuration.
-		 * 
-		 */
-		public Map containerIds = Collections.EMPTY_MAP;
-		
-		/* (non-Javadoc)
-		 * Set of unique plugin id strings found in classpath (including required projects).
-		 * If a required plugin with the same id was found in more than one project, only one id will
-		 * be in this set since they are the same.
-		 * <p>
-		 * The key will be the plugin ids, and the value will be a <code>Boolean</code>, where true means it
-		 * is visible to the top-level project.
-		 * 
-		 * Will be empty if no project sent in to launch configuration.
-		 */		
-		public Map pluginIds = Collections.EMPTY_MAP;;
-		
-		/* (non-Javadoc)
-		 * Map of unique projects found in classpath (including required projects), but not including top-level project.
-		 * <p>
-		 * The key will be the <code>IPath</code> for the project, and the value will be a <code>Boolean</code>, where true means it
-		 * is visible to the top-level project.
-		 * 
-		 * Will be <code>null</code> if no project sent in to launch configuration.
-		 */		
-		public Map projectPaths;
-		
-		/* (non-Javadoc)
-		 * Java project for this launch. <code>null</code> if not for a project.
-		 */
-		public IJavaProject javaProject;
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getContainerIds()
-		 */
-		public Map getContainerIds() {
-			return containerIds;
-		}
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getContainers()
-		 */
-		public Map getContainers() {
-			return containers;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getJavaProject()
-		 */
-		public IJavaProject getJavaProject() {
-			return javaProject;
-		}
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getPluginIds()
-		 */
-		public Map getPluginIds() {
-			return pluginIds;
-		}
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getProjectPaths()
-		 */
-		public Map getProjectPaths() {
-			return projectPaths;
-		}
-		
-	}
-		
-	/**
-	 * LaunchInfo for a launch. Stored by key and retrievable by the key.
-	 * This is only passed to launch delegates. It should not be passed on to
-	 * others, though the IConfigurationContributionInfo may be.
-	 * 
-	 * <p>
-	 * This class is not intended to be subclassed by clients.
-	 * </p>
-	 * 
-	 * @see ProxyLaunchSupport#getInfo(String)
-	 * @see IConfigurationContributionInfo
-	 * @since 1.0.0
-	 */
-	public static class LaunchInfo {
-		/**
-		 * Contributors for this launch. It will never be <code>null</code>. It may be empty.
-		 */
-		public IConfigurationContributor[] contributors;
-		
-		/**
-		 * The registry returned from the launch. The launch needs to set this before it returns.
-		 */
-		public ProxyFactoryRegistry resultRegistry;
-		
-
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getJavaProject()
-		 */
-		public IJavaProject getJavaProject() {
-			return configInfo.getJavaProject();
-		}		
-		
-		/**
-		 * Return the IConfigurationContributionInfo for this launch.
-		 * @return
-		 * 
-		 * @since 1.0.0
-		 */
-		public IConfigurationContributionInfo getConfigInfo() {
-			return configInfo;
-		}
-		
-		protected IConfigurationContributionInfo configInfo;
-		
-	}
-	
-	/**
-	 * Start an implementation using the default config for the given project.
-	 * <p> 
-	 * This will wait for build. If you
-	 * know the build has been suspended by your thread, then you must use the other method that takes a waitForThread
-	 * boolean, and you must pass in false. Otherwise it will deadlock.
-	 * 
-	 * @param project The project. It must be a java project, and it cannot be <code>null</code>.
-	 * @param vmTitle title for VM. It may be <code>null</code>.
-	 * @param aContribs The contributions array. It may be <code>null</code>.
-	 * @param pm
-	 * @return The created registry.
-	 * @throws CoreException
-	 * 
-	 * @see ProxyLaunchSupport#startImplementation(IProject, String, IConfigurationContributor[], boolean, IProgressMonitor)
-	 * @since 1.0.0
-	 */
-	public static ProxyFactoryRegistry startImplementation(
-			IProject project,
-			String vmTitle,
-			IConfigurationContributor[] aContribs,
-			IProgressMonitor pm)
-				throws CoreException {
-		return startImplementation(project, vmTitle, aContribs, true, pm);
-	}
-	
-	/**
-	 * Start an implementation using the default config for the given project.
-	 * <p> 
-	 * If you know the build has been suspended by your thread, then you must use call this with false for waitForThread. Otherwise it will deadlock.
-	 * 
-	 * @param project The project. It must be a java project, and it cannot be <code>null</code>.
-	 * @param vmTitle title for VM. It may be <code>null</code>.
-	 * @param aContribs The contributions array. It may be <code>null</code>.
-	 * @param waitForBuild wait for the build. If caller knows that the build has been suspended by this thread, then it must call this with false. Otherwise a deadlock will occur.
-	 * @param pm
-	 * @return The created registry.
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static ProxyFactoryRegistry startImplementation(
-			IProject project,
-			String vmTitle,
-			IConfigurationContributor[] aContribs,
-			boolean waitForBuild, 
-			IProgressMonitor pm)
-				throws CoreException {
-		// First find the appropriate launch configuration to use for this project.
-		// The process is:
-		//	1) See if the project's persistent property has a setting for "proxyLaunchConfiguration", if it does,
-		//		get the configuration of that name and create a working copy of it.
-		//	2) If not, then get the "org.eclipse.jem.proxy.LocalProxyLaunchConfigurationType"
-		//		and create a new instance working copy.
-
-		IJavaProject javaProject = JavaCore.create(project);
-		if (javaProject == null) {
-			throw new CoreException(
-					new Status(
-							IStatus.WARNING,
-							ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
-							0,
-							MessageFormat.format(
-									ProxyMessages.Not_Java_Project_WARN_, 
-									new Object[] { project.getName()}),
-							null));
-		}
-
-		// First if specific set.
-		String launchName = project.getPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION);
-		ILaunchConfiguration config = null;		
-		if (launchName != null && !NOT_SET.equals(launchName)) {
-			ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations();
-			for (int i = 0; i < configs.length; i++) {
-				if (configs[i].getName().equals(launchName)) {
-					config = configs[i];
-					break;
-				}
-			}
-			if (config == null || !config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "").equals(project.getName())) { //$NON-NLS-1$
-				project.setPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION, (String) null);	// Config not found, or for a different project, so no longer the default.
-				config = null;
-			}
-		}
-		
-		if (config == null) {
-			ILaunchConfigurationWorkingCopy configwc = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(IProxyConstants.LOCAL_LAUNCH_TYPE).newInstance(null, DebugPlugin.getDefault().getLaunchManager().generateUniqueLaunchConfigurationNameFrom("LocalProxy_"+project.getName())); //$NON-NLS-1$
-			configwc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, project.getName()); 
-			config = configwc;
-		}
-		
-		return startImplementation(config, vmTitle, aContribs, waitForBuild, pm);
-	}
-	
-	/**
-	 * Launch a registry using the given configuration.
-	 * <p> 
-	 * This will wait for build. If you
-	 * know the build has been suspended by your thread, then you must use the other method that takes a waitForThread
-	 * boolean, and you must pass in false. Otherwise it will deadlock.
-	 *
-	 * @param config 
-	 * @param vmTitle title for VM. It may be <code>null</code>.
-	 * @param aContribs The contributions array. It may be <code>null</code>.
-	 * @param pm
-	 * @return The registry from this configuration.
-	 * @throws CoreException
-	 * 
-	 * @see ProxyLaunchSupport#startImplementation(ILaunchConfiguration, String, IConfigurationContributor[], boolean, IProgressMonitor)
-	 * @since 1.0.0
-	 */
-	public static ProxyFactoryRegistry startImplementation(
-			ILaunchConfiguration config,
-			String vmTitle,
-			IConfigurationContributor[] aContribs,
-			IProgressMonitor pm)
-			throws CoreException {
-		return startImplementation(config, vmTitle, aContribs, true, pm);
-	}
-
-	/**
-	 * Launch a registry using the given configuration.
-	 * <p> 
-	 * If you know the build has been suspended by your thread, then you must use you must pass in false for waitForThread. Otherwise it will deadlock.
-	 *
-	 * @param config
-	 * @param vmTitle title for VM. It may be <code>null</code>.
-	 * @param aContribs The contributions array. It may be <code>null</code>.
-	 * @param waitForBuild wait for the build. If caller knows that the build has been suspended by this thread, then it must call this with false. Otherwise a deadlock will occur.
-	 * @param pm
-	 * @return The registry from this configuration.
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static ProxyFactoryRegistry startImplementation(
-				ILaunchConfiguration config,
-				String vmTitle,
-				IConfigurationContributor[] aContribs,
-				boolean waitForBuild,
-				IProgressMonitor pm)
-				throws CoreException {
-
-		if (pm == null)
-			pm = new NullProgressMonitor();
-		String stepId = "Pre-launch VM ( " + vmTitle + " )"; //$NON-NLS-1$ //$NON-NLS-2$
-		TimerTests.basicTest.startStep(stepId);
-		if (vmTitle.equals("Beaninfo")) //$NON-NLS-1$
-			PerformanceMonitorUtil.getMonitor().snapshot(125);
-		final ILaunchConfigurationWorkingCopy configwc = config.getWorkingCopy();
-		
-		pm.beginTask("", 400); //$NON-NLS-1$
-		pm.subTask(ProxyMessages.ProxyLaunch);	
-		if (waitForBuild) {
-			// See if build needed or waiting or inprogress, if so, wait for it to complete. We've
-			// decided too difficult to determine if build would affect us or not, so just wait.		
-			if (UI_RUNNER != null)
-				UI_RUNNER.handleBuild(new SubProgressMonitor(pm, 100));
-			else
-				runBuild(new SubProgressMonitor(pm, 100));
-			
-			if (pm.isCanceled())
-				return null;
-		}
-				
-		if (aContribs != null) {
-			IConfigurationContributor[] newContribs = new IConfigurationContributor[aContribs.length+1];
-			System.arraycopy(aContribs, 0, newContribs, 1, aContribs.length);
-			newContribs[0] = new ProxyContributor();
-			aContribs = newContribs;
-		} else
-			aContribs = new IConfigurationContributor[] {new ProxyContributor()};
-
-		String launchKey = String.valueOf(System.currentTimeMillis());
-		LaunchInfo launchInfo = new LaunchInfo();
-		synchronized (ProxyLaunchSupport.class) {
-			while (LAUNCH_INFO.containsKey(launchKey)) {
-				launchKey += 'a'; // Just add something on to make it unique.
-			}
-			LAUNCH_INFO.put(launchKey, launchInfo);
-		}
-		
-		String projectName = configwc.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String) null);
-		aContribs = fillInLaunchInfo(aContribs, launchInfo, projectName);
-		
-		try {		
-			configwc.setAttribute(IProxyConstants.ATTRIBUTE_LAUNCH_KEY, launchKey);
-			if (vmTitle != null && vmTitle.length()>0)
-				configwc.setAttribute(IProxyConstants.ATTRIBUTE_VM_TITLE, vmTitle);
-			
-			if (ATTR_PRIVATE != null)
-				configwc.setAttribute(ATTR_PRIVATE, true);			
-			
-			// Let contributors modify the configuration.
-			final IConfigurationContributor[] contribs = aContribs;
-			final LaunchInfo linfo = launchInfo;
-			for (int i = 0; i < contribs.length; i++) {
-				// First run the initialize.
-				// Run in safe mode so that anything happens we don't go away.
-				final int ii = i;
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// Don't need to do anything. Platform.run logs it for me.
-					}
-
-					public void run() throws Exception {
-						contribs[ii].initialize(linfo.getConfigInfo());
-					}
-				});
-
-				// Now run the contribute to configuration.
-				// Run in safe mode so that anything happens we don't go away.
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// Don't need to do anything. Platform.run logs it for me.
-					}
-
-					public void run() throws Exception {
-						contribs[ii].contributeToConfiguration(configwc);
-					}
-				});
-			}
-			pm.worked(100);
-			
-			configwc.launch(ILaunchManager.RUN_MODE, new SubProgressMonitor(pm, 100));
-			
-			final ProxyFactoryRegistry reg = launchInfo.resultRegistry;
-			if (!pm.isCanceled() && reg == null)
-				throw new CoreException(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.ProxyLaunchSupport_RegistryCouldNotStartForSomeReason_WARN_, null)); 
-			if (pm.isCanceled()) {
-				if (reg != null)
-					reg.terminateRegistry();
-				return null;
-			}
-			
-			performExtensionRegistrations((BaseProxyFactoryRegistry) reg, launchInfo);
-			
-//			TimerTests.basicTest.startStep("contribute to registry");
-			for (int i = 0; i < contribs.length; i++) {
-				final int ii = i;
-				// Run in safe mode so that anything happens we don't go away.
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// Don't need to do anything. Platform.run logs it for me.
-					}
-
-					public void run() throws Exception {
-//						String stepid = "contribute to registry for " + contribs[ii].getClass();
-//						TimerTests.basicTest.startStep(stepid);
-						contribs[ii].contributeToRegistry(reg);
-//						TimerTests.basicTest.stopStep(stepid);
-					}
-				});
-			}
-//			TimerTests.basicTest.stopStep("contribute to registry");
-		} finally {
-			// Clean up and return.
-			LAUNCH_INFO.remove(launchKey);
-		}	
-		
-		pm.done();
-		if (vmTitle.equals("Beaninfo")) //$NON-NLS-1$
-			PerformanceMonitorUtil.getMonitor().snapshot(126);
-		TimerTests.basicTest.stopStep(stepId);
-		return launchInfo.resultRegistry;
-	}
-	
-	/**
-	 * Create a default IConfigurationContributionInfo for the given project. This is useful info even when not launching a
-	 * vm.
-	 * 
-	 * @param javaProject
-	 * @return new contrib info.
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.1.0
-	 */
-	public static IConfigurationContributionInfo createDefaultConfigurationContributionInfo(IJavaProject javaProject) throws JavaModelException {
-		LaunchSupportIConfigurationContributionInfo configInfo = new LaunchSupportIConfigurationContributionInfo(javaProject,
-				ProxyPlugin.getPlugin().getIDsFound(javaProject));
-		return configInfo;
-
-	}
-	
-	/**
-	 * Use in calling {@link ProxyLaunchSupport#fillInLaunchInfo(IConfigurationContributor[], LaunchInfo, String)} for the configuration
-	 * contributors array if there are no incoming contributors.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final IConfigurationContributor[] EMPTY_CONFIG_CONTRIBUTORS = new IConfigurationContributor[0];
-	/**
-	 * Fill in the launch info config info and contribs. The contribs sent in may be expanded due to extension
-	 * points and a new one created. Either the expanded copy or the original (if no change) will be stored in
-	 * the launchinfo and returned from this call.
-	 * 
-	 * @param aContribs this should never be <code>null</code>. Pass in {@link ProxyLaunchSupport#EMPTY_CONFIG_CONTRIBUTORS} in that case.
-	 * @param launchInfo
-	 * @param projectName
-	 * @return a modified aContribs if any change was made to it.  This will never be <code>null</code>. It will return an empty list if aContribs was null and no changes were made.
-	 * @throws JavaModelException
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IConfigurationContributor[] fillInLaunchInfo(IConfigurationContributor[] aContribs, LaunchInfo launchInfo, String projectName) throws JavaModelException, CoreException {
-		if (projectName != null) {
-			projectName = projectName.trim();
-			if (projectName.length() > 0) {
-				IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
-				IJavaProject javaProject = JavaCore.create(project);
-				if (javaProject != null && javaProject.exists()) {
-					launchInfo.configInfo = createDefaultConfigurationContributionInfo(javaProject);
-					if (!launchInfo.configInfo.getContainerIds().isEmpty() || !launchInfo.configInfo.getContainers().isEmpty() || !launchInfo.configInfo.getPluginIds().isEmpty()) {
-						List computedContributors = new ArrayList(launchInfo.configInfo.getContainerIds().size()+launchInfo.configInfo.getContainers().size()+launchInfo.configInfo.getPluginIds().size());
-						// Note: We don't care about the visibility business here. For contributors to proxy it means
-						// some classes in the projects/plugins/etc. need configuration whether they are visible or not.
-						// This is because even though not visible, some other visible class may instantiate it. So it
-						// needs the configuration.
-						// First handle explicit classpath containers that implement IConfigurationContributor
-						for (Iterator iter = launchInfo.configInfo.getContainers().keySet().iterator(); iter.hasNext();) {
-							IClasspathContainer container = (IClasspathContainer) iter.next();
-							if (container instanceof IConfigurationContributor)
-								computedContributors.add(container);
-						}
-						
-						// Second add in contributors that exist for a container id.
-						for (Iterator iter = launchInfo.configInfo.getContainerIds().values().iterator(); iter.hasNext();) {
-							ContainerPaths paths = (ContainerPaths) iter.next();
-							IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getContainerConfigurations(paths.getContainerId(), paths.getAllPaths());
-							if (contributors != null)
-								for (int i = 0; i < contributors.length; i++) {
-									Object contributor = contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
-									if (contributor instanceof IConfigurationContributor)
-										computedContributors.add(contributor);
-								}
-						}
-						
-						// Finally add in contributors that exist for a plugin id.
-						for (Iterator iter = launchInfo.configInfo.getPluginIds().keySet().iterator(); iter.hasNext();) {
-							String pluginId = (String) iter.next();
-							IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getPluginConfigurations(pluginId);
-							if (contributors != null)
-								for (int i = 0; i < contributors.length; i++) {
-									Object contributor = contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
-									if (contributor instanceof IConfigurationContributor)
-										computedContributors.add(contributor);
-								}
-						}
-						
-						// Now turn into array
-						if (!computedContributors.isEmpty()) {
-							IConfigurationContributor[] newContribs = new IConfigurationContributor[aContribs.length
-									+ computedContributors.size()];
-							System.arraycopy(aContribs, 0, newContribs, 0, aContribs.length);
-							IConfigurationContributor[] cContribs = (IConfigurationContributor[]) computedContributors
-									.toArray(new IConfigurationContributor[computedContributors.size()]);
-							System.arraycopy(cContribs, 0, newContribs, aContribs.length, cContribs.length);
-							aContribs = newContribs;
-						}
-					}
-				}
-			}
-		}
-		
-		launchInfo.contributors = aContribs;
-		return aContribs;
-	}
-	
-	/**
-	 * Execute the extension registrations that are valid for this type of registry and the launchinfo paths.
-	 * <p>
-	 * This is meant to be called only by registry implementations that do not launch through a launch configration after the registry is created but
-	 * before the {@link IConfigurationContributor#contributeToRegistry(ProxyFactoryRegistry)} is called. This will be called automatically
-	 * by registries that used a launch configuration to launch.
-	 * 
-	 * @param baseRegistry
-	 * @param launchInfo
-	 * @throws CoreException 
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void performExtensionRegistrations(final BaseProxyFactoryRegistry baseRegistry, LaunchInfo launchInfo) throws CoreException {
-		IConfigurationContributionInfo configInfo = launchInfo.configInfo;
-		if (configInfo != null && (!configInfo.getContainerIds().isEmpty() || !configInfo.getPluginIds().isEmpty())) {
-			String registryID = baseRegistry.getRegistryTypeID();
-			// Note: We don't care about the visibility business here. For contributors to proxy it means
-			// some classes in the projects/plugins/etc. need configuration whether they are visible or not.
-			// This is because even though not visible, some other visible class may instantiate it. So it
-			// needs the configuration.
-			
-			// First call registrations that exist for a container id.
-			for (Iterator iter = configInfo.getContainerIds().values().iterator(); iter.hasNext();) {
-				ContainerPaths paths = (ContainerPaths) iter.next();
-				IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getContainerExtensions(paths.getContainerId(), paths.getAllPaths());
-				if (contributors != null)
-					for (int i = 0; i < contributors.length; i++) {
-						if (registryID.equals(contributors[i].getAttributeAsIs(ProxyPlugin.PI_REGISTRY_TYPE))) {
-							try {
-								final IExtensionRegistration contributor = (IExtensionRegistration) contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
-								Platform.run(new ISafeRunnable() {
-								
-									public void run() throws Exception {
-										contributor.register(baseRegistry);
-									}
-								
-									public void handleException(Throwable exception) {
-										// Don't need to do anything, Platform logs it for me.
-									}
-								
-								});
-							} catch (ClassCastException e) {
-								// If not right class, just ignore it.
-							}
-						}
-					}
-			}
-			
-			// Finally add in contributors that exist for a plugin id.
-			for (Iterator iter = configInfo.getPluginIds().keySet().iterator(); iter.hasNext();) {
-				String pluginId = (String) iter.next();
-				IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getPluginExtensions(pluginId);
-				if (contributors != null)
-					for (int i = 0; i < contributors.length; i++) {
-						if (registryID.equals(contributors[i].getAttributeAsIs(ProxyPlugin.PI_REGISTRY_TYPE))) {
-							try {
-								final IExtensionRegistration contributor = (IExtensionRegistration) contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
-								Platform.run(new ISafeRunnable() {
-								
-									public void run() throws Exception {
-										contributor.register(baseRegistry);
-									}
-								
-									public void handleException(Throwable exception) {
-										// Don't need to do anything, Platform logs it for me.
-									}
-								
-								});
-							} catch (ClassCastException e) {
-								// If not right class, just ignore it.
-							}
-						}
-					}
-			}
-	}
-}
-
-
-	/*
-	 * Run the build. If the original launch was in the UI thread, this will
-	 * be called under control of an IProgressService so that it is in a separate
-	 * thread and the UI will remain responsive (in that either a busy cursor comes
-	 * up or eventually a progress dialog).
-	 * If the pm is canceled, this will just return, but the caller must check if the pm is canceled.
-	 * 
-	 * <package-protected> so that only the UI handler will access it.
-	 */
-	static void runBuild(IProgressMonitor pm) throws CoreException {
-		boolean autobuilding = ResourcesPlugin.getWorkspace().isAutoBuilding();
-		if (!autobuilding) {
-			try {
-				// We are not autobuilding. So kick off a build right here and
-				// wait for it. (If we already within a build on this thread, then this
-				// will return immediately without building. We will take that risk. If
-				// some other thread is building, we will wait for it finish before we
-				// can get it and do our build.
-				ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, pm); 
-			} catch (OperationCanceledException e) {
-				// The pm is already marked canceled, so caller can check that instead.
-			} 
-		} else {
-			pm.beginTask("", 200); //$NON-NLS-1$
-			IJobManager jobManager = Platform.getJobManager();
-			Job currentJob = jobManager.currentJob();
-			if (currentJob == null || (!currentJob.belongsTo(ResourcesPlugin.FAMILY_AUTO_BUILD) && !currentJob.belongsTo(ResourcesPlugin.FAMILY_MANUAL_BUILD))) { 
-				if (jobManager.find(ResourcesPlugin.FAMILY_AUTO_BUILD).length > 0 || jobManager.find(ResourcesPlugin.FAMILY_MANUAL_BUILD).length >0) {
-					// We are not within a build job. If we were, then we don't do the build. We will take
-					// that risk. The problem is that if within the build, we can't wait for it to finish because
-					// we would stop the thread and so the build would not complete.
-					pm.subTask(ProxyMessages.ProxyWaitForBuild); 
-					try {
-						while (true) {
-							try {
-								jobManager.join(ResourcesPlugin.FAMILY_AUTO_BUILD, new SubProgressMonitor(pm, 100));
-								jobManager.join(ResourcesPlugin.FAMILY_MANUAL_BUILD, new SubProgressMonitor(pm, 100));
-								break;
-							} catch (InterruptedException e) {
-							}
-						}
-					} catch (OperationCanceledException e) {
-					}
-				}
-			} 
-			pm.done();
-		}
-	}
-	
-	
-	/*
-	 * This prevents the launch from being shown. However these constants are in UI component, and we don't
-	 * want to pre-req that. So we will get them reflectively instead.
-	 * public but only so that launch delegate can get to it.
-	 */
-	public static String ATTR_PRIVATE;
-	private static IUIRunner UI_RUNNER = null;
-
-	static {
-		ATTR_PRIVATE = null;
-		try {
-			// See if we have a UI bundle and it is active. If it exists but is not active,
-			// then we won't do anything. If we were running a UI application, it should already
-			// of been active before we got here.
-			Bundle uiBundle = Platform.getBundle("org.eclipse.ui");	//$NON-NLS-1$
-			if (uiBundle != null && uiBundle.getState() == Bundle.ACTIVE) {
-				try {
-					// We have a UI bundle, so we can load our UIRunner class and it will load fine.
-					UI_RUNNER = (IUIRunner) Class.forName("org.eclipse.jem.internal.proxy.core.UIRunner").newInstance(); //$NON-NLS-1$
-				} catch (InstantiationException e1) {
-					ProxyPlugin.getPlugin().getLogger().log(e1, Level.WARNING);
-				}
-				
-				// So that we can run headless (w/o ui), need to do class forName for debugui contants
-				Bundle debuguiBundle = Platform.getBundle("org.eclipse.debug.ui"); //$NON-NLS-1$
-				if (debuguiBundle != null && debuguiBundle.getState() == Bundle.ACTIVE) {
-					Class debugUIConstants = debuguiBundle.loadClass("org.eclipse.debug.ui.IDebugUIConstants"); //$NON-NLS-1$
-					ATTR_PRIVATE = (String) debugUIConstants.getField("ATTR_PRIVATE").get(null); //$NON-NLS-1$
-				}
-			}			
-		} catch (SecurityException e) {
-		} catch (ClassNotFoundException e) {
-		} catch (NoSuchFieldException e) {
-		} catch (IllegalArgumentException e) {
-		} catch (IllegalAccessException e) {
-		}
-	}	
-
-	/* (non-Javadoc)
-	 * Only referenced by launch delegates. public because they are in other packages,
-	 * or even external developers packages. Not meant to be generally available.
-	 * 
-	 * This is needed because we can't pass the generic info into a launch configuration
-	 * because a launch configuration can't take objects. Only can take strings and numbers.  
-	 */
-	public static synchronized LaunchInfo getInfo(String key) {
-		return (LaunchInfo) LAUNCH_INFO.get(key);
-	}
-	
-	/**
-	 * Convert the string path into a valid url.
-	 * @param path
-	 * @return the url or <code>null</code> if not convertable (i.e. not well-formed).
-	 * 
-	 * @since 1.0.0
-	 */
-	public static URL convertStringPathToURL(String path) {
-		try {
-			return path != null ? new File(path).toURL() : null;
-		} catch (MalformedURLException e) {
-			return null;
-		}
-	}
-
-	/**
-	 * Convert the string paths into a valid urls.
-	 * 
-	 * @param paths
-	 * @return the urls or <code>null</code> if paths is null. Any path not convertable (i.e. not well-formed) will not be in the final list.
-	 * So this means the result length may be smaller than the paths length.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static URL[] convertStringPathsToURL(String[] paths) {
-		if (paths != null) {
-			URL[] result = new URL[paths.length];
-			int nextURL = 0;
-			for (int i = 0; i < paths.length; i++) {
-				URL url = convertStringPathToURL(paths[i]);
-				if (url != null)
-					result[nextURL++] = url;   
-			}
-			if (nextURL == 0)
-				return null;	// None were found.
-			
-			if (nextURL != result.length) {
-				URL[] nr = new URL[nextURL];
-				System.arraycopy(result, 0, nr, 0, nr.length);
-				result = nr;
-			}
-			return result;
-		} else
-			return null;
-	}
-
-	/**
-	 * Convert the urls to string array. It is assumed the urls are in file protocol. 
-	 * @param urls
-	 * @return string paths or <code>null</code> if urls is <code>null</code>. Any <code>null</code> entry of urls will result in 
-	 * a corresponding <code>null</code> in the strings.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static String[] convertURLsToStrings(URL[] urls) {
-		if (urls != null) {
-			String[] strings = new String[urls.length];
-			for (int i = 0; i < urls.length; i++) {
-				strings[i] = urls[i] != null ? urls[i].getFile() : null;
-			}
-			return strings;
-		} else
-			return null;
-	}
-
-	/* (non-Javadoc)
-	 * Local contributor used to make sure that certain jars are in the path.
-	 * 
-	 * @since 1.0.0
-	 */
-	static class ProxyContributor extends ConfigurationContributorAdapter {
-		public void contributeClasspaths(IConfigurationContributionController controller) {
-			// Add the required jars to the end of the classpath. (We want proxyCommon and initParser (+ initParser NLS), but they are in the runtime of the proxy bundle (which is jarred up), so we contribute the bundle instead.
-			controller.contributeClasspath(ProxyPlugin.getPlugin().getBundle(), (IPath) null, IConfigurationContributionController.APPEND_USER_CLASSPATH, true);	//$NON-NLS-1$
-		}
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyMessages.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyMessages.java
deleted file mode 100644
index 8178652..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyMessages.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class ProxyMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.proxy.core.messages";//$NON-NLS-1$
-
-	private ProxyMessages() {
-		// Do not instantiate
-	}
-
-	public static String UnexpectedException_EXC_;
-	public static String ClassCast_EXC__IncorrectType;
-	public static String ProxyFactory_EXC__NoBeanProxyFactory;
-	public static String ProxyFactory_EXC__NoBeanTypeProxyFactory;
-	public static String Not_Java_Project_WARN_;
-	public static String No_VM_WARN_;
-	public static String No_Implementation_WARN_;
-	public static String ProxyLaunch;
-	public static String ProxyWaitForBuild;
-	public static String Expression_InInvalidStateDueTo_EXC_;
-	public static String Expression_InInvalidState_EXC_;
-	public static String Expression_TypeSentInInvalidOrder_EXC_;
-	public static String Expression_ArrayTypeNotAnArray_EXC_;
-	public static String Expression_CannotHandleNoReceiveOnFieldAccess_EXC_;
-	public static String Expression_MethodsNeedReceiver_EXC_;
-	public static String Expression_InvalidMarkNesting;
-	public static String ProxyPlugin_CleanupDefaultProxyLaunchConfigurations;
-	public static String ProxyLaunchSupport_RegistryCouldNotStartForSomeReason_WARN_;
-	public static String Expression_CreateProxyReassignmentExpression_InvalidForReassignment_EXC_;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, ProxyMessages.class);
-	}
-
-	public static String Expression_InvalidProxy;
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyPlugin.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyPlugin.java
deleted file mode 100644
index 1c4b15c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyPlugin.java
+++ /dev/null
@@ -1,1371 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ProxyPlugin.java,v $
- *  $Revision: 1.57 $  $Date: 2005/10/26 22:14:01 $ 
- */
-
-
-import java.io.*;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.debug.core.*;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
-import org.eclipse.jdt.launching.JavaRuntime;
-import org.eclipse.osgi.service.resolver.BundleSpecification;
-import org.eclipse.osgi.util.ManifestElement;
-import org.osgi.framework.*;
-
-import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jem.util.logger.proxyrender.EclipseLogger;
-
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo.ContainerPaths;
-
-/**
- * The plugin class for the org.eclipse.jem.internal.proxy.core plugin.
- */
-
-public class ProxyPlugin extends Plugin {
-	
-	/**
-	 * This interface is for a listener that needs to know if this plugin (ProxyPlugin) is being shutdown. 
-	 * It is needed because there are some extensions that get added dynamically that need to know when the
-	 * plugin is being shutdown. Can't use new bundle listener for this because it notifies AFTER shutdown.
-	 * 
-	 * @since 1.0.0
-	 */
-	public interface IProxyPluginShutdownListener {
-		/**
-		 * ProxyPlugin is in shutdown.
-		 * 
-		 * @since 1.0.0
-		 */
-		public void shutdown();
-	}
-	
-	private static ProxyPlugin PROXY_PLUGIN = null;
-	public static final String PREFERENCES_VM_NOVERIFY_KEY = "JEM_PREFERENCES_VM_NOVERIFY_KEY"; // Key for NOVERIFY option of VM //$NON-NLS-1$
-	public static final String PDE_NATURE_ID = "org.eclipse.pde.PluginNature" ; //$NON-NLS-1$
-		
-	// If this is set to true, then in development mode and it will try for proxy jars in directories.
-	private boolean devMode;
-	
-	private ListenerList shutdownListeners;
-
-	public ProxyPlugin() {
-		super();
-		PROXY_PLUGIN = this;
-		devMode = Platform.inDevelopmentMode();  	
-	}
-	
-	public boolean isDevMode() {
-		return devMode;
-	}
-
-	/**
-	 * Access the singleton
-	 * @return the singleton plugin
-	 * 
-	 * @since 1.0.0
-	 */
-	public static ProxyPlugin getPlugin() {
-		return PROXY_PLUGIN;
-	}
-	
-	private Logger logger;
-	public Logger getLogger() {
-		if (logger == null)
-			logger = EclipseLogger.getEclipseLogger(this);
-		return logger;
-	}	
-
-	/**
-	 * This will take the bundle and file name and make it local and return that
-	 * fully qualified. It will look in fragments, but only returns first found. If there can be multiples use
-	 * the one for bundles and it fragments.
-	 * <p>
-	 * If we are in development and it will pick it up from the path
-	 * that is listed in the proxy.jars file located in the bundle passed in. This allows development code to be
-	 * used in place of the actual runtime jars. If the runtime jars are found,
-	 * they will be used.
-	 * <p>
-	 * For example if looking for file runtime/xyz.jar in bundle abc, then in bundle directory for abc,
-	 * there should be a file called proxy.jars. This should only be in development, this file should not
-	 * be distributed for production. It would be distributed in the SDK environment when testing is desired.
-	 * <p>
-	 * The format of the file is:
-	 * 	runtimefile=/projectname/builddirectory
-	 * <p>
-	 * For this to work when the actual jar is not found, the Eclipse must of been started in 
-	 * dev mode (i.e. the bundle location will be a project within the developer Eclipse. That way
-	 * we can go up one level for the current install location and assume the above projectname
-	 * will be found relative to the directory.
-	 * <p>
-	 * For the above example:
-	 * 	runtime/xyz.jar=/xyzproject/bin
-	 * <p>
-	 * It will return "." if file can't be found. It means nothing but it won't cause jvm to crash.
-	 * 
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @return the path to the file or <code>"."</code> if not found.
-	 * 
-	 * @since 1.0.0
-	 */
-	public String localizeFromBundleOnly(Bundle bundle, String filenameWithinBundle) {
-		URL url = urlLocalizeFromBundleOnly(bundle, filenameWithinBundle);
-		return url != null ? getFileFromURL(url) : "."; //$NON-NLS-1$
-	}
-	public String localizeFromBundleAndFragments(Bundle bundle, String filenameWithinBundle) {
-		URL url = urlLocalizeFromBundleAndFragments(bundle, filenameWithinBundle);
-		return url != null ? getFileFromURL(url) : "."; //$NON-NLS-1$
-	}
-	
-	/**
-	 * Just like localizeFromBundle except it will return an array of Strings. It will look for the filename
-	 * within the bundle and any fragments of the bundle. If none are found, an empty array will be returned.
-	 * <p>
-	 * To find the files in the fragments that are in the runtime path (i.e. libraries), it will need to use a suffix,
-	 * This is because the JDT will get confused if a runtime jar in a fragment has the same name
-	 * as a runtime jar in the main bundle.
-	 * NOTE: This is obsolete. JDT no longer has this problem. So we can find libraries in fragments that have the
-	 * same file path. 
-	 * <p>
-	 * So we will use the following search pattern:
-	 * <ol>
-	 * <li>Find in all of the fragments those that match the name exactly in the same paths if paths are supplied.</li>
-	 * <li>Find in all of the fragments, in their runtime path (library stmt), those that match the name 
-	 *    but have a suffix the same as the uniqueid of the fragment (preceeded by a period). This is so that it can be easily
-	 *    found but yet be unique in the entire list of fragments. For example if looking for "runtime/xyz.jar"
-	 *    and we have fragment "a.b.c.d.frag", then in the runtime path we will look for the file
-	 *    "runtime/xyz.a.b.c.d.frag.jar". Note: This is obsolete. Still here only for possible old code. Will go 
-	 *    away in future.</li>
-	 * <p>
-	 * If the files in the fragments are not in the fragments library path then it can have the same name. NOTE: Obsolete,
-	 * JDT can now handle same name.
-	 * <p>
-	 * This is useful for nls where the nls for the filename will be in one or more of the fragments of the plugin.
-	 * 
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public String[] localizeAllFromBundleAndFragments(Bundle bundle, String filenameWithinBundle) {
-		URL[] urls = urlLocalizeAllFromBundleAndFragments(bundle, filenameWithinBundle);
-		String[] result = new String[urls.length];
-		for (int i = 0; i < urls.length; i++) {
-			result[i] = getFileFromURL(urls[i]);
-		}
-		return result;
-	}
-	
-	public static String getFileFromURL(URL url) {
-		// We need to do this in a device independent way. The URL will always put a leading '/' in the
-		// file part of the URL, but on Windows we need to have this '/' removed. Some JRE's don't understand it.
-		return new File(url.getFile()).getAbsolutePath();
-
-	}
-
-	public URL urlLocalizeFromBundleAndFragments(Bundle bundle, String filenameWithinBundle) {
-		return urlLocalizeFromBundleAndFragments(bundle, new Path(filenameWithinBundle));
-	}
-	public URL urlLocalizeFromBundleAndFragments(Bundle bundle, IPath filenameWithinBundle) {
-		try {
-			URL pvm = Platform.find(bundle, filenameWithinBundle);
-			if (pvm != null)
-				return Platform.asLocalURL(pvm);
-		} catch (IOException e) {
-		}
-		if (devMode) {
-			URL[] urls = findDevAllFromBundleAndFragments(bundle, filenameWithinBundle.toString());
-			if (urls.length > 0)
-				return urls[0];
-			else
-				return null;
-		} else
-			return null;
-	}
-	
-	/**
-	 * Like <code>localizeFromBundleAndFragments</code> except it returns URL's instead.
-	 * 
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @return
-	 * 
-	 * @see ProxyPlugin#localizeFromBundleAndFragments(Bundle, String)
-	 * @since 1.0.0
-	 */
-	public URL[] urlLocalizeAllFromBundleAndFragments(Bundle bundle, String filenameWithinBundle) {
-		return urlLocalizeAllBundleAndFragments(bundle, Platform.getFragments(bundle), filenameWithinBundle);
-	}
-	public URL[] urlLocalizeAllFromBundleAndFragments(Bundle bundle, IPath filenameWithinBundle) {
-		return urlLocalizeAllBundleAndFragments(bundle, Platform.getFragments(bundle), filenameWithinBundle.toString());
-	}
-	
-	/**
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @param fragments
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	private URL[] urlLocalizeAllBundleAndFragments(Bundle bundle, Bundle[] fragments, String filenameWithinBundle) {
-
-		ArrayList urls = new ArrayList((fragments == null ? 0 : fragments.length) + 1);
-		URL url = internalUrlLocalizeFromBundleOnly(bundle, filenameWithinBundle);
-		if (url != null)
-			urls.add(url);
-		if (fragments != null) {
-			for (int i = 0; i < fragments.length; i++) {
-				Bundle fragment = fragments[i];
-				url = internalUrlLocalizeFromBundleOnly(fragment, filenameWithinBundle);
-				if (url != null)
-					urls.add(url);
-			}
-		}
-		return (URL[]) urls.toArray(new URL[urls.size()]);
-	}
-
-	private static final String PROXYJARS = "proxy.jars";	//$NON-NLS-1$
-	
-	/**
-	 * @see ProxyPlugin#localizeFromBundle(Bundle, String)
-	 * 
-	 * This is just a helper to return a url instead.
-	 * 
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public URL urlLocalizeFromBundleOnly(Bundle bundle, String filenameWithinBundle) {
-		// If the filenameWithinBundle begins with one of these special characters,
-		// it might be in a fragment.
-		if (filenameWithinBundle.charAt(0) == '$'
-				&& (filenameWithinBundle.regionMatches(true, 0, "$nl$", 0, "$nl$".length()) //$NON-NLS-1$ //$NON-NLS-2$
-						|| filenameWithinBundle.regionMatches(true, 0, "$os$", 0, "$os$".length()) || filenameWithinBundle.regionMatches(true, 0, //$NON-NLS-1$ //$NON-NLS-2$
-						"$ws$", 0, "$ws$".length()))) //$NON-NLS-1$ //$NON-NLS-2$
-			return urlLocalizeFromBundleAndFragments(bundle, filenameWithinBundle);
-		try {
-			URL pvm = new URL(bundle.getEntry("/"), filenameWithinBundle); //$NON-NLS-1$
-			pvm = verifyFound(Platform.asLocalURL(pvm));
-			if (pvm != null)
-				return pvm;
-		} catch (IOException e) {
-		}
-		return findDev(bundle, filenameWithinBundle);
-
-	}
-	
-	protected URL internalUrlLocalizeFromBundleOnly(Bundle bundle, String filenameWithinBundle) {
-		try {
-			URL pvm = bundle.getEntry(filenameWithinBundle);
-			if (pvm != null)
-				return Platform.asLocalURL(pvm);
-		} catch (IOException e) {
-		}
-		return findDev(bundle, filenameWithinBundle);		
-		
-	}	
-	
-	private URL verifyFound(URL pvm) throws IOException {
-		if (devMode) {
-			// Need to test if found in devmode. Otherwise we will just assume it is found. If not found on remote and moved to cache, an IOException would be thrown.
-			if (pvm != null) {
-				InputStream ios = null;
-				try {
-					ios = pvm.openStream();
-					if (ios != null)
-						return pvm; // Found it, so return it.
-				} finally {
-					if (ios != null)
-						ios.close();
-				}
-			}
-		} else
-			return pvm;
-		return null;
-	}
-
-	/**
-	 * @see ProxyPlugin#localizeFromBundle(bundle, String)
-	 * 
-	 * This is just a helper to return a url instead.
-	 * 
-	 * @param bundle
-	 * @param filenameWithinBundle
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public URL urlLocalizeFromBundleOnly(Bundle bundle, IPath filenameWithinBundle) {					
-		return urlLocalizeFromBundleOnly(bundle, filenameWithinBundle.toString());
-	}
-	
-	private URL findDev(Bundle bundle, String filenameWithinBundle) {
-		if (devMode) {
-			// Got this far and in dev mode means it wasn't found, so we'll try for development style.
-			// It is assumed that in dev mode, we are running with the IDE as local and any 
-			// build outputs will be local so local file protocol will be returned
-			// from Platform.resolve(). We won't be running in dev mode with our entireplugin being in a jar,
-			// or on a separate system.
-			try {
-				URL pvm = bundle.getEntry(PROXYJARS);
-				if (pvm != null) {
-					InputStream ios = null;
-					try {
-						ios = pvm.openStream();
-						Properties props = new Properties();
-						props.load(ios);
-						String pathString = props.getProperty(filenameWithinBundle.toString());
-						if (pathString != null) {
-							URL url = Platform.resolve(bundle.getEntry("/"));	// It is assumed that if in debug mode, then this plugin is an imported plugin within the developement workspace. //$NON-NLS-1$
-							if (url.getProtocol().equals("file")) { //$NON-NLS-1$
-								File file = new File(url.getFile()).getParentFile();	// This gets us to workspace root of development workspace.
-								file = new File(file, pathString);
-								return file.toURL();
-							}
-						}
-					} finally {
-						if (ios != null)
-							ios.close();
-					}
-				}
-			} catch (IOException e) {
-			}
-		}
-		
-		return null;
-
-	}
-	private URL[] findDevAllFromBundleAndFragments(Bundle bundle, String filenameWithinBundle) {
-		Bundle [] fragments = Platform.getFragments(bundle);
-		ArrayList urls = new ArrayList((fragments == null ? 0 : fragments.length) + 1);
-		URL url = findDev(bundle, filenameWithinBundle);
-		if (url != null)
-			urls.add(url);
-		if (fragments != null) {
-			for (int i = 0; i < fragments.length; i++) {
-				Bundle fragment = fragments[i];
-				url = findDev(fragment, filenameWithinBundle);
-				if (url != null)
-					urls.add(url);
-			}
-		}
-		return (URL[]) urls.toArray(new URL[urls.size()]);
-	}
-	
-	/**
-	 * Get the urls for the bundle and all fragments. This is used when bundles/fragments are jarred. It won't work correctly if not 
-	 * a jarred bundle and fragments. This would most likely be used for NLS
-	 * purposes to bring in the bundle and all of the nls. If a specific fragment was wanted use {@link #urlLocalizeBundle(Bundle)} instead.
-	 * 
-	 * @param bundle
-	 * @return urls for bundle and all fragments.
-	 * 
-	 * @since 1.2.0
-	 */
-	public URL[] urlLocalizeBundleAndFragments(Bundle bundle) {
-		Bundle[] fragments = Platform.getFragments(bundle);
-		List urls = new ArrayList((fragments == null ? 0 : fragments.length) + 1);
-		URL[] burls = urlLocalizeBundle(bundle);
-		if (burls != null) {
-			urls.addAll(Arrays.asList(burls));
-		}
-		if (fragments != null) {
-			for (int i = 0; i < fragments.length; i++) {
-				burls = urlLocalizeBundle(fragments[i]);
-				if (burls != null)
-					urls.addAll(Arrays.asList(burls));
-			}
-		}
-
-		return (URL[]) urls.toArray(new URL[urls.size()]);
-
-	}
-	
-	/**
-	 * Get the urls for the bundle libraries only. If a fragment is wanted, then pass in the fragment instead.
-	 * If bundle and all fragments are wanted use {@link #urlLocalizeBundleAndFragments(Bundle)} instead.
-	 * <p>
-	 * If in dev mode, it will use the binary output directory for the plugin libraries from the build.properties file. 
-	 * 
-	 * @param bundle
-	 * @return URL array of local library references for the bundle or null if can't resolve to local.
-	 * 
-	 * @since 1.2.0
-	 */
-	public URL[] urlLocalizeBundle(Bundle bundle) {
-		URL[] pvms;
-		try {
-			pvms = new URL[] {Platform.resolve(bundle.getEntry("/"))};
-			if (pvms[0].getProtocol().equals("jar")) {
-				// The bundle is a jar, so use as is. 
-				pvms[0] = getFilePath(pvms[0]);
-				return pvms;
-			}
-		} catch (IOException e) {
-			pvms = null;
-		}
-		try {
-			// It is a directory. We could be in either development mode or not. Walk the manifest classpath and find the libraries.
-			Properties buildProps = null;
-			String libraries = (String) bundle.getHeaders().get(Constants.BUNDLE_CLASSPATH);
-			ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, libraries);
-			List urls = new ArrayList();
-			if (elements != null) {
-				for (int i = 0; i < elements.length; i++) {
-					try {
-						URL pvm = bundle.getEntry(elements[i].getValue());
-						if (pvm != null) {
-							urls.add(Platform.asLocalURL(pvm));
-							continue;
-						}
-					} catch (IOException e) {
-					}				
-					if (devMode) {
-						// Not found as a jar, so see if can be found in devmode.
-						if (buildProps == null) {
-							buildProps = new Properties();
-							try {
-								URL bp = bundle.getEntry("build.properties");
-								if (bp != null) {
-									InputStream ios = null;
-									try {
-										ios = bp.openStream();
-										buildProps.load(ios);
-									} finally {
-										if (ios != null)
-											ios.close();
-									}
-								}
-							} catch (IOException e) {
-							}
-						}
-						String pathString = buildProps.getProperty("output."+elements[i].getValue());
-						if (pathString != null) {
-							try {
-								urls.add(Platform.asLocalURL(bundle.getEntry(pathString)));
-							} catch (IOException e) {
-							}
-						}
-					}
-				}
-				return (URL[]) urls.toArray(new URL[urls.size()]);
-			} else if (devMode) {
-				// If dev mode then we would look in the build.properties to find the output.. entry. This tells where the binaries are 
-				// for project. If there is no "output.." entry then either it is not a runnable plugin or the rare case is it is only
-				// classfiles in a folder. In that case see if there is a "source.." entry and use that.
-				try {
-					URL bp = bundle.getEntry("build.properties");
-					if (bp != null) {
-						InputStream ios = null;
-						try {
-							ios = bp.openStream();
-							Properties props = new Properties();
-							props.load(ios);
-							String pathString = props.getProperty("output..");
-							if (pathString != null) {
-								return new URL[] {Platform.resolve(bundle.getEntry(pathString))};
-							} else if ((pathString = props.getProperty("source..")) != null) {
-								// Probably a class folder, so use the source instead.
-								return new URL[] {Platform.resolve(bundle.getEntry(pathString))};
-							} else
-								return pvms;	// Try the root of the plugin.
-						} finally {
-							if (ios != null)
-								ios.close();
-						}
-					}
-				} catch (IOException e) {
-				}
-				
-			}
-		} catch (BundleException e) {
-		}
-		return null;
-	}
-	
-	/**
-	 * Returns a url as file url if it can. If it is already a file url, it will just return it.
-	 * If it is "jar:file:...." type protocol, then it will strip it down to the file part, which is
-	 * the jar itself, and not the file within the jar. 
-	 * @param l
-	 * @return
-	 * 
-	 * @since 1.2.0
-	 */
-	public static URL getFilePath(URL l) {
-		if (l != null) {
-			if (l.getProtocol().equals("file")) //$NON-NLS-1$
-			     return l;
-			else if (l.getProtocol().equals("jar")) { //$NON-NLS-1$
-				String f = l.getFile();
-				int idx = f.lastIndexOf('!');
-				if (idx>=0)
-					f = f.substring(0,idx);
-				try {
-					return getFilePath(new URL(f));
-				} catch (MalformedURLException e) {}
-			}
-		}
-		return null;
-	}
-	
-	/**
-	 * A helper to order the plugins into pre-req order. 
-	 * If A eventually depends on B, then B will be ahead of A in the
-	 * list of plugins. (I.e. B is a pre-req somewhere of A).
-	 *  
-	 * @param bundlesToOrder - Bundles of interest. The results will have these in thiee correct order.
-	 * @return An array of the Bundlers in there order from no prereqs in set to the leaves.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static Bundle[] orderPlugins(final Set bundlesToOrder) {
-		Map prereqsMap = new HashMap(bundlesToOrder.size()*3);
-		int ndx = bundlesToOrder.size();
-		Bundle[] result = new Bundle[ndx];
-		Map dependents = getDependentCounts(false, bundlesToOrder, prereqsMap);	// We want the inactive ones too. That way have complete order. They can be ignored later if necessary.
-		// keep iterating until all have been visited. This will actually find them in reverse order from what we
-		// want, i.e. it will find the leaves first. So we will build result array in reverse order.
-		while (!dependents.isEmpty()) {
-			// loop over the dependents list.  For each entry, if there are no dependents, visit
-			// the bundle and remove it from the list.  Make a copy of the keys so we don't end up
-			// with concurrent accesses (since we are deleting the values as we go)
-			Iterator ib = dependents.entrySet().iterator();
-			while (ib.hasNext()) {
-				Map.Entry entry = (Map.Entry) ib.next();
-				Bundle bundle = (Bundle) entry.getKey() ;
-				int[] count = (int[]) entry.getValue();
-				if (count != null && count[0] <= 0) {
-					if (bundlesToOrder.contains(bundle)) {
-						result[--ndx] = bundle;
-						if (ndx == 0)
-							return result;	// We've ordered all that we care about. Anything left over is unimportant.
-					}
-					ib.remove();
-					// decrement the dependent count for all of the prerequisites.
-					Bundle[] requires = getPrereqs(bundle, prereqsMap);
-					for (int j = 0; j < requires.length; j++) {
-						Bundle prereq = requires[j];
-						int[] countPrereq = (int[]) dependents.get(prereq);
-						if (countPrereq != null)
-							--countPrereq[0];
-					}
-				}
-			}
-		}		
-		return result;
-	}
-	
-	/**
-	 * Get all of the prereqs for this bundle, all of the way down to the root.
-	 * They will be in top-down depth-first order. There won't be duplicates. They will show up
-	 * only once the first time they are found.
-	 * 
-	 * @param bundle
-	 * @return list of all pre-reqs.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static List getAllPrereqs(Bundle bundle) {
-		List prereqs = new ArrayList();
-		getAllPrereqs(bundle, prereqs, new HashMap());
-		return prereqs;
-	}
-	
-	private static void getAllPrereqs(Bundle bundle, List prereqs, Map prereqsMap) {
-		Bundle[] prs = getPrereqs(bundle, prereqsMap);
-		for (int i = 0; i < prs.length; i++) {
-			Bundle pre = prs[i];
-			if (prereqsMap.containsKey(pre))
-				continue;	// Already processed this one once.
-			prereqs.add(pre);	// Add to the list of pre-reqs accumulated so far.
-			getAllPrereqs(pre, prereqs, prereqsMap);
-		}
-	}
-	
-	private static Bundle[] getPrereqs(Bundle bundle, Map prereqsMap) {
-		Bundle[] prereqs = (Bundle[]) prereqsMap.get(bundle);
-		if (prereqs == null) {
-			prereqs = getPrereqs(bundle);
-			prereqsMap.put(bundle, prereqs);
-		}
-		return prereqs;
-	}
-	
-	public static Bundle[] getPrereqs(Bundle bundle) {
-		Bundle[] l = (Bundle[]) pluginRequiredMap.get(bundle.getSymbolicName());
-		if (l == null) {
-			BundleSpecification specs[] = Platform.getPlatformAdmin().getState(false).getBundle(bundle.getBundleId()).getRequiredBundles();
-			ArrayList bundles = new ArrayList(specs.length);
-			for (int i = 0; i < specs.length; i++) {
-				Bundle b = Platform.getBundle(specs[i].getName());
-				if (b != null)
-					bundles.add(b);
-			}
-			l = (Bundle[]) bundles.toArray(new Bundle[bundles.size()]);
-			pluginRequiredMap.put(bundle.getSymbolicName(), l);
-		}
-		return l;
-	}
-	
-	private static Map getDependentCounts(boolean activeOnly, Set startingSet, Map prereqsMap) {
-		// Try to maintain independents in order from the starting set (which happens to be ordered, and hopefully reversed.).
-		// Trying to have leaves show up in same order they are found in the Eclipse extensions, so we should
-		// have the starting set be in reverse order from that. The actual process
-		// builds them in reverse order from the starting set, so we expect the startingSet to be in  reverse order so they will be in forward order
-		// hopefully. This is just a heuristic. There is no guarentee it will actually produce the 
-		// desired output.
-		Map dependents = new LinkedHashMap(startingSet.size());	
-		// build a table of all dependent counts.  The table is keyed by descriptor and
-		// the value the integer number of dependent plugins.
-		List processNow = new ArrayList(startingSet);
-		List processNext = new ArrayList(processNow.size());
-		if (!processNow.isEmpty()) {
-			// Go through the first time from the starting set to get an entry into the list.
-			// If there is an entry, then it won't be marked for processNext. Only new entries
-			// are added to processNext in the following loop.
-			int pnSize = processNow.size();
-			for (int i = 0; i < pnSize; i++) {
-				Bundle bundle = (Bundle) processNow.get(i);
-				if (activeOnly && bundle.getState() != Bundle.ACTIVE)
-					continue;
-				// ensure there is an entry for this descriptor (otherwise it will not be visited)
-				int[] entry = (int[]) dependents.get(bundle);
-				if (entry == null)
-					dependents.put(bundle, new int[1]);
-			}
-		}
-		
-		// Now process the processNow to find the requireds, increment them, and add to processNext if never found before.
-		while (!processNow.isEmpty()) {
-			processNext.clear();
-			int pnSize = processNow.size();
-			for (int i = 0; i < pnSize; i++) {
-				Bundle bundle = (Bundle) processNow.get(i);
-				if (activeOnly && bundle.getState() != Bundle.ACTIVE)
-					continue;			
-				Bundle[] requires = getPrereqs(bundle, prereqsMap);
-				for (int j = 0; j < requires.length; j++) {
-					Bundle prereq = requires[j];
-					if (prereq == null || activeOnly
-							&& bundle.getState() != Bundle.ACTIVE)
-						continue;
-					int[] entry = (int[]) dependents.get(prereq);
-					if (entry == null) {
-						dependents.put(prereq, new int[]{1});
-						processNext.add(prereq); // Never processed before, so we add it to the next process loop.
-					} else
-						++entry[0];
-				}
-			}
-			
-			// Now swap the lists so that we processNext will be now and visa-versa.
-			List t = processNext;
-			processNext = processNow;
-			processNow = t;
-		}
-		return dependents;
-	}
-		
-	/**
-	 * Add a shutdown listener
-	 * @param listener
-	 * 
-	 * @since 1.0.0
-	 */
-	public void addProxyShutdownListener(IProxyPluginShutdownListener listener) {
-		if (shutdownListeners == null)
-			shutdownListeners = new ListenerList();
-		shutdownListeners.add(listener);
-	}
-
-	/**
-	 * Remove a shutdown listener
-	 * @param listener
-	 * 
-	 * @since 1.0.0
-	 */
-	public void removeProxyShutdownListener(IProxyPluginShutdownListener listener) {
-		if (shutdownListeners != null)
-			shutdownListeners.remove(listener);
-	}
-	
-	private ILaunchConfigurationListener launchListener = new ILaunchConfigurationListener() {
-		public void launchConfigurationAdded(ILaunchConfiguration configuration) {
-			try {
-				if (!configuration.isWorkingCopy() && IProxyConstants.ID_PROXY_LAUNCH_GROUP.equals(configuration.getCategory()))
-					startCleanupJob();
-			} catch (Exception e) {
-			}
-		}
-
-		public void launchConfigurationChanged(ILaunchConfiguration configuration) {
-			try {
-				if (!configuration.isWorkingCopy() && IProxyConstants.ID_PROXY_LAUNCH_GROUP.equals(configuration.getCategory()))
-					startCleanupJob();
-			} catch (Exception e) {
-			}
-		}
-
-		public void launchConfigurationRemoved(ILaunchConfiguration configuration) {
-			try {
-				// On delete you can't tell the category or anything because all of that info has already removed.
-				if (!configuration.isWorkingCopy())
-					startCleanupJob();
-			} catch (Exception e) {
-			}
-		}
-	};
-	
-	private Job cleanupJob = new Job(ProxyMessages.ProxyPlugin_CleanupDefaultProxyLaunchConfigurations) { 
-		{
-			setSystem(true);	// So it doesn't show up in progress monitor. No need to interrupt user.
-			setPriority(Job.SHORT);	// A quick running job.
-		}
-		protected IStatus run(IProgressMonitor monitor) {
-			synchronized (this) {
-				if (monitor.isCanceled())
-					return Status.CANCEL_STATUS;
-			}
-			// all we want to do is find out if any launch configurations (from proxy launch group) exist for
-			// a project. If they don't, then unset the project's property. If they do, and the property is not
-			// set, then set it to NOT_SET to indicate not set, but there are some configs for it.
-			// We just gather the project names that have launch configurations.
-			try {
-				Set projectNames = new HashSet();
-				ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations();
-				for (int i = 0; i < configs.length; i++) {
-					if (IProxyConstants.ID_PROXY_LAUNCH_GROUP.equals(configs[i].getCategory())
-						&& (ProxyLaunchSupport.ATTR_PRIVATE == null || !configs[i].getAttribute(ProxyLaunchSupport.ATTR_PRIVATE, false)))
-						projectNames.add(configs[i].getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "")); //$NON-NLS-1$
-				}
-
-				IJavaModel model = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
-				IJavaElement[] children = model.getChildren();
-				int cancelCount = 10;
-				for (int j = 0; j < children.length; j++) {
-					if (children[j].getElementType() == IJavaElement.JAVA_PROJECT) {
-						if (--cancelCount <= 0)
-							synchronized (this) {
-								cancelCount = 10;	// Rest for next set of ten.
-								// Checking on every 10 projects because they may be many projects, while only few configs.
-								// This way it will stop sooner.
-								if (monitor.isCanceled())
-									return Status.CANCEL_STATUS;
-							}						
-						IProject p = ((IJavaProject) children[j]).getProject();
-						if (projectNames.contains(p.getName())) {
-							// This project has a launch config. If it has a setting, then do nothing, else need to put on not set. 
-							if (p.getPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION) == null)
-								p.getProject().setPersistentProperty(
-									ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION,
-									ProxyLaunchSupport.NOT_SET);
-						} else {
-							// This project has no launch configs. Remove any setting if it exists.
-							p.setPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION, (String) null);
-						}
-					}
-				}
-				return Status.OK_STATUS;
-			} catch (CoreException e) {
-				return e.getStatus();
-			}
-		}
-	};
-	
-	private void startCleanupJob() {
-		cleanupJob.cancel();	// Stop what we are doing.
-		cleanupJob.schedule(1000l);	// Schedule to start in one second.
-	}
-
-	
-	/* (non-Javadoc)
-	 * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
-	 */
-	public void start(final BundleContext context) throws Exception {
-		super.start(context);
-		DebugPlugin.getDefault().getLaunchManager().addLaunchConfigurationListener(launchListener);
-		context.addBundleListener(new BundleListener() {
-			public void bundleChanged(BundleEvent event) {
-				if (event.getBundle() != ProxyPlugin.this.getBundle())
-					return;	// Not of interest to us.
-				switch (event.getType()) {
-					case BundleEvent.STARTED:
-						context.removeBundleListener(this);	// Since we don't care anymore
-						startCleanupJob();
-						break;
-					case BundleEvent.STOPPED:
-					case BundleEvent.UNINSTALLED:
-					case BundleEvent.UNRESOLVED:
-						context.removeBundleListener(this);	// We stopped before we started, so remove ourselves.
-						break;
-				}
-			}
-		});
-		getPluginPreferences().setDefault(PREFERENCES_VM_NOVERIFY_KEY, true);
-	}
-	
-
-	/* (non-Javadoc)
-	 * @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)
-	 */
-	public void stop(BundleContext context) throws Exception {
-		// Handle case where debug plugin shuts down before we do since order not guarenteed.
-		if (DebugPlugin.getDefault() != null)
-			DebugPlugin.getDefault().getLaunchManager().removeLaunchConfigurationListener(launchListener);
-		cleanupJob.cancel();	// Stop what we are doing.		
-		if (shutdownListeners != null) {
-			Object[] listeners = shutdownListeners.getListeners();
-			for (int i = 0; i < listeners.length; i++) {
-				((IProxyPluginShutdownListener) listeners[i]).shutdown();
-			}
-		}		
-		super.stop(context);
-	}
-	
-	public static final String PI_CONFIGURATION_CONTRIBUTION_EXTENSION_POINT = "org.eclipse.jem.proxy.contributors"; //$NON-NLS-1$
-	public static final String PI_EXTENSION_REGISTRATION_EXTENSION_POINT = "org.eclipse.jem.proxy.extensions"; //$NON-NLS-1$
-	public static final String PI_CONTAINER = "container"; //$NON-NLS-1$
-	public static final String PI_PLUGIN = "plugin"; //$NON-NLS-1$
-	public static final String PI_CLASS = "class"; //$NON-NLS-1$
-	public static final String PI_REGISTRY_TYPE = "registryType";	//$NON-NLS-1$
-	public static final Map pluginRequiredMap = new HashMap(50);
-	
-	/*
-	 * Processed extension point info for contributors.
-	 */
-	protected ContributorExtensionPointInfo contributions;
-		
-	/*
-	 * Processed extension point info for registry extensions.
-	 */
-	protected ContributorExtensionPointInfo extensions;
-
-
-	/**
-	 * These are public only so that jem.ui can access this constant. Not meant to be accessed by others.
-	 */
-	public static final QualifiedName PROPERTY_LAUNCH_CONFIGURATION = new QualifiedName("org.eclipse.jem.proxy", "proxyLaunchConfiguration"); //$NON-NLS-1$ //$NON-NLS-2$
-	
-	/**
-	 * Return the plugin ordered array of configuration elements for the given container, or <code>null</code> if not contributed.
-	 * 
-	 * @param containerid the first segment of all of the container paths is the container id.
-	 * @param containerPaths array of container paths to match against for contributions. The paths must all be of the same container id.
-	 * @return Array of configuration elements. 
-	 * 
-	 * @since 1.0.0
-	 */
-	public synchronized IConfigurationElement[] getContainerConfigurations(String containerid, String[] containerPaths) {
-		if (contributions == null)
-			processProxyContributionExtensionPoint();
-		return (IConfigurationElement[]) contributions.containerPathContributions.getContributors(containerid, containerPaths);
-	}
-
-	/**
-	 * Return the plugin ordered array of configuration elements for the given plugin, or <code>null</code> if not contributed.
-	 * 
-	 * @param pluginid
-	 * @return Array of configuration elements or <code>null</code> if this plugin has no contributions.
-	 * 
-	 * @since 1.0.0
-	 */
-	public synchronized IConfigurationElement[] getPluginConfigurations(String pluginid) {
-		if (contributions == null)
-			processProxyContributionExtensionPoint();
-		return (IConfigurationElement[]) contributions.pluginToContributions.get(pluginid);
-	}
-
-	/**
-	 * Return the plugin ordered array of configuration elements for the given container, or <code>null</code> if not contributed.
-	 * 
-	 * @param containerid the first segment of all of the container paths is the container id.
-	 * @param containerPaths array of container paths to match against for contributions. The paths must all be of the same container id.
-	 * @return Array of configuration elements.
-	 * 
-	 * @since 1.0.0
-	 */
-	public synchronized IConfigurationElement[] getContainerExtensions(String containerid, String[] containerPaths) {
-		if (extensions == null)
-			processProxyExtensionExtensionPoint();
-		return (IConfigurationElement[]) extensions.containerPathContributions.getContributors(containerid, containerPaths);
-	}
-
-	/**
-	 * Return the plugin ordered array of configuration elements for the given plugin, or <code>null</code> if not contributed.
-	 * 
-	 * @param pluginid
-	 * @return Array of configuration elements or <code>null</code> if this plugin has no contributions.
-	 * 
-	 * @since 1.0.0
-	 */
-	public synchronized IConfigurationElement[] getPluginExtensions(String pluginid) {
-		if (extensions == null)
-			processProxyExtensionExtensionPoint();
-		return (IConfigurationElement[]) extensions.pluginToContributions.get(pluginid);
-	}
-
-	protected synchronized void processProxyContributionExtensionPoint() {
-		contributions = processContributionExtensionPoint(PI_CONFIGURATION_CONTRIBUTION_EXTENSION_POINT);
-	}
-	
-	protected synchronized void processProxyExtensionExtensionPoint() {
-		extensions = processContributionExtensionPoint(PI_EXTENSION_REGISTRATION_EXTENSION_POINT);
-	}	
-	
-	/**
-	 * Process the extension point looking contributors. It will find entries that have the "container" or "plugin" attributes
-	 * set on them.
-	 * 
-	 * @param extensionPoint fully-qualified extension point id, including plugin id of the extension point.
-	 * @return the contributor info record.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static ContributorExtensionPointInfo processContributionExtensionPoint(String extensionPoint) {	
-		// We are processing this once because it is accessed often (once per vm per project).
-		// This can add up so we get it together once here.
-		IExtensionPoint extp = Platform.getExtensionRegistry().getExtensionPoint(extensionPoint);
-		ContributorExtensionPointInfo result = new ContributorExtensionPointInfo();
-		result.containerPathContributions = new ContainerPathContributionMapping(IConfigurationElement.class);
-		if (extp == null) {
-			result.pluginToContributions = Collections.EMPTY_MAP;
-			return result;
-		}
-		
-		IExtension[] extensions = extp.getExtensions();
-		if (extensions.length > 0) {
-			// Need to be in plugin order so that first ones processed have no dependencies on others.
-			// Gather in extension order.
-			// We want the list in reverse order of found extensions for a bundle. This is a heuristic to try
-			// to get leaves ordered in the order found from the extension list. Since the orderPlugins actually
-			// reverses the leaf order, hopefully this will set it back to what we want at the end.
-			HashMap bundlesToExtensions = new LinkedHashMap(extensions.length);
-			for (int i = extensions.length-1; i >= 0; i--) {
-				Bundle bundle = Platform.getBundle(extensions[i].getNamespace());
-				IExtension[] ext = (IExtension[]) bundlesToExtensions.get(bundle);
-				if (ext == null)
-					bundlesToExtensions.put(bundle, new IExtension[] { extensions[i]});
-				else {
-					// More than one extension defined in this plugin.
-					IExtension[] newExt = new IExtension[ext.length + 1];
-					System.arraycopy(ext, 0, newExt, 0, ext.length);
-					newExt[newExt.length - 1] = extensions[i];
-					bundlesToExtensions.put(bundle, newExt);
-				}
-			}
-
-			// Now order them so we process in required order.
-			Bundle[] ordered = ProxyPlugin.orderPlugins(bundlesToExtensions.keySet());
-			Map patternStringToID_Pattern = new HashMap(); // Map of string patterns to the {container id, compiled pattern}. This so that we use the same compiled pattern everywhere.
-			result.pluginToContributions = new HashMap(ordered.length);
-			for (int i = 0; i < ordered.length; i++) {
-				IExtension[] exts = (IExtension[]) bundlesToExtensions.get(ordered[i]);
-				for (int j = 0; j < exts.length; j++) {
-					IConfigurationElement[] configs = exts[j].getConfigurationElements();
-					// Technically we expect the config elements to have a name of "contributor", but since that
-					// is all that can be there, we will ignore it. The content is what is important.
-					for (int k = 0; k < configs.length; k++) {
-						String containerPattern = configs[k].getAttributeAsIs(PI_CONTAINER);
-						if (containerPattern != null) {
-							Object[] id_Pattern = (Object[]) patternStringToID_Pattern.get(containerPattern);
-							if (id_Pattern == null) {
-								int slash = containerPattern.indexOf('/');
-								String containerID = slash != -1 ? containerPattern.substring(0, slash) : containerPattern;
-								// The pattern becomes for the containerPattern "SWT_CONTAINER" becomes "SWT_CONTAINER(/.*)*". This
-								// means to match the string must start with "SWT_CONTAINER" and it must have either nothing after this
-								// or it must have a "/" and any characters after that. So this means it will not match "SWT_CONTAINERXZ"
-								// but it will match "SWT_CONTAINER/XYZ".
-								id_Pattern = new Object[] { containerID, Pattern.compile(containerPattern + "(/.*)*")};
-								patternStringToID_Pattern.put(containerPattern, id_Pattern);
-							}
-							result.containerPathContributions.addContribution((String) id_Pattern[0], (Pattern) id_Pattern[1], configs[k]);
-						}
-
-						String plugin = configs[k].getAttributeAsIs(PI_PLUGIN);
-						if (plugin != null) {
-							List contributions = (List) result.pluginToContributions.get(plugin);
-							if (contributions == null) {
-								contributions = new ArrayList(1);
-								result.pluginToContributions.put(plugin, contributions);
-							}
-							contributions.add(configs[k]);
-						}
-					}
-				}
-			}
-
-			// Finalize the mappings for both container paths and plugins.
-			result.containerPathContributions.finalizeMapping();
-			for (Iterator iter = result.pluginToContributions.entrySet().iterator(); iter.hasNext();) {
-				Map.Entry entry = (Map.Entry) iter.next();
-				entry.setValue(((List) entry.getValue()).toArray(new IConfigurationElement[((List) entry.getValue()).size()]));
-			}
-		} else
-			result.pluginToContributions = Collections.EMPTY_MAP;
-		return result;
-	}
-	
-	/**
-	 * The result of the {@link ProxyPlugin#getIDsFound(IJavaProject)}.
-	 * 
-	 * @since 1.2.0
-	 */
-	public static class FoundIDs {
-		
-		/**
-		 * Map of (containerIds(String)->{@link ContainerPaths}) of containers classpaths found in the project's classpath.
-		 * 
-		 */
-		public Map containerIds = new HashMap(2);
-		
-		/**
-		 * Map of (containers({@link IClasspathContainer})->Boolean) of containers found in the project's classpath. The value will be <code>true</code> if the container is visible to the top-level project.
-		 */
-		public Map containers = new HashMap(2);
-		
-		/**
-		 * Map of (pluginIds(String)->Boolean) of plugin ids found in the project's classpath if the project is a plugin project. The value will be <code>true</code> if the plugin is visible to the top-level project.
-		 */
-		public Map pluginIds;
-		
-		/**
-		 * Map of (projects({@link IPath}->Boolean) of project found in the project's classpath. The value will be <code>true</code> if the project is visible to the top-level project.
-		 */
-		public Map projects = new HashMap(2);
-		
-		FoundIDs() {
-			// not meant to be instantiated or subclassed by clients.
-		}
-	}
-	
-	/**
-	 * For the given java project, return the maps of found ids.
-	 *
-	 * @param jproject
-	 * @return the found ids.
-	 * 
-	 * @since 1.0.0
-	 */
-	public FoundIDs getIDsFound(IJavaProject jproject) throws JavaModelException {		
-		IPath projectPath = jproject.getProject().getFullPath();
-		FoundIDs foundIDs = new FoundIDs();
-		foundIDs.projects.put(projectPath, Boolean.TRUE);		
-		expandProject(projectPath, foundIDs, true, true);
-		
-		// The containerIds values will actually be an Map[] {Map(visibleIPath->pathString), Map(hiddenIPath->pathString)}. Needs to be converted to a ContainerPaths now
-		// that we are done.
-		for (Iterator itr = foundIDs.containerIds.entrySet().iterator(); itr.hasNext();) {
-			Map.Entry entry = (Entry) itr.next();
-			Map[] value = (Map[]) entry.getValue();
-			entry.setValue(new ContainerPaths((String) entry.getKey(), (String[]) value[0].values().toArray(new String[value[0].size()]), (String[]) value[1].values().toArray(new String[value[1].size()])));
-		}
-		
-		if (foundIDs.pluginIds == null)
-			foundIDs.pluginIds = Collections.EMPTY_MAP;
-		
-		foundIDs.projects.remove(projectPath);	// Don't need to include itself now, was needed for testing so if ciruclar we don't get into a loop.
-		if (foundIDs.projects.isEmpty())
-			foundIDs.projects = Collections.EMPTY_MAP;
-		
-		return foundIDs;
-
-	}
-	
-	private static final IPath JRE_CONTAINER_PATH = new Path(JavaRuntime.JRE_CONTAINER);
-	
-	/*
-	 * The passed in visible flag tells if this project is visible and its contents are visible if they are exported.
-	 * Only exception is if first is true, then all contents are visible to the top level project.
-	 */
-	private void expandProject(IPath projectPath, FoundIDs foundIds, boolean visible, boolean first) throws JavaModelException {
-		IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(projectPath.lastSegment());
-		if (res == null)
-			return;	// Not exist so don't delve into it.
-		IJavaProject project = (IJavaProject)JavaCore.create(res);
-		if (project == null || !project.exists() || !project.getProject().isOpen())
-			return;	// Not exist as a java project or not open, so don't delve into it.
-
-		IClasspathEntry[] entries = project.getRawClasspath();
-		for (int i = 0; i < entries.length; i++) {
-			IClasspathEntry entry = entries[i];
-			Boolean currentFlag = null;	// Current setting value.
-			boolean newFlag;	// The new setting value. 
-			switch (entry.getEntryKind()) {
-				case IClasspathEntry.CPE_PROJECT:
-					// Force true if already true, or this is the first project, or this project is visible and the entry is exported. These override a previous false.
-					currentFlag = (Boolean) foundIds.projects.get(entry.getPath());
-					newFlag = (currentFlag != null && currentFlag.booleanValue()) || first || (visible && entry.isExported());
-					if (currentFlag == null || currentFlag.booleanValue() != newFlag)
-						foundIds.projects.put(entry.getPath(),  newFlag ? Boolean.TRUE : Boolean.FALSE );
-					if (currentFlag == null)
-						expandProject(entry.getPath(), foundIds, visible && entry.isExported(), false);
-					break;
-				case IClasspathEntry.CPE_CONTAINER:
-					if (!first && JavaRuntime.JRE_CONTAINER.equals(entry.getPath().segment(0))) //$NON-NLS-1$
-						break;	// The first project determines the JRE, so any subsequent ones can be ignored.
-					Map[] paths = (Map[]) foundIds.containerIds.get(entry.getPath().segment(0));
-					if (paths == null) {
-						paths = new Map[] {new HashMap(2), new HashMap(2)};
-						foundIds.containerIds.put(entry.getPath().segment(0), paths);
-					}
-					currentFlag = null;
-					if (paths[0].containsKey(entry.getPath()))
-						currentFlag = Boolean.TRUE;
-					else if (paths[1].containsKey(entry.getPath()))
-						currentFlag = Boolean.FALSE;
-					newFlag = (currentFlag != null && currentFlag.booleanValue()) || first || (visible && entry.isExported());					
-					if (currentFlag == null || currentFlag.booleanValue() != newFlag) {
-						if (newFlag) {
-							// It is visible, remove from hidden, if there, and add to visible.
-							paths[1].remove(entry.getPath());
-							paths[0].put(entry.getPath(), entry.getPath().toString());
-						} else {
-							// It is hidden, remove from visible, if there, and add to hidden.
-							paths[0].remove(entry.getPath());
-							paths[1].put(entry.getPath(), entry.getPath().toString());
-						}
-					}
-
-					IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project);
-					// Force true if already true, or this is the first project, or this project is visible and the entry is exported. These override a previous false.
-					currentFlag = (Boolean) foundIds.containers.get(container);
-					newFlag = (currentFlag != null && currentFlag.booleanValue()) || first || (visible && entry.isExported());
-					if (currentFlag == null || currentFlag.booleanValue() != newFlag)					
-						foundIds.containers.put(container,  newFlag ? Boolean.TRUE : Boolean.FALSE );
-					break;
-				case IClasspathEntry.CPE_VARIABLE:
-					// We only care about JRE_LIB. If we have that, then we will treat it as JRE_CONTAINER. Only
-					// care about first project too, because the first project is the one that determines the JRE type.
-					if (first && JavaRuntime.JRELIB_VARIABLE.equals(entry.getPath().segment(0))) { //$NON-NLS-1$
-						paths = (Map[]) foundIds.containerIds.get(JavaRuntime.JRE_CONTAINER);
-						if (paths == null) {
-							paths = new Map[] {new HashMap(2), new HashMap(2)};
-							foundIds.containerIds.put(JavaRuntime.JRE_CONTAINER, paths);
-						}
-						currentFlag = null;
-						if (paths[0].containsKey(JRE_CONTAINER_PATH))
-							currentFlag = Boolean.TRUE;
-						else if (paths[1].containsKey(JRE_CONTAINER_PATH))
-							currentFlag = Boolean.FALSE;
-						newFlag = (currentFlag != null && currentFlag.booleanValue()) || first || (visible && entry.isExported());					
-						if (currentFlag == null || currentFlag.booleanValue() != newFlag) {
-							if (newFlag) {
-								// It is visible, remove from hidden, if there, and add to visible.
-								paths[1].remove(JRE_CONTAINER_PATH);
-								paths[0].put(JRE_CONTAINER_PATH, JavaRuntime.JRE_CONTAINER);
-							} else {
-								// It is hidden, remove from visible, if there, and add to hidden.
-								paths[0].remove(JRE_CONTAINER_PATH);
-								paths[1].put(JRE_CONTAINER_PATH, JavaRuntime.JRE_CONTAINER);
-							}
-						}
-					}
-					break;
-				default:
-					break;
-			}
-		}		
-		
-		findPlugins(foundIds, visible, first, project);
-	}
-	
-	/**
-	 * Find the plugins that the given project references, either directly or indirectly.
-	 * <p>
-	 * The map will be of plugin ids to a Boolean. If the boolean is <code>BooleanTRUE</code>,
-	 * then the plugin is visible to the given project. the visible and first flags
-	 * will modify this. If first is true, then all direct plugins will be visible,
-	 * else only exported plugins will be visible. If visible is false and first is false, then it doesn't matter, all of the
-	 * plugins will not be visible. 
-	 * <p>
-	 * Visible means that classes in the plugin can be referenced directly from code. Not visible
-	 * means that they can only be referenced from some other plugin in the list. In other words,
-	 * visible ones can be directly referenced, but invisible ones can only be referenced from
-	 * plugins that can see it.
-	 * <p>
-	 * For most uses, first and visible should be true. Then it will treat the project as the toplevel
-	 * project and will return true for those that are visible to it, either directly or indirectly.
-	 * These flags were added for more special cases where may be calling on a project that is deeper
-	 * down in the classpath were visibilty has already been decided.
-	 * <p>
-	 * Note: PDE must be installed for this to return anything, otherwise it will leave
-	 * the map alone.
-	 * 
-	 * @param foundIds foundIds structure to get plugin info from.
-	 * @param visible <code>true</code> means this project is visible, so any plugins visible to it will be visible, else none will be visible.
-	 * @param first <code>true</code> if this is the top project of interest. This means that all plugins within the project are visible. Else only exported projects will be visible.
-	 * @param project project to start looking from
-	 * 
-	 * @since 1.0.2
-	 */
-	public void findPlugins(FoundIDs foundIds, boolean visible, boolean first, IJavaProject project) {
-		try {
-			// To prevent unnecessary loading of the PDE plugin, find the plugins only if this project is a PDE plugin project.
-			if (isPDEProject(project)) {
-				IPDEProcessForPlugin pdeprocess = getPDEProcessForPlugin();
-				if (pdeprocess != null) {
-					if (foundIds.pluginIds == null)
-						foundIds.pluginIds = new HashMap();
-					pdeprocess.findPlugins(project, foundIds, visible, first); // expand the plugins for this project, if any.
-				}
-			}
-		} catch (CoreException e) {
-		}
-	}
-
-	/**
-	 * 
-	 * @param project
-	 * 
-	 * @return true if this is a Plugin project or false if not
-	 * @throws CoreException
-	 * 
-	 * @since 1.1.0
-	 */
-	public static boolean isPDEProject(IJavaProject project) throws CoreException {
-		return project.getProject().hasNature(PDE_NATURE_ID);
-	}
-
-
-	/*
-	 * Interface for processing Plugins. Used when PDE plugin is present in the installation. 
-	 * 
-	 * @since 1.0.2
-	 */
-	interface IPDEProcessForPlugin {
-
-		/*
-		 * Go through the project and find all of the plugins it references, either directly or through
-		 * the referenced plugins, and mark them as visible or not.
-		 */
-		public abstract void findPlugins(IJavaProject project, FoundIDs foundIds, boolean visible, boolean first);
-	}
-	
-	/*
-	 * Try to get the pde process for plugin. If already tried once and not found, then forget it.
-	 * <package-protected> because PDEContributeClasspath needs it too.
-	 */
-	private IPDEProcessForPlugin pdeProcessForPlugin;
-	private boolean triedPDEProcess;
-	IPDEProcessForPlugin getPDEProcessForPlugin() {
-		if (!triedPDEProcess) {
-			triedPDEProcess = true;
-			if (Platform.getBundle("org.eclipse.pde.core") != null) { //$NON-NLS-1$
-				try {
-					Class classPDEProcess = Class.forName("org.eclipse.jem.internal.proxy.core.PDEProcessForPlugin"); //$NON-NLS-1$
-					pdeProcessForPlugin = (IPDEProcessForPlugin) classPDEProcess.newInstance();
-				} catch (ClassNotFoundException e) {
-					// Not found, do nothing.
-				} catch (InstantiationException e) {
-					getLogger().log(e, Level.WARNING);
-				} catch (IllegalAccessException e) {
-					getLogger().log(e, Level.WARNING);
-				}
-			}
-		}
-		return pdeProcessForPlugin;
-	}
-	
-	/**
-	 * This tries to find a jar in the bundle specified, and the attached source using the
-	 * PDE source location extension point. The jar must exist for source to be attachable.
-	 * The source must be in the standard PDE source plugin. I.e. it must be in a directory
-	 * of the name "bundlename_bundleversion", and in the same path from there as in the
-	 * jar, plus the name must be "jarnamesrc.zip".
-	 * <p>
-	 * The returned URL's will not be Platform.resolve(). They will be in form returned from
-	 * Platform.find().
-	 * 
-	 * @param bundle bundle to search, will search fragments too.
-	 * @param filepath filepath from the root of the bundle/fragment where the jar will be found. 
-	 * @return two URL's. [0] is the URL to the jar, <code>null</code> if not found, [2] is the URL to the source zip, <code>null</code> if not found.
-	 * 
-	 * @since 1.0.0
-	 */
-	public URL[] findPluginJarAndAttachedSource(Bundle bundle, IPath filepath) {
-		// This is a bit kludgy, but the algorithm is to find the file first, and then get the root url of the bundle/fragment
-		// that matches the found file. This will be used to calculate the name of the directory under the source. From there
-		// all of the source extensions will be searched for the source zip file.
-		// This is assuming that find returns a url where the file part of the url is a standard path and doesn't have
-		// things like special chars to indicate within a jar. That would appear when it is resolved, but I think that the
-		// unresolved ones from find are typically "jarbundle://nnn/path" or something like that. This is a gray area.
-		URL jarURL = Platform.find(bundle, filepath);
-		if (jarURL == null)
-			return new URL[2];
-		
-		// Found it, so let's try to find which bundle/fragment it was found in.
-		String jarString = jarURL.toExternalForm();
-		// First the bundle itself.
-		String installLoc = bundle.getEntry("/").toExternalForm(); //$NON-NLS-1$
-		URL sourceURL = null;
-		if (jarString.startsWith(installLoc))
-			sourceURL = getSrcFrom(bundle, installLoc, jarString);
-		else {
-			// Now look in the fragments.
-			Bundle[] frags = Platform.getFragments(bundle);
-			for (int i = 0; i < frags.length; i++) {
-				installLoc = frags[i].getEntry("/").toExternalForm(); //$NON-NLS-1$
-				if (jarString.startsWith(installLoc)) {
-					sourceURL = getSrcFrom(frags[i], installLoc, jarString);
-					break;
-				}
-			}
-		}
-		return new URL[] {jarURL, sourceURL};
-	}
-	
-	private URL getSrcFrom(Bundle bundle, String installLoc, String jarString) {
-		// format of path in a PDE source plugin is (under the "src" directory from the extension point),
-		// "bundlename_bundleversion/pathOfJar/jarnamesrc.zip". However there is no way to know
-		// which extension has the source in it, so we need to search them all.
-		
-		IPath srcPath = new Path(bundle.getSymbolicName()+"_"+ (String) bundle.getHeaders("").get(Constants.BUNDLE_VERSION)); //$NON-NLS-1$ //$NON-NLS-2$ $NON-NLS-2$
-		srcPath = srcPath.append(new Path(jarString.substring(installLoc.length())));
-		if (srcPath.segmentCount() < 2)
-			return null;	// Something is not right. No jar name.
-		srcPath = srcPath.removeFileExtension();	// Remove the .jar.
-		String jarName = srcPath.lastSegment();	// This should be the jar name.
-		srcPath = srcPath.removeLastSegments(1).append(jarName+"src.zip"); //$NON-NLS-1$
-		
-		// Now look through all of the src extensions. Can't tell if the extension is from a fragment or a bundle, so we need to
-		// use Platform.find() to look in the bundle and fragment. So we may get a dup search if there is a fragment source 
-		// (for example platform source and win32 platform source (which is a fragment of platform source).
-		IConfigurationElement[] ces = Platform.getExtensionRegistry().getConfigurationElementsFor("org.eclipse.pde.core.source"); //$NON-NLS-1$
-		for (int i = 0; i < ces.length; i++) {
-			IPath srcsrch = new Path(ces[i].getAttributeAsIs("path")).append(srcPath); //$NON-NLS-1$
-			Bundle srcBundle = Platform.getBundle(ces[i].getDeclaringExtension().getNamespace());
-			URL srcUrl = Platform.find(srcBundle, srcsrch);
-			if (srcUrl != null) {
-				return srcUrl;
-			}
-		}
-		return null;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ThrowableProxy.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ThrowableProxy.java
deleted file mode 100644
index da9c5cc..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ThrowableProxy.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.core;
-/*
- *  $RCSfile: ThrowableProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-
-
-/**
- * This is a proxy wrapper for an exception being thrown on the
- * remove VM. The standard exception methods refer to this proxy.
- * To refer to the proxied exception itself, the methods defined
- * in here would be used.
- */
-public abstract class ThrowableProxy extends java.lang.Exception implements IBeanProxy {
-   /**
-    * Constructs an <code>Exception</code> with no specified detail message. 
-    */
-   public ThrowableProxy() {
-		super();
-   }
-
-	/**
-	 * @param message
-	 * @param cause
-	 * 
-	 * @since 1.1.0
-	 */
-	protected ThrowableProxy(String message, Throwable cause) {
-		super(message, cause);
-	}
-	/**
-	 * @param cause
-	 * 
-	 * @since 1.1.0
-	 */
-	protected ThrowableProxy(Throwable cause) {
-		super(cause);
-	}
-   /**
-    * Constructs an <code>Exception</code> with the specified detail message. 
-    *
-    * @param   s   the detail message.
-    */
-   public ThrowableProxy(String s) {
-		super(s);
-   }
-	
-	
-	public abstract String getProxyLocalizedMessage();
-	public abstract String getProxyMessage();
-	public abstract void printProxyStackTrace(java.io.PrintWriter writer);
-	public abstract void printProxyStackTrace(java.io.PrintStream stream);
-	public abstract void printProxyStackTrace();
-
-	public String toString() {
-		return super.toString() + "Proxy: " + toBeanString();	//$NON-NLS1$ - toString's aren't nls'ed. //$NON-NLS-1$
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/UIRunner.java b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/UIRunner.java
deleted file mode 100644
index 94e5002..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/UIRunner.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: UIRunner.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:05 $ 
- */
-package org.eclipse.jem.internal.proxy.core;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.logging.Level;
-
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.jface.operation.IRunnableWithProgress;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.PlatformUI;
- 
-
-/**
- * The actual implementation of IUIRunner to run the build under
- * IProgressService control if in the UI thread.
- * 
- * <package-protected> because should only be used within here.
- * 
- * @since 1.0.0
- */
-class UIRunner implements IUIRunner {
-	
-	/*
-	 * Special class that takes a progress monitor 1 and only handles isCanceled from it,
-	 * but everything else is forwarded to progress monitor 2. This allows the pm that
-	 * is sent into handleBuild to signal a cancel even though the progress service
-	 * sends in its own pm. 
-	 * 
-	 * @since 1.0.0
-	 */
-	private static class UIRunnerProgressMonitor extends ProgressMonitorWrapper {
-		private IProgressMonitor pmcancel;
-		
-		public UIRunnerProgressMonitor(IProgressMonitor pmcancel, IProgressMonitor pmmain) {
-			super(pmmain);
-			this.pmcancel = pmcancel;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.core.runtime.IProgressMonitor#isCanceled()
-		 */
-		public boolean isCanceled() {
-			return pmcancel.isCanceled() || super.isCanceled();
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.core.runtime.IProgressMonitor#setCanceled(boolean)
-		 */
-		public void setCanceled(boolean value) {
-			super.setCanceled(value);
-			pmcancel.setCanceled(value);	// Cancel it too now.
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IUIRunner#handleBuild(org.eclipse.core.runtime.IProgressMonitor)
-	 */
-	public void handleBuild(final IProgressMonitor pm) throws CoreException {
-		if (!PlatformUI.isWorkbenchRunning() || Display.getCurrent() == null) {
-			ProxyLaunchSupport.runBuild(pm);
-		} else {
-			pm.beginTask("", 100); //$NON-NLS-1$
-			try {
-				PlatformUI.getWorkbench().getProgressService().busyCursorWhile(new IRunnableWithProgress() {
-
-					public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
-						IProgressMonitor uipm = new UIRunnerProgressMonitor(pm, monitor); 
-						try {
-							ProxyLaunchSupport.runBuild(uipm);
-						} catch (CoreException e) {
-							throw new InvocationTargetException(e);
-						}
-						if (uipm.isCanceled()) {
-							pm.setCanceled(true);	// Make sure that cancel got through (could of come from monitor instead).
-							throw new InterruptedException();
-						}
-					}
-				});
-			} catch (InvocationTargetException e) {
-				if (e.getCause() instanceof CoreException)
-					throw (CoreException) e.getCause();
-				ProxyPlugin.getPlugin().getLogger().log(e.getCause(), Level.WARNING);
-			} catch (InterruptedException e) {
-				// It was canceled, launch will be canceled too. pm is already marked canceled and caller can check that
-			}
-			pm.done();
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/messages.properties b/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/messages.properties
deleted file mode 100644
index e6e08c3..0000000
--- a/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/messages.properties
+++ /dev/null
@@ -1,49 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/messages.properties,v $
-# $Revision: 1.12 $  $Date: 2005/08/24 20:39:05 $
-#
-
-
-
-#
-# Exception Messages. All of these messages are the text of an java exception.
-#
-UnexpectedException_EXC_                                    = IWAV0064E Unexpected exception thrown.
-
-# {0} and {1} are java classes (e.g. java.lang.Object)
-ClassCast_EXC__IncorrectType                                = IWAV0065E "{0}" is neither a subclass of, nor does it implement, class "{1}".
-
-# Standard Bean Proxy Factory and Standard Bean Type Proxy Factory are terms in beaninfo. They are the
-# standard (i.e. base) factories for beans or bean types. Bean types are java classes.
-ProxyFactory_EXC__NoBeanProxyFactory                        = IWAV0066E No Standard Bean Proxy Factory has been set.
-ProxyFactory_EXC__NoBeanTypeProxyFactory                    = IWAV0067E No Standard Bean Type Proxy Factory has been set.
-
-
-# {0} is the title of a project.
-Not_Java_Project_WARN_                                      = IWAV0068W Project "{0}" is not a java project.
-No_VM_WARN_                                                 = IWAV0069W Project "{0}" has no Java JRE defined to use to run programs within this project.
-No_Implementation_WARN_                                     = IWAV0070W Cannot find a proxy implementation to use for project "{0}."
-
-ProxyLaunch                                                 = Launching Local Proxy VM
-ProxyWaitForBuild                                           = Waiting for build to complete
-Expression_InInvalidStateDueTo_EXC_                         = IWAV0162E Expression is in invalid state due to "{0}"
-Expression_InInvalidState_EXC_                              = IWAV0163E Expression is in invalid state
-Expression_TypeSentInInvalidOrder_EXC_                      = IWAV0164E Expression type sent in invalid order, received: {0}, expected {1}.
-Expression_ArrayTypeNotAnArray_EXC_                         = IWAV0165E ArrayType "{0}" is not an array.
-Expression_CannotHandleNoReceiveOnFieldAccess_EXC_          = IWAV0166E Access by field name ({0}) (not by proxy) requires a receiver.
-Expression_MethodsNeedReceiver_EXC_                         = IWAV0167E Access by method name ({0}) (not by proxy) requires a receiver.
-Expression_InvalidMarkNesting                               = IWAV0168E Improper nesting of mark statements in Expression. Tried to pop or endMark to before current mark. Tried to go past Mark# {0}.
-Expression_InvalidProxy=Expression Proxy is for a different expression
-ProxyPlugin_CleanupDefaultProxyLaunchConfigurations         = Clean up default proxy launch configurations.
-ProxyLaunchSupport_RegistryCouldNotStartForSomeReason_WARN_ = IWAV0168W Registry could not be started for some reason.
-Expression_CreateProxyReassignmentExpression_InvalidForReassignment_EXC_=Invalid expression type for reassignment: {0}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/AmbiguousMethodException.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/AmbiguousMethodException.java
deleted file mode 100644
index a832ca0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/AmbiguousMethodException.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: AmbiguousMethodException.java,v $
- *  $Revision: 1.3 $  $Date: 2005/06/16 17:46:14 $ 
- */
-package org.eclipse.jem.internal.proxy.common;
- 
-
-/**
- * Ambiguous Method Exception. I.E. There is more than one that could be used.
- */
-public class AmbiguousMethodException extends Exception {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -7084137612344373381L;
-	public AmbiguousMethodException() {
-	}
-	public AmbiguousMethodException(String msg) {
-		super(msg);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/CommandException.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/CommandException.java
deleted file mode 100644
index e2883ff..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/CommandException.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common;
-/*
- *  $RCSfile: CommandException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-/**
- * An error occurred during command processing.
- *
- */
-
-public class CommandException extends Exception {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -2519238571145682514L;
-	protected final Object fExceptionData;
-	
-	public CommandException() {
-		fExceptionData = null;
-	}
-	
-	public CommandException(Object data) {
-		fExceptionData = data;
-	}
-	
-	public CommandException(String msg, Object data) {
-		super(msg);
-		fExceptionData = data;
-	}	
-	
-	public Object getExceptionData() {
-		return fExceptionData;
-	}
-	
-	public boolean isRecoverable() {
-		return false;	// By default Command Exceptions are not recoverable.
-	}	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/GenericEventQueue.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/GenericEventQueue.java
deleted file mode 100644
index 7b8baa7..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/GenericEventQueue.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile$
- *  $Revision$  $Date$ 
- */
-package org.eclipse.jem.internal.proxy.common;
-
-import java.util.LinkedList;
-
-/**
- * A generic event queue. It runs on its own thread and will execute any queued up runnables.
- * <p>
- * When a runnable is added to the queue, the thread will be notified. If the thread is free it will
- * run the runnable. If it is not free, the runnable will be added to the queue. The thread will process
- * all intervening runnables and then execute the runnable in sequence with all of the rest.
- * <p>
- * This is used when you can't use the system widget (e.g. AWT event queue or SWT asyncExec) or when the
- * runnable must be executed on a non-ui thread.
- * <p>
- * <b>Note:</b> It is required that {@link #close()} be called so that resources are cleared up.
- * 
- * @since 1.1.0.1
- */
-public class GenericEventQueue {
-	
-	private LinkedList queue = new LinkedList();
-
-	private class EventThread extends Thread {
-		private boolean run = true;
-		
-		public EventThread(String title) {
-			super(title);
-		}
-		
-		public void close() {
-			synchronized (queue) {
-				run = false;
-				queue.clear();
-				queue.notifyAll();
-			}
-		}
-		
-		public void postEvent(Runnable run) {
-			if (!this.isAlive()) {
-				throw new IllegalStateException("Event queue thread is not executing.");
-			}
-			synchronized (queue) {
-				if (run != null)
-					queue.addLast(run);
-				queue.notifyAll();
-			}
-		}
-		
-		public void run() {
-			while (true) {
-				Runnable runnable;
-				synchronized (queue) {
-					while (run && queue.isEmpty()) {
-						try {
-							queue.wait();
-						} catch (InterruptedException e) {
-						}
-					}
-					if (!run)
-						return;	// Done.
-					else {
-						runnable = (Runnable) queue.removeFirst();
-					}
-				}
-
-				try {
-					runnable.run();
-				} catch (RuntimeException e) {
-					e.printStackTrace();
-				} finally {
-					runnable = null;	// Set this so that we don't hold onto resources in the runnable while waiting for next quy.
-				}
-			}
-		}
-	}
-	
-	private EventThread eventThread;
-	
-	/**
-	 * Construct with a title. (This title will be the title on the Thread for the queue).
-	 * The thread will have the same priority as the current thread. 
-	 * @param queueTitle
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public GenericEventQueue(String queueTitle) {
-		this(queueTitle, Thread.currentThread().getPriority());
-	}
-	
-	/**
-	 * Construct with a title. (This title will be the title on the Thread for the queue).
-	 * And a priority for the event queue's processing thread.
-	 * @param queueTitle
-	 * @param priority priority to use for event queue's thread.
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public GenericEventQueue(String queueTitle, int priority) {
-		eventThread = new EventThread(queueTitle);
-		eventThread.setPriority(priority);
-		synchronized(queue) {
-			eventThread.start();
-			try {
-				queue.wait(100);	// Wait for thread to start.
-			} catch (InterruptedException e) {
-			}	
-		}
-	}
-	
-	/**
-	 * Close the event queue. This will clear out any pending events. They will not
-	 * be executed. 
-	 * 
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public void close() {
-		eventThread.close();
-	}
-	
-	/**
-	 * Post the event.
-	 * @param runnable runnable to execute, or <code>null</code> to kick-start the thread if for some reason it may be waiting and it shouldn't be.
-	 * 
-	 * @throws IllegalStateException thrown if the event queue thread has already been closed, or ended for some severe error.
-	 * @since 1.1.0.1
-	 */
-	public void postEvent(Runnable runnable) {
-		eventThread.postEvent(runnable);
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallback.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallback.java
deleted file mode 100644
index 164d7e6..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallback.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common;
-/*
- *  $RCSfile: ICallback.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-/**
- * This interface is to be implemented by any callback.
- * The callback will use the IVMCallbackServer passed in to
- * get callback handlers, and the id passed in is
- * to be passed to these handlers.
- */
-public interface ICallback {
-	
-	/**
-	 * Initialize the callback
-	 */
-	public void initializeCallback(IVMCallbackServer vmServer, int callbackID);
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallbackHandler.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallbackHandler.java
deleted file mode 100644
index 9b67ff2..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallbackHandler.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common;
-/*
- *  $RCSfile: ICallbackHandler.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-/**
- * This is the interface for a callback handler.
- * Users will talk to this interface to perform 
- * callbacks.
- */
-public interface ICallbackHandler {
-
-	/**
-	 * Callback, but send the parm as an object, ie. it must
-	 * be nothing but constants, e.g. String, Integer, or an
-	 * array of constants. Constants should not be things like
-	 * regular objects. This is because only standard java.lang
-	 * type constants can be assured to be available on the other
-	 * client. Also you don't want to send big objects. It must
-	 * be constants that don't need to be sent back for any reason
-	 * since their identity will be lost in the transfer.
-	 * <p>
-	 * This should be used if there are no parms (i.e. it is null).
-	 * <p>
-	 * To send big objects, use the callback stream.
-	 * 
-	 * @param callbackID
-	 * @param msgID
-	 * @param parm
-	 * @return
-	 * @throws CommandException
-	 * 
-	 * @see IVMCallbackServer#requestStream(int, int)
-	 * @since 1.0.0
-	 */
-	public Object callbackAsConstants(int callbackID, int msgID, Object parm) throws CommandException;
-
-	/**
-	 * Callback to registered client.
-	 * <p>
-	 *  The parms can be <code>null</code> if no parms, or it is an array of parms.
-	 * The parms
-	 *    will be turned into proxies on the client vm. So the callback
-	 *    will recieve an array of proxies to the values in the parms.
-	 *    If any of the entries in the array is itself an array, a
-	 *    proxy to the array will be created and sent. The array itself
-	 *    will not be sent.
-	 * <p>
-	 *    If an array entry should go across as an array of proxies and
-	 *    not as one proxy to an array, then the entry needs to be an
-	 *    instance of {@link ICallbackHandler.TransmitableArray transmitableArray}. This will flag
-	 *    that it should transmit the entire entry as proxies. This should
-	 *    be used sparingly, only if there isn't much data in the array and
-	 *    all of the array would be used on the client. That way transmitting
-	 *    the entire array will be faster than accessing individual components.
-	 * <p>
-	 * If the array contains only one entry or the parm itself is null, then {@link org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, IBeanProxy)}
-	 * will be called. Else {@link org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, Object[])} will be called with all of the parms
-	 * turned into proxies as mentioned in the previous paragraph.
-	 *
-	 * @param callbackID The id of the callback. This will be given
-	 *    to the callback when it is created, and it must pass
-	 *    on to the handler. That way it is know which callback
-	 *    to call on the client.
-	 * @param msgID The id of the message for the callback. This is an
-	 *    agreed upon id of the developers of the callback on both
-	 *    sides.
-	 * @param parms Null if no parms, or an array of objects to send to the client vm. See the comments 
-	 * above for a complete description of the parameter.
-	 * 
-	 * @see ICallbackHandler.TransmitableArray
-	 */
-	public Object callbackWithParms(int callbackID, int msgID, Object[] parms) throws CommandException;
-
-	/**
-	 * Array wrapper that turns an array for parameters into a transmittable array.
-	 * 
-	 * @see ICallbackHandler#callbackWithParms(int, int, Object[])
-	 * @since 1.1.0
-	 */
-	public static class TransmitableArray {
-		protected final Object[] fArray;
-		public TransmitableArray(Object[] array) {
-			fArray = array;
-		}
-		public Object[] getArray() {
-			return fArray;
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallbackRunnable.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallbackRunnable.java
deleted file mode 100644
index 944c797..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICallbackRunnable.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ICallbackRunnable.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.common;
-
-/**
- * Users would implement this as a runnable to 
- * send a callback request.
- */
-public interface ICallbackRunnable {
-	
-	/**
-	 * The actual run code.
-	 */
-	public Object run(ICallbackHandler handler) throws CommandException;
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICommandException.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICommandException.java
deleted file mode 100644
index ebee32e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/ICommandException.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common;
-/*
- *  $RCSfile: ICommandException.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-public class ICommandException {
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/IVMCallbackServer.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/IVMCallbackServer.java
deleted file mode 100644
index e79349a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/IVMCallbackServer.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common;
-/*
- *  $RCSfile$
- *  $Revision$  $Date$ 
- */
-
-import java.io.OutputStream;
-/**
- * This is the interface for accessing the 
- * VM callback Server. It will be given to an
- * ICallback so that the callback can access
- * the server to request a callback.
- */
-public interface IVMCallbackServer {
-	
-	/**
-	 * Get the IVMServer for this callback server.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IVMServer getIVMServer();
-	
-	
-	/**
-	 * Process a callback. The runnable contains the
-	 * actual code.
-	 */
-	public Object doCallback(ICallbackRunnable runnable) throws CommandException;
-	
-	/**
-	 * Request a stream for writing a lot of data (suggested for larger
-	 * than several thousand bytes). The connection will be assigned
-	 * to this stream until the stream is closed.
-	 */
-	public OutputStream requestStream(int callbackID, int msgID) throws CommandException;
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/IVMServer.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/IVMServer.java
deleted file mode 100644
index 8dd8aa9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/IVMServer.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IVMServer.java,v $
- *  $Revision: 1.3 $  $Date: 2005/07/08 17:51:47 $ 
- */
-package org.eclipse.jem.internal.proxy.common;
- 
-/**
- * This is the base server for the vm on the vm side (i.e. not the client side).
- * <p>
- * It can be passed to proxies if they need to access the vm server.
- * @since 1.1.0
- */
-public interface IVMServer {
-
-	/**
-	 * Add a runnable that will be called if shutdown is requested. If already added,
-	 * it will not be added again.
-	 * <p>
-	 * The body of the runnable must not do any vm server calls. That is because
-	 * the server is shutdown at this point. The body must simply do clean up code.
-	 * The shutdown will not continue until the call to the runnable is returned.
-	 * <p>
-	 * Calls to this will be ignored if shutdown has already started.
-	 * @param runnable
-	 * 
-	 * @since 1.1.0
-	 */
-	public void addShutdownListener(Runnable runnable);
-
-	/**
-	 * Remove the shutdown runnable from the list. If not added, then not an error to call this.
-	 * <p>
-	 * Calls to this will be ignored if shutdown has already started.
-	 * @param runnable
-	 * 
-	 * @since 1.1.0
-	 */
-	public void removeShutdownListener(Runnable runnable);
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MapTypes.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MapTypes.java
deleted file mode 100644
index a9d1422..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MapTypes.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: MapTypes.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.common;
-
-import java.util.HashMap;
- 
-
-/**
- * This is used for mapping between JNI format and non-JNI format. It also has the
- * maps for primitives.
- * @since 1.0.0
- */
-public class MapTypes {
-
-	public final static HashMap MAP_SHORTSIG_TO_TYPE = new HashMap(8);
-	public final static HashMap MAP_TYPENAME_TO_SHORTSIG = new HashMap(8);
-	static {
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("B", Byte.TYPE); //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("C", Character.TYPE); //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("D", Double.TYPE);		 //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("F", Float.TYPE); //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("I", Integer.TYPE); //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("J", Long.TYPE); //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("S", Short.TYPE); //$NON-NLS-1$
-		MapTypes.MAP_SHORTSIG_TO_TYPE.put("Z", Boolean.TYPE); //$NON-NLS-1$
-		
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("byte","B"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("char","C"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("double","D"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("float","F"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("int","I"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("long","J"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("short","S"); //$NON-NLS-1$ //$NON-NLS-2$
-		MapTypes.MAP_TYPENAME_TO_SHORTSIG.put("boolean","Z"); //$NON-NLS-1$ //$NON-NLS-2$
-	}
-
-	
-
-	/**
-	 * Convert formal type name for an array (i.e. java.lang.Object[]
-	 * to the jni format (i.e. [Ljava.lang.Object;)
-	 * This is used when a name is passed in from the IDE side.
-	 * The VM side uses the jni format, and all of proxy uses the jni format.
-	 * 
-	 * @param classname
-	 * @return string jni form of name.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static String getJNIFormatName(String classname) {
-		if (classname.length() == 0 || !classname.endsWith("]")) //$NON-NLS-1$
-			return classname;	// Not an array,or invalid
-		
-		StringBuffer jni = new StringBuffer(classname.length());
-		int firstOpenBracket = classname.indexOf('[');
-		int ob = firstOpenBracket;
-		while (ob > -1) {
-			int cb = classname.indexOf(']', ob);
-			if (cb == -1)
-				break;
-			jni.append('[');
-			ob = classname.indexOf('[', cb);
-		}
-		
-		String finalType = classname.substring(0, firstOpenBracket).trim();
-		if (finalType != null) {
-			String shortSig = (String) MapTypes.MAP_TYPENAME_TO_SHORTSIG.get(finalType);
-			if (shortSig == null) {
-				jni.append('L');
-				jni.append(finalType);
-				jni.append(';');
-			} else {
-				jni.append(shortSig);
-			}
-		}
-		
-		return jni.toString();
-	}
-	
-	/**
-	 * This converts from the JNI format to the formal typename.
-	 * 
-	 * @param jniName
-	 * @return formal typename
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String getFormalTypeName(String jniName) {
-		if (jniName.charAt(0) == '[') {
-			// It is an array
-			int dims = jniName.lastIndexOf('[')+1;	// Number of dimensions
-			int startType = dims;
-			StringBuffer fName = new StringBuffer(jniName.length()+(2*dims)); 
-			if (jniName.charAt(startType) == 'L')
-				fName.append(jniName.substring(startType+1, jniName.length()-1));	// For "[Ljava.lang.String;" return "java.lang.String"
-			else if (jniName.length() == startType+1) {
-				// Possible primitive
-				Class type = (Class) MAP_SHORTSIG_TO_TYPE.get(jniName.substring(startType, startType+1));
-				if (type != null) {
-					fName.append(type.getName());
-				} else
-					return "";	// Invalid if no 'L' and not a primitive. //$NON-NLS-1$
-			} else
-				return "";	// Invalid, must be either a primitive or 'L' type. //$NON-NLS-1$
-			while(dims-- > 0) {
-				fName.append("[]"); //$NON-NLS-1$
-			}
-			return fName.toString();
-		} else if (jniName.length() == 1) {
-			// Possible primitive.
-			Class type = (Class) MAP_SHORTSIG_TO_TYPE.get(jniName);
-			if (type != null) {
-				return type.getName();
-			}
-		}
-		
-		// If got here then just a name as is.
-		return jniName;
-	}
-	
-	/**
-	 * Convert the formal type name, with the given number of dimensions,
-	 * to an array JNI type.
-	 * @param finalComponent final component name, should not be an array type.
-	 * @param dimensions number of dimensions for the array.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static String getJNITypeName(String finalComponent, int dimensions) {
-		StringBuffer jni = new StringBuffer(finalComponent.length()+dimensions+2);
-		while (dimensions-- > 0) {
-			jni.append('[');
-		}
-		
-		String shortSig = (String) MapTypes.MAP_TYPENAME_TO_SHORTSIG.get(finalComponent);
-		if (shortSig == null) {
-			jni.append('L');
-			jni.append(finalComponent);
-			jni.append(';');
-		} else {
-			jni.append(shortSig);
-		}
-		
-		return jni.toString();
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MethodHelper.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MethodHelper.java
deleted file mode 100644
index 90772c3..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MethodHelper.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * This is a class to do message/constructor work. 
- * Specifically to find the most appropriate method.
- */
-public class MethodHelper {
-	
-	/*
-	 * The class that is used to represent Null class type.
-	 * 
-	 * @since 1.0.0
-	 */
-	private static class NULL_CLASS {
-	}
-	
-	public static final Class NULL_TYPE = NULL_CLASS.class;
-	
-	static final ArrayList sPrimitivesOrder;
-	static final int sCharPos;
-	
-	static {
-		sPrimitivesOrder = new ArrayList(6);
-		sPrimitivesOrder.add(Byte.TYPE);
-		sPrimitivesOrder.add(Short.TYPE);
-		sPrimitivesOrder.add(Integer.TYPE);
-		sPrimitivesOrder.add(Long.TYPE);
-		sPrimitivesOrder.add(Float.TYPE);
-		sPrimitivesOrder.add(Double.TYPE);
-
-		// char can be treated like a short for purposes of ordering.
-		sCharPos = sPrimitivesOrder.indexOf(Short.TYPE);
-	}
-	
-	/**
-	 * Return whether the type2 can be assigned to type1 in
-	 * method argument conversion.
-	 */
-	public static boolean isAssignableFrom(Class type1, Class type2) {
-		if (type1 == type2)
-			return true;	// They're the same, so assignable.
-		if (type1.isPrimitive()) {
-			if (type2.isPrimitive()) {
-				if (type1 == Boolean.TYPE || type2 == Boolean.TYPE)
-					return false;	// Since not equal and one is boolean and the other isn't, not assignable
-				int type1Pos = (type1 != Character.TYPE) ? sPrimitivesOrder.indexOf(type1) : sCharPos;
-				int type2Pos = (type2 != Character.TYPE) ? sPrimitivesOrder.indexOf(type2) : sCharPos;
-				return type1Pos > type2Pos;	// It can be widened if type1 is higher in the order
-			}
-			return false;	// primitive to non-primitive, not assignable.
-		} else
-			if (type2 == NULL_TYPE)
-				return true;	// NULL_TYPE represents null for us, and null can be assigned to any object
-			else		
-				return type1.isAssignableFrom(type2);	// Can type2 be assigned to type1
-	}
-	
-	
-	/**
-	 * Every entry in Array2 can be assigned to the corresponding entry in Array1.
-	 */
-	public static boolean isAssignableFrom(Class[] types1, Class[] types2) {
-		if (types1.length != types2.length)
-			return false;	// Not the same size, so not compatible.
-		for (int i=0; i<types1.length; i++) {
-			if (!isAssignableFrom(types1[i], types2[i]))
-				return false;
-		}
-		return true;	// All are assignable
-	}
-	
-	/**
-	 * Return the index of the most compatible method/constructor from the lists passed in.
-	 * MethodsList: List of methods (if null then this is for constructors)
-	 * ParmsList: List of parms for each method (each entry will be Class[]).
-	 */
-	private static int findMostCompatible(List methods, List parms, String ambiguousName) throws AmbiguousMethodException {
-		// The algorithm used is from the Java Language Specification 15.12.2.2
-		// Find the maximally specific ones
-		// This is defined as the one that is more specific then all of the rest.
-		// If there are duplicates parms that are maximally specific, then it doesn't matter which choosen
-		// because when invoked the JVM will make sure the right thing is done.
-		// 
-		Class[][] parmsCopy = (Class[][]) parms.toArray(new Class[parms.size()][]);
-		int size = parmsCopy.length;
-		// For each entry see if it is maximally specific, i.e. it is more specific then all of the others.
-nextMethod:	for (int i=0; i<size; i++) {
-			// For ctors we don't need to test the declaring class because it will always be the same class.
-			Class dclClassi = methods != null ? ((Method) methods.get(i)).getDeclaringClass() : null;
-			Class[] parmsi = parmsCopy[i];
-			for (int j=0; j<size; j++) {
-				if (i == j)
-					continue;
-				// Methodi is more specific if
-				//   a) Methodi declaring class is assignable to Methodj declaring class
-				//   b) Methodi parms are assignable to Methodj parms
-				//
-				// First see if Methodi is more specific, if it is
-				// then throw out Methodj and continue
-				// If Methodi is not compatible to Methodj, go to the next method for i. Methodi is not the most specific
-				// Something else is either more specific or none are ma
-				if (dclClassi != null) {
-					// Step a
-					if (!isAssignableFrom(((Method) methods.get(j)).getDeclaringClass(), dclClassi))
-						continue nextMethod;	// Methodi is not more specific than Methodj, so try next i.
-				}
-				
-				// Step b
-				Class[] parmsj = parmsCopy[j];
-				if (!isAssignableFrom(parmsj, parmsi)) {
-					// Methodi is not more specific than Methodj, so go to next i.
-					continue nextMethod;
-				}
-			}
-			return i;	// Methodi is more specific than all of the other ones.
-		}
-
-		throw new AmbiguousMethodException(ambiguousName);	// There was not one more specific than all of the others.
-	}
-	
-	/**
-	 * Find the most compatible method for the given arguments.
-	 */
-	public static Method findCompatibleMethod(Class receiver, String methodName, Class[] arguments) throws NoSuchMethodException, AmbiguousMethodException {
-		try {
-			Method mthd = receiver.getMethod(methodName, arguments);
-			return mthd;	// Found exact match
-		} catch (NoSuchMethodException exc) {
-			if (arguments != null) {
-				// Need to find most compatible one.
-				Method mthds[] = receiver.getMethods();
-				ArrayList parmsList = new ArrayList(mthds.length); // The parm list from each compatible method.
-				ArrayList mthdsList = new ArrayList(mthds.length); // The list of compatible methods, same order as the parms above.
-				for (int i = 0; i < mthds.length; i++) {
-					Method mthd = mthds[i];
-					if (!mthd.getName().equals(methodName))
-						continue; // Not compatible, not same name
-					Class[] parms = mthd.getParameterTypes();
-					if (!isAssignableFrom(parms, arguments))
-						continue; // Not compatible, parms
-					// It is compatible with the requested method
-					parmsList.add(parms);
-					mthdsList.add(mthd);
-				}
-
-				// Now have list of compatible methods.
-				if (parmsList.size() == 0)
-					throw throwFixedNoSuchMethod(exc, receiver, methodName, arguments); // None found, so rethrow the exception
-				if (parmsList.size() == 1)
-					return (Method) mthdsList.get(0); // Only one, so return it
-
-				// Now find the most compatible method
-				int mostCompatible = findMostCompatible(mthdsList, parmsList, methodName);
-				return (Method) mthdsList.get(mostCompatible);
-			} else
-				throw throwFixedNoSuchMethod(exc, receiver, methodName, arguments); // None found, so rethrow the exception
-		}
-	}
-	
-	/*
-	 * NoSuchMEthodExeception doesn't include the signature. Since these are dynamic searches, the exception itself is useless without
-	 * the signature. So we add it.
-	 */
-	private static NoSuchMethodException throwFixedNoSuchMethod(NoSuchMethodException e, Class declareClass, String methodName, Class[] argClasses) {
-
-		// The default trace doesn't show what method was being searched for, so recreate with that.
-		StringBuffer s = new StringBuffer();
-		s.append(declareClass.getName());
-		s.append('.');
-		s.append(methodName);
-		s.append('(');
-		if (argClasses != null) {
-			for (int i = 0; i < argClasses.length; i++) {
-				if (i > 0)
-					s.append(',');
-				s.append(argClasses[i].getName());
-			}
-		}
-		s.append(')');
-		NoSuchMethodException ne = new NoSuchMethodException(s.toString());
-		ne.setStackTrace(e.getStackTrace());
-		return ne;
-	}
-	
-	/**
-	 * Find the most compatible constructor for the given arguments.
-	 */
-	public static Constructor findCompatibleConstructor(Class receiver, Class[] arguments) throws NoSuchMethodException, AmbiguousMethodException {
-		try {
-			java.lang.reflect.Constructor ctor = receiver.getDeclaredConstructor(arguments);
-			ctor.setAccessible(true);	// We allow all access, let ide and compiler handle security.
-			return ctor;	// Found exact match
-		} catch (NoSuchMethodException exc) {
-			if (arguments != null) {
-				// Need to find most compatible one.
-				java.lang.reflect.Constructor ctors[] = receiver.getDeclaredConstructors();
-				ArrayList parmsList = new ArrayList(ctors.length); // The parm list from each compatible method.
-				ArrayList ctorsList = new ArrayList(ctors.length); // The list of compatible methods, same order as the parms above.
-				for (int i = 0; i < ctors.length; i++) {
-					java.lang.reflect.Constructor ctor = ctors[i];
-					Class[] parms = ctor.getParameterTypes();
-					if (!isAssignableFrom(parms, arguments))
-						continue; // Not compatible, parms
-					// It is compatible with the requested method
-					parmsList.add(parms);
-					ctorsList.add(ctor);
-				}
-
-				// Now have list of compatible methods.
-				if (parmsList.size() == 0)
-					throw exc; // None found, so rethrow the exception
-				if (parmsList.size() == 1) {
-					java.lang.reflect.Constructor ctor = (java.lang.reflect.Constructor) ctorsList.get(0); // Only one, so return it
-					ctor.setAccessible(true); // We allow all access, let ide and compilor handle security.
-					return ctor;
-				}
-
-				// Now find the most compatible ctor
-				int mostCompatible = findMostCompatible(null, parmsList, receiver.getName());
-				java.lang.reflect.Constructor ctor = (java.lang.reflect.Constructor) ctorsList.get(mostCompatible);
-				ctor.setAccessible(true); // We allow all access, let ide and compilor handle security.
-				return ctor;
-			} else
-				throw exc; // None found, so rethrow the exception
-		}
-	}	
-				
-		
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/UnresolvedCompilationError.java b/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/UnresolvedCompilationError.java
deleted file mode 100644
index 687dd6f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/UnresolvedCompilationError.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile$
- *  $Revision$  $Date$ 
- */
-package org.eclipse.jem.internal.proxy.common;
- 
-/**
- * Used by the the registries to indicate "UnresolvedCompilationError". This is because the
- * normal java throws just an Error with a message. To make it easier in processing, it will
- * be turned into this error instead so that it can be explicitly caught.
- * <p>
- * This will only be used in certain explicit parts of the code. It will be detailed where
- * it can be thrown.
- * 
- * @since 1.1.0.1
- */
-public class UnresolvedCompilationError extends Error {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0.1
-	 */
-	private static final long serialVersionUID = 7778842211073592790L;
-	
-	/**
-	 * Construct from an Error.
-	 * @param error The error that is the actual one. <b>This will not be the cause, the message and stacktrace will be copied into this new error.</b>
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public UnresolvedCompilationError(Error error) {
-		super(error.getMessage());
-		setStackTrace(error.getStackTrace());
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/BeanProxyValueSender.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/BeanProxyValueSender.java
deleted file mode 100644
index 2631d13..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/BeanProxyValueSender.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeanProxyValueSender.java,v $
- *  $Revision: 1.3 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-import org.eclipse.jem.internal.proxy.core.ThrowableProxy;
- 
-/**
- * Useful in REM to get the array of BeanProxyValues.
- * 
- * @since 1.1.0
- */
-public class BeanProxyValueSender implements Commands.ValueSender {
-	protected int index = 0;
-	protected Object[] array;
-	private Exception exception;
-	private final REMStandardBeanProxyFactory factory;
-	
-	/**
-	 * See if there was an exception thrown during reading.
-	 * 
-	 * @return an exception or <code>null</code> if no exception.
-	 * 
-	 * @since 1.1.0
-	 */
-	public Exception getException() {
-		return exception;
-	}
-		
-	public BeanProxyValueSender(REMStandardBeanProxyFactory factory) {
-		this.factory = factory;
-	}
-	public BeanProxyValueSender(REMStandardBeanProxyFactory factory, Commands.ValueObject arrayHeader) {
-		this(factory);
-		initialize(arrayHeader);
-	}
-	
-	public void initialize(Commands.ValueObject arrayHeader) {
-		index = 0;
-		// The array type doesn't matter, it will be an array of objects.
-		// The values will either be IBeanProxies or an array, or constants.
-		array = new Object[arrayHeader.anInt];
-	}
-	
-	public void clear() {
-		array = null;
-		index = 0;
-	}
-	
-	public Object[] getArray() {
-		return array;
-	}
-				
-	// A new value is being sent to the array
-	// NOTE: It is important that this has been called within a transaction.
-	public void sendValue(Commands.ValueObject value) {
-		try {
-			array[index++] = factory.getBeanProxy(value);	// Add it to the array
-		} catch (ThrowableProxy e) {
-			// We can't stop it right away because we can't send exception on, however,
-			// we can log it and save the exception.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			exception = e;			
-		} catch (CommandException e) {
-			// We can't stop it right away because we can't send exception on, however,
-			// we can log it and save the exception.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			exception = e;
-		}
-	}
-				
-	// The next entry is an array too!
-	public Commands.ValueSender nestedArray(Commands.ValueObject arrayHeader) {
-		BeanProxyValueSender sender = new BeanProxyValueSender(factory, arrayHeader);
-		// Take the newly created array and put it into the current array.
-		array[index++] = sender.getArray();
-		return sender;
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/DebugModeHelper.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/DebugModeHelper.java
deleted file mode 100644
index efa923b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/DebugModeHelper.java
+++ /dev/null
@@ -1,365 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: DebugModeHelper.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-
-import java.lang.reflect.*;
-
-import org.eclipse.core.runtime.Platform;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-/**
- * This is a helper for debug mode. It allows access to
- * the workbench, if available, or AWT, if available, for
- * the debug prompts. It uses reflection so that nothing is
- * forced to be loaded or pre-reqd. That way it can run headless.
- */
-
-class DebugModeHelper {
-	boolean awt = false;
-	boolean console = false;
-	boolean setup = false;
-	java.io.InputStreamReader inReader = null;
-	
-	// Workbench reflections
-	Object display = null;	
-	Constructor cMB = null;
-	Field fAppModel = null;
-	Method fasync = null;
-	Method fsync = null;	
-	Method fSetText = null;
-	Method fSetMessage = null;
-	Method fOpen = null;
-	Method fGetWorkbench = null;
-	Class cSWT = null;
-		
-	
-	// AWT Reflections
-	Class cMessageDialog = null;
-	Method fDoit = null;
-	
-	protected void setupType() {
-		if (setup)
-			return;
-			
-		setup = true;
-		
-		// See if use system console instead. If false or not set, then try to query usage.	 		
-	 	console = "true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName()+ProxyRemoteUtil.IO_CONSOLE)); //$NON-NLS-1$
-	 	if (console)
-	 		return;
-		
-		try {		 		
-		 	// See if PlatformUI plugin available.
-		 	Bundle uiBundle = Platform.getBundle("org.eclipse.ui"); //$NON-NLS-1$
-		 	if (uiBundle == null) {
-		 		setupAWT();	// UI not available, try through AWT.
-		 		return;
-		 	}
-	
-	 		// Setup Eclipse
-		 	Class cPlatformUI = uiBundle.loadClass("org.eclipse.ui.PlatformUI"); //$NON-NLS-1$
-		 	Method isWBRunning = cPlatformUI.getMethod("isWorkbenchRunning", null); //$NON-NLS-1$
-		 	if (!((Boolean) isWBRunning.invoke(null, null)).booleanValue()) {
-		 		setupAWT();	// UI not available, try through AWT.
-		 		return;
-		 	}
-		 	
-		 	fGetWorkbench = cPlatformUI.getMethod("getWorkbench", null); //$NON-NLS-1$
-		 	Object w = fGetWorkbench.invoke(null, null);
-
-			if (w != null) {
-	 			Class cDisplay = uiBundle.loadClass("org.eclipse.swt.widgets.Display"); //$NON-NLS-1$
-	 			Method fGetCurrent = cDisplay.getMethod("getCurrent", null); //$NON-NLS-1$
-	 			Method fGetDefault = cDisplay.getMethod("getDefault", null);	 			 //$NON-NLS-1$
-	 			fasync = cDisplay.getMethod("asyncExec", new Class[] {Runnable.class}); //$NON-NLS-1$
-	 			fsync = cDisplay.getMethod("syncExec", new Class[] {Runnable.class}); //$NON-NLS-1$
-	 			
-	 			// Get the display
-	 			display = fGetCurrent.invoke(null, null);
-	 			if (display == null)
-	 				display = fGetDefault.invoke(null, null);
-			}
-			
-			if (display != null) { 	
-	 			Class cShell = uiBundle.loadClass("org.eclipse.swt.widgets.Shell"); //$NON-NLS-1$
-	 			Class cMessageBox = uiBundle.loadClass("org.eclipse.swt.widgets.MessageBox"); //$NON-NLS-1$
-	 			cMB = cMessageBox.getConstructor(new Class[] {cShell, Integer.TYPE});
-
-				fSetText = cMessageBox.getMethod("setText", new Class[] {String.class}); //$NON-NLS-1$
-				fSetMessage = cMessageBox.getMethod("setMessage", new Class[] {String.class});				 //$NON-NLS-1$
-				fOpen = cMessageBox.getMethod("open", null);		 		 //$NON-NLS-1$				
-		 			
-	 			cSWT = uiBundle.loadClass("org.eclipse.swt.SWT"); //$NON-NLS-1$
-	 			fAppModel = cSWT.getField("APPLICATION_MODAL"); //$NON-NLS-1$
-		 	} else {
-		 		setupAWT();	// UI not available, try through AWT.
-		 	}
-		} catch (NoSuchMethodException e) {
-		} catch (ClassNotFoundException e) {
-		} catch (IllegalAccessException e) {
-		} catch (InvocationTargetException e) {
-		} catch (NoSuchFieldException e) {
-		}
-		
-		return;		 			 		
-		 			
-	}	
-
-	protected void setupAWT() {
-	 		
-	 	// See if AWT is available.
-	 	try {
-		 	cMessageDialog = Class.forName("org.eclipse.jem.internal.proxy.remote.MessageDialog"); //$NON-NLS-1$
-		 	fDoit = cMessageDialog.getMethod("doit", new Class[] {String.class, String.class, String.class, String.class}); //$NON-NLS-1$
-		 	awt = true;
-		 	return;
-	 	} catch (ClassNotFoundException e) {
-	 	} catch (NoSuchMethodException e) {
-	 	}
- 		console = true;	// No AWT either, i.e. true headless environment
-	} 	
-	
-	public boolean debugMode(final String name) {
-	 	boolean debugMode = "true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName()+ProxyRemoteUtil.DEBUG_VM)); //$NON-NLS-1$
-	 	if (!debugMode)
-	 		return debugMode;
-	 		
-	 	setupType();
-
-		// See if use system console instead. If false or not set, then try to query usage.	 		
-	 	if (console)
-	 		return debugModeConsole(name);
-	 		
-	 	if (awt)
-	 		return debugModeAWT(name);
-		
-		try {		 		
- 			final Field fYes = cSWT.getField("YES"); //$NON-NLS-1$
- 			Field fNo = cSWT.getField("NO"); //$NON-NLS-1$
- 			Field fIcon = cSWT.getField("ICON_QUESTION"); //$NON-NLS-1$
-	 			
- 			final int style = fYes.getInt(null) | fNo.getInt(null) | fIcon.getInt(null) | fAppModel.getInt(null);	 			
- 			final boolean[] db = new boolean[1];
-
-			fsync.invoke(display, new Object[] { new Runnable() {
-				/**
-				 * @see java.lang.Runnable#run()
-				 */
-				public void run() {
-					try {
-						Object shell = getActiveShell();
-						Object mb = cMB.newInstance(new Object[] {shell, new Integer(style)});					
-						fSetText.invoke(mb, new Object[] {"Debug RemoteVM?"}); //$NON-NLS-1$
-						fSetMessage.invoke(mb, new Object[] {"Do you want to start the remote vm ("+name+") in debug mode?"});	// Not NLS'd because this is for internal developers only //$NON-NLS-1$ //$NON-NLS-2$
-							
-						db[0] = fYes.get(null).equals(fOpen.invoke(mb, null));
-					} catch (InstantiationException e) {
-					} catch (IllegalAccessException e) {
-					} catch (InvocationTargetException e) {
-					}
-				}
-			}});
-		 	return db[0];
-		} catch (IllegalAccessException e) {
-		} catch (InvocationTargetException e) {
-		} catch (NoSuchFieldException e) {
-		}
-		
-		return debugModeAWT(name);
- 	}
- 	
-
-	/*
-	 * This must be called from within the display thread.
-	 */
-	protected Object getActiveShell() {
-	 	Object shell = null;		
-		try {
-			Object w = fGetWorkbench.invoke(null, null);
-			Object ww = null;
-			if (w != null) {
-			 	Class cWorkbench = w.getClass();
-			 	Method getWorkbenchWindow = cWorkbench.getMethod("getActiveWorkbenchWindow", null); //$NON-NLS-1$
-				ww = getWorkbenchWindow.invoke(w, null);
-			}
-			if (ww != null) {
-				Class cWorkbenchWindow = ww.getClass();
-				Method getShell = cWorkbenchWindow.getMethod("getShell", null); //$NON-NLS-1$
-				shell = getShell.invoke(ww, null);
-			}
-		} catch (IllegalAccessException e) {
-		} catch (InvocationTargetException e) {
-		} catch (NoSuchMethodException e) {
-		}
-	 	
-	 	return shell;
-	}	
-		 	
-	protected boolean debugModeAWT(String name) {
-	 		
-	 	// See if AWT is available.
-	 	try {
-		 	Integer r = (Integer) fDoit.invoke(null, new Object[] {"Debug RemoteVM?", "Do you want to start the remote vm ("+name+") in debug mode?", "Yes", "No"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-		 	return r.intValue() == 1;	// i.e. button1 or "yes" was hit.
-	 	} catch (IllegalAccessException e) {
-	 	} catch (InvocationTargetException e) {
-	 	}
-	 	
- 		return false;	// No AWT either, i.e. headless environment, shouldn't of gotton here.
-	} 	
-	
-	protected boolean debugModeConsole(String name) {
-	 		
-	 	// Debug through the console
- 		inReader = new java.io.InputStreamReader(System.in);
- 		System.out.println("Do you want to start the remote vm ("+name+") in debug mode? (Enter Y or N):"); //$NON-NLS-1$ //$NON-NLS-2$
- 		char r = ' ';
- 		try {
- 			r = Character.toLowerCase((char) inReader.read());
- 			// Need to flush the input reader now.
- 			while (inReader.ready())
- 				inReader.read();
-		 	return r == 'y';	// i.e. "y" was entered.	 			
- 		} catch (java.io.IOException e) {
- 		}
-	 	
- 		return false;	// Error reading, so no debugging.
-	} 
- 	
- 	/**
- 	 * Return true if continue debugging.
- 	 */
-	public boolean promptPort(final int dport) {
- 		if (awt)
- 			return promptPortAWT(dport);
- 		else if (console)
- 			return promptPortConsole(dport);
- 			
- 		try {	
-			final Field fOK = cSWT.getField("OK"); //$NON-NLS-1$
-			Field fCancel = cSWT.getField("CANCEL"); //$NON-NLS-1$
-			Field fIcon = cSWT.getField("ICON_WORKING"); //$NON-NLS-1$
-	 			
-			final int style = fOK.getInt(null) | fCancel.getInt(null) | fIcon.getInt(null) | fAppModel.getInt(null);
-
-			final boolean[] ok = new boolean[1];
-			fsync.invoke(display, new Object[] { new Runnable() {	
-				/**
-				 * @see java.lang.Runnable#run()
-				 */
-				public void run() {
-					try {
-						Object shell = getActiveShell();
-						Object mb = cMB.newInstance(new Object[] {shell, new Integer(style)});					
-						fSetText.invoke(mb, new Object[] {"Connect Debugger to RemoteVM!"}); //$NON-NLS-1$
-						fSetMessage.invoke(mb, new Object[] {"You must now attach the debugger to port number "+dport+". Press OK when the debugger is attached. The program will not continue properly without the debugger being attached. Press Cancel if you could not connect the debugger. This will still cause an error, but it will clean up better."});	// Not NLS'd because this is for internal developers only //$NON-NLS-1$ //$NON-NLS-2$
-						ok[0] = fOK.get(null).equals(fOpen.invoke(mb, null));
-					} catch (InstantiationException e) {
-					} catch (IllegalAccessException e) {
-					} catch (InvocationTargetException e) {
-					}
-				}
-			}});			
-			return ok[0];
- 		} catch (NoSuchFieldException e) {
- 		} catch (InvocationTargetException e) {
- 		} catch (IllegalAccessException e) {
- 		}
- 		return false;
-	}	 	
- 	
-	protected boolean promptPortAWT(int dport) {
-		try {
-		 	Integer r = (Integer) fDoit.invoke(null, new Object[] {"Connect Debugger to RemoteVM!", "You must now attach the debugger to port number "+dport+". Press OK when the debugger is attached. The program will not continue properly without the debugger being attached. Press Cancel if you could not connect the debugger. This will still cause an error, but it will clean up better.", "OK", "Cancel"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-		 	return r.intValue() == 1;	// i.e. button1 or "OK" was hit.
-		} catch (InvocationTargetException e) {
-		} catch (IllegalAccessException e) {
-		}
- 		
-		return false;
-	}
-		 	
- 	protected boolean promptPortConsole(int dport) {
-		System.out.println("You must now attach the debugger to port number "+dport+". Enter 'y' when the debugger is attached. The program will not continue properly without the debugger being attached. Press 'n' if you could not connect the debugger. This will still cause an error, but it will clean up better. Enter 'y' or 'n':"); //$NON-NLS-1$ //$NON-NLS-2$
-		char r = ' ';
-		try {
-			r = Character.toLowerCase((char) inReader.read());
- 			while (inReader.ready())
- 				inReader.read();
-			return r == 'y';	// i.e. "y" was entered, go on
-		} catch (java.io.IOException e) {
-		}
- 		
-		return false;
-	}
-	
-	/**
-	 * Display an error msg. There will only be an OK button.
-	 * This will always display, debug mode won't be looked at.
-	 * This is for errors. This will be displayed async, so this
-	 * may return before the msg has been displayed and answered,
-	 * but since the only response is OK, it doesn't really matter.
-	 */
-	public void displayErrorMessage(final String title, final String msg) {
-		setupType();
-		if (console)
-			displayErrorMessageConsole(title, msg);
-		else if (awt)
-			displayErrorMessageAWT(title, msg);
-		else {
-			try { // This needs to be done in display thread.
-				Field fOK = cSWT.getField("OK"); //$NON-NLS-1$
-				Field fIcon = cSWT.getField("ICON_ERROR"); //$NON-NLS-1$
-
-				final int style = fOK.getInt(null) | fIcon.getInt(null) | fAppModel.getInt(null);
-				fasync.invoke(display, new Object[] { new Runnable() {
-						/**
-						 * @see java.lang.Runnable#run()
-						 */
-						public void run() { try { Object shell = getActiveShell();
-								Object mb = cMB.newInstance(new Object[] { shell, new Integer(style)});
-
-								fSetText.invoke(mb, new Object[] { title });
-								fSetMessage.invoke(mb, new Object[] { msg });
-								fOpen.invoke(mb, null);
-							} catch (InstantiationException e) {
-							} catch (IllegalAccessException e) {
-							} catch (InvocationTargetException e) {
-							}
-						}
-					}
-				});
-			} catch (NoSuchFieldException e) {
-			} catch (InvocationTargetException e) {
-			} catch (IllegalAccessException e) {
-			}
-		}
-	}	
-	
- 	protected void displayErrorMessageConsole(String title, String msg) {
-		System.out.println("Error: " + title); //$NON-NLS-1$
-		System.out.println("       " + msg); //$NON-NLS-1$
-	}
-	
-	protected void displayErrorMessageAWT(String title, String msg) {
-		try {
-		 	fDoit.invoke(null, new Object[] {title, msg, ProxyRemoteMessages.OK_7, null}); 
-		} catch (InvocationTargetException e) {
-		} catch (IllegalAccessException e) {
-		}
-	}		
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanProxy.java
deleted file mode 100644
index 15ea493..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanProxy.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.IBeanProxy;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * A Remote VM proxy. All IBeanProxy implementations
- * for the Remote VM must also implement this interface.
- * This is necessary for proper functioning.
- *
- * NOTE: This is an internal interface to the Remote VM Proxy.
- * It MUST not be used outside of the proxy factory family.
- */
-
-public interface IREMBeanProxy extends IBeanProxy {
-	/**
-	 * Return the ID of this proxy
-	 */
-	public Integer getID();
-	
-	/**
-	 * Proxy is about to be released, MUST mark it invalid.
-	 * This is required. Resources can also be cleaned up
-	 * if they are being held and need to be cleaned up.
-	 *
-	 * NOTE: This method will only be called when the proxy
-	 * is explicitly released. If it is simply garbage collected,
-	 * then this method will not be called. Simple garbage collection
-	 * means that no one is referencing this proxy. The proxy factory
-	 * will know what id this proxy was referencing and will release it
-	 * on the server at GC time.
-	 *
-	 * If there are resources
-	 * that absolutely must be released, then the finalize method
-	 * should be implemented to do the clean up. However, try not
-	 * to have this be the case. Finalize methods add overhead that is
-	 * usually better not to have. The better way is for any users
-	 * that get this kind of proxy object know to call release on
-	 * ProxyFactoryRegistry to release it before garbage collection.	 
-	 */
-	public void release();
-	
-	/**
-	 * Render this bean for transport to the server into a Commands.ValueObject.
-	 * For example, a string may put a string. An id type may put out the id.
-	 */
-	public void renderBean(Commands.ValueObject renderInto);
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanTypeProxy.java
deleted file mode 100644
index 6c0fc4f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanTypeProxy.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * All bean type proxies in remote vm must implement this interface.
- *
- * NOTE: This is an internal interface to the Remote VM Proxy.
- * It MUST not be used outside of the proxy factory family. 
- */
-public interface IREMBeanTypeProxy extends IBeanTypeProxy, IREMBeanProxy {
-	
-/**
- * Create a new bean proxy with the specified id.
- */
-public IREMBeanProxy newBeanProxy(Integer anID);
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract);
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanTypeProxyFactory.java
deleted file mode 100644
index a28377f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMBeanTypeProxyFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Interface for Remote VM Bean Type Proxy Factories.
- * All extension factories for Remote VM must implement this interface.
- */
-
-public interface IREMBeanTypeProxyFactory extends IBeanTypeProxyFactory {
-/**
- * Return a bean type proxy for the class name.
- * Return null if the extension factory doesn't handle this class.
- * Don't register any proxies returned, they will automatically be registered.
- * This should only return bean type proxies where the factory can determine
- * everything it needs, such as supertype and classID.
- * NOTE: This is implemented for the usage of the
- *       standard BeanType proxy factory. It should
- *       NOT be called by anyone else. They should
- *       go through the IStandardBeanTypeFactory
- *       instead. The standard bean type factory
- *       will call this method on the appropriate
- *       extension when it needs to.
- *
- * Creation date: (12/3/99 2:26:12 PM)
- */
-public IREMBeanTypeProxy getExtensionBeanTypeProxy(String typeName);	
-
-/**
- * Return a bean type proxy for the class name.
- * Return null if the extension factory doesn't handle this class.
- * Don't register any proxies returned, they will automatically be registered.
- * This should only return bean type proxies where the factory can determine
- * everything it needs, such as supertype and classID.
- * NOTE: This is implemented for the usage of the
- *       standard BeanType proxy factory. It should
- *       NOT be called by anyone else. They should
- *       go through the IStandardBeanTypeFactory
- *       instead. The standard bean type factory
- *       will call this method on the appropriate
- *       extension when it needs to.
- 
- * @param typeName
- * @param expression
- * @return
- * 
- * @since 1.1.0
- */
-public IProxyBeanType getExtensionBeanTypeProxy(String typeName, IExpression expression);
-
-/**
- * Return a bean type proxy for the class id and class name.
- * Return null if the extension factory doesn't handle this class. 
- * Don't register any proxies returned, they will automatically be registered. 
- * This will be called in the case that a new class id was returned
- * from the server that we don't have registered yet. Implementers will
- * created a proxy out of the name and the id and return it.
- * The supertype will be passed in so that the extension factory doesn't need to
- * try to find it.
- * NOTE: This is implemented for the usage of the
- *       standard BeanType proxy factory. It should
- *       NOT be called by anyone else. They should
- *       go through the IStandardBeanTypeFactory
- *       instead. The standard bean type factory
- *       will call this method on the appropriate
- *       extension when it needs to.
- *
- * Creation date: (12/3/99 2:26:12 PM)
- */
-public IREMBeanTypeProxy getExtensionBeanTypeProxy(String typeName, Integer classID, IBeanTypeProxy superType);	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConnection.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConnection.java
deleted file mode 100644
index a0b6536..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConnection.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMConnection.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Interface for the Remote VM Connection object.
- */
-
-public interface IREMConnection {
-	
-	/**
-	 * Did this construct correctly.
-	 * This is needed because an exception could be thrown in the ctor and
-	 * that's not a good thing to do.
-	 */
-	public boolean isConnected();
-	
-	/**
-	 * Terminate the server.
-	 * WARNING: This is only here so that factory can to it. Termination should ONLY
-	 * be done by the Factory not any one else. 
-	 */
-	public void terminateServer();
-			
-	/**
-	 * Close the connection.
-	 */
-	public void close();
-	
-	/**
-	 * Get the class information. Null return if not found.
-	 */
-	public Commands.GetClassReturn getClass(String className) throws CommandException;
-
-	/**
-	 * Get the class information from the id. 
-	 */
-	 public Commands.GetClassIDReturn getClassFromID(int classID) throws CommandException;
-
-	
-
-	/**
-	 * Get object data from an id.
-	 */	
-	public void getObjectData(int objectID, Commands.ValueObject valueReturn) throws CommandException;
-		
-	/**
-	 * Get a new instance using the initialization string.
-	 */
-	public void getNewInstance(int classID, String initString, Commands.ValueObject newInstance) throws CommandException;
-		
-	/**
-	 * Invoke the get array contents command.
-	 * @param arrayID
-	 * @param returnValue
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void getArrayContents(int arrayID, Commands.ValueObject returnValue) throws CommandException;
-	
-	/**
-	 * Invoke the method call.
-	 * The parms valueObject must represent an Object[] (either through ARRAY_IDS or OBJECT)
-	 */	
-	public void invokeMethod(int methodID, Commands.ValueObject invokeOn, Commands.ValueObject parms, Commands.ValueObject returnValue) throws CommandException;
-
-	/**
-	 * Invoke the method call with method passed.
-	 * The parms valueObject must represent an Object[] (either through ARRAY_IDS or OBJECT)
-	 */	
-	public void invokeMethod(Commands.ValueObject classType, String methodName, Commands.ValueObject parmTypes, Commands.ValueObject invokeOn, Commands.ValueObject parms, Commands.ValueObject returnValue) throws CommandException;
-
-	/**
-	 * Release the id. It is no longer needed on the client.
-	 */
-	public void releaseID(int id);
-	
-	/**
-	 * Read array values as BeanProxies into valueSender.
-	 * @param returnValue
-	 * @param valueSender
-	 * @param allowFlag <code>true</code> to allow FLAG values, <code>false</code> if not allow flag values.
-	 * 
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void readProxyArrayValues(Commands.ValueObject returnValue, Commands.ValueSender valueSender, boolean allowFlag) throws CommandException;
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConstantBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConstantBeanProxy.java
deleted file mode 100644
index f8daae0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConstantBeanProxy.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMConstantBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-/**
- * Tag interface to indicate this proxy is a constant proxy, i.e. there
- * is no bean on the server representing this (e.g. Strings and Integers).
- */
-
-public interface IREMConstantBeanProxy extends IREMBeanProxy {
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConstantBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConstantBeanTypeProxy.java
deleted file mode 100644
index e1a7352..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMConstantBeanTypeProxy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMConstantBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * This interface is used for any BeanType that represents a constant type bean.
- * These are types that are immutable and a copy of the actual value is kept here
- * in the client and not stored as an object id.
- */
-
-public interface IREMConstantBeanTypeProxy extends IBeanTypeProxy {
-	
-	/**
-	 * Create a new bean proxy the ValueObject passed in.
-	 */
-	public IBeanProxy newBeanProxy(Commands.ValueObject value);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMExpressionConnection.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMExpressionConnection.java
deleted file mode 100644
index 2de047e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMExpressionConnection.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IREMExpressionConnection.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:06 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import java.io.IOException;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
- 
-/**
- * Additional function on a connection for expression tree processing.
- * Connections returned (IREMConnections) will always also implement IREMExpressionConnection,
- * but they are separated so that expression functions don't pollute the regular
- * connection interface with added commands that shouldn't be called except
- * when processing an expression. If they were called out of order, big problems
- * can occur.
- * <p>
- * To use, simply cast the IREMConnection to be an IREMExpressionConnection.
- * 
- * @since 1.0.0
- */
-public interface IREMExpressionConnection extends IREMConnection {
-	
-	/**
-	 * Start expression processing.
-	 * @param expressionID 
-	 * @param trace TODO
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void startExpressionProcessing(int expressionID, byte trace) throws IOException;
-	
-	/**
-	 * Transfer the expression. This tells the remote vm to stop processing on the
-	 * given connection and return the expression processing controller for the expression.
-	 * 
-	 * @param expressionID
-	 * @param expController
-	 * @throws IOException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void transferExpression(int expressionID, Commands.ValueObject expController) throws CommandException;
-	
-	/**
-	 * Resume the expression on this connection.
-	 * @param expressionID
-	 * @param expController expression processor controller to use for the expression on this new connection.
-	 * @throws CommandException 
-	 * 
-	 * @since 1.1.0
-	 */
-	public void resumeExpression(int expressionID, Commands.ValueObject expController) throws CommandException;
-	
-	/**
-	 * Push an expression command. This is the common portion of the
-	 * subcommand. The actual data of the command will be separately done.
-	 * @param expressionID 
-	 * @param subcommand The subcommand being sent. From IInternalExpressionConstants.
-	 * 
-	 * @throws IOException
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.initParser.tree.IInternalExpressionConstants#PUSH_TO_PROXY_EXPRESSION
-	 * @since 1.0.0
-	 */
-	public void pushExpressionCommand(int expressionID, byte subcommand) throws IOException;
-	
-	/**
-	 * Push the value object to the remote side.
-	 * 
-	 * @param valueObject
-	 * @throws CommandException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void pushValueObject(Commands.ValueObject valueObject) throws CommandException;
-
-	/**
-	 * Push just the single byte to the remote side.
-	 * @param abyte
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void pushByte(byte abyte) throws IOException;
-	
-	/**
-	 * Push just the single int to the remote side.
-	 * 
-	 * @param anInt
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void pushInt(int anInt) throws IOException;
-	
-	
-	/**
-	 * Push just the singe string to the remote side.
-	 * 
-	 * @param aString
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void pushString(String aString) throws IOException;
-	
-	/**
-	 * Push just the bool to the remote side.
-	 * @param aBool
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void pushBoolean(boolean aBool) throws IOException;
-	
-	/**
-	 * Get the final value. It must be called after processing the proxy id resolutions even for sync (so that we can get
-	 * any thrown errors).
-	 * 
-	 * @param result
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	public void getFinalValue(Commands.ValueObject result) throws CommandException;
-	
-	/**
-	 * Send the pull value command, with the proxyids of intereset. If an error
-	 * occurs, command exception is thrown. 
-	 * <p>
-	 * After the pull value call, if no errors, the proxyids must be read, and then getFinalValue call must be sent.
-	 * @param expressionID
-	 * @param proxyids expression proxyids that request feedback or <code>null</code> if no proxy ids.
-	 * @param sender sender to use to process the returned proxy ids, or <code>null</code> if expecting no proxy resolutions.
-	 * 
-	 * @throws CommandException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void pullValue(int expressionID, Commands.ValueObject proxyids, Commands.ValueSender sender) throws CommandException;
-	
-	/**
-	 * Send the sync command, with the proxyids of intereset. If an error
-	 * occurs, command exception is thrown.
-	 * <p>
-	 * After the sync call, if no errors, the returned proxyids must be processed and then the final endValue call must be sent.
-	 * 
-	 * @param expressionID 
-	 * @param proxyids expression proxyids that request feedback or <code>null</code> if no proxy ids.
-	 * @param sender sender to use to process the proxy id resolutions, or <code>null</code> if expecting no proxy ids.
-	 * 
-	 * @throws CommandException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void sync(int expressionID, Commands.ValueObject proxyids, Commands.ValueSender sender) throws CommandException;	
-	
-	/**
-	 * Stop expression processing.
-	 * @param expressionID 
-	 * 
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public void stopExpressionProcessing(int expressionID) throws IOException;
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMMethodProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMMethodProxy.java
deleted file mode 100644
index e921201..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMMethodProxy.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMMethodProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * This interface for REMMethodProxy allows the invokation where
- * the parms are a mixture of constant objects (i.e. can be sent
- * as values to the client) and IBeanProxies. It is only to be
- * used by other factories that want to invoke methods where
- * some of the parms are constants so that there is no need
- * create IBeanProxies for them, e.g. String. This should be
- * used with extreme care.
- */
-
-public interface IREMMethodProxy extends IMethodProxy, IREMBeanProxy {
-	public IBeanProxy invokeWithParms(IBeanProxy subject, Object[] parms) throws ThrowableProxy;
-	
-		
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMSpecialBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMSpecialBeanTypeProxy.java
deleted file mode 100644
index 65974d7..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/IREMSpecialBeanTypeProxy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: IREMSpecialBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-/**
- * This is a special interface for allowing abstract
- * types to create the correct subclass types.
- * Only ones that use REMAnAbstractBeanTypeProxy
- * should implement this.
- */
-public interface IREMSpecialBeanTypeProxy {
-	
-	/**
-	 * Called by REMAnAbstractBeanTypeProxy to create a subclass of it.
-	 * This allows correct types to be created depending upon the
-	 * main super type.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract, IBeanTypeProxy superType);
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/LocalFileConfigurationContributorController.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/LocalFileConfigurationContributorController.java
deleted file mode 100644
index 5232611..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/LocalFileConfigurationContributorController.java
+++ /dev/null
@@ -1,292 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: LocalFileConfigurationContributorController.java,v $
- *  $Revision: 1.13 $  $Date: 2005/10/26 18:48:19 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import java.net.URL;
-import java.util.*;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
-import org.eclipse.jdt.launching.JavaRuntime;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
- 
-/**
- * This version works with local files being added to the classpath, and the classpath is strings.
- * 
- * @since 1.0.0
- */
-public class LocalFileConfigurationContributorController implements IConfigurationContributionController {
-	
-	private URL[] classpathInfo;
-	private URL[][] bootpathInfo;
-	private List classpath;
-	private List prependBootpath;
-	private List appendBootpath;
-	private List javaLibraryPath;
-	private ProxyLaunchSupport.LaunchInfo launchInfo;
-	
-	public LocalFileConfigurationContributorController(URL[] classpathInfo, URL[][] bootpathInfo, ProxyLaunchSupport.LaunchInfo launchInfo) {
-		this.classpathInfo = classpathInfo;
-		this.bootpathInfo = bootpathInfo;
-		this.launchInfo = launchInfo;
-	}
-	
-	public URL[] getFinalClasspath() {
-		if (classpath == null)
-			return classpathInfo;
-		else
-			return (URL[]) classpath.toArray(new URL[classpath.size()]);
-	}
-
-	public URL[] getFinalPrependBootpath() {
-		if (prependBootpath == null)
-			return bootpathInfo[0];
-		else
-			return (URL[]) prependBootpath.toArray(new URL[prependBootpath.size()]);
-	}
-	
-	public URL[] getFinalAppendBootpath() {
-		if (appendBootpath == null)
-			return bootpathInfo[2];
-		else
-			return (URL[]) prependBootpath.toArray(new URL[appendBootpath.size()]);
-	}	
-
-	public List getFinalJavaLibraryPath() {
-		if (javaLibraryPath == null)
-			return Collections.EMPTY_LIST;
-		else
-			return javaLibraryPath;
-	}
-	
-	protected List getClasspath() {
-		if (classpath == null) {
-			classpath = new ArrayList(classpathInfo.length);
-			addAll(classpath, classpathInfo, -1);
-		}
-		return classpath;
-	}
-	
-	protected List getPrependBootpath() {
-		if (prependBootpath == null) {
-			if (bootpathInfo[0] != null) {
-				prependBootpath = new ArrayList(bootpathInfo[0].length);
-				addAll(prependBootpath, bootpathInfo[0], -1);
-			} else
-				prependBootpath = new ArrayList(1);
-		}
-		return prependBootpath;
-	}
-	
-	protected List getAppendBootpath() {
-		if (appendBootpath == null) {
-			if (bootpathInfo[2] != null) {
-				appendBootpath = new ArrayList(bootpathInfo[2].length);
-				addAll(appendBootpath, bootpathInfo[2], -1);
-			} else
-				appendBootpath = new ArrayList(1);
-		}
-		return appendBootpath;
-	}	
-	
-	protected List getJavaLibraryPath() {
-		if (javaLibraryPath == null) {
-			javaLibraryPath = new ArrayList(3);
-		}
-		return javaLibraryPath;
-	}
-	
-	protected void addAll(List toList, Object[] array, int loc) {
-		for (int i = 0; i < array.length; i++) {
-			// Need a dup check, sometimes dups come in especially during development
-			if (toList.contains(array[i]))
-				continue;
-			if (loc == -1)
-				toList.add(array[i]);
-			else
-				toList.add(loc++, array[i]);
-		}
-	}
-	
-	protected void addLocations(List toList, IRuntimeClasspathEntry[] entries) {
-		for (int i = 0; i < entries.length; i++) {
-			IRuntimeClasspathEntry entry = entries[i];
-			URL location = ProxyLaunchSupport.convertStringPathToURL(entry.getLocation());
-			if (location != null && !toList.contains(location))
-				toList.add(location);
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#getJavaProject()
-	 */
-	public IJavaProject getJavaProject() {
-		return launchInfo.getJavaProject();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeProject(org.eclipse.core.resources.IProject)
-	 */
-	public void contributeProject(IProject project) throws CoreException {
-		IJavaProject jproject = JavaCore.create(project);
-		IRuntimeClasspathEntry[] projPath = JavaRuntime.computeUnresolvedRuntimeClasspath(jproject);
-		boolean jreContainerFound= false;
-		for (int i = 0; i < projPath.length; i++) {
-			IRuntimeClasspathEntry entry= projPath[i];
-			if (entry.getClasspathProperty() == IRuntimeClasspathEntry.BOOTSTRAP_CLASSES || entry.getClasspathProperty() == IRuntimeClasspathEntry.STANDARD_CLASSES) {
-				int entryKind= entry.getClasspathEntry().getEntryKind();
-				String segment0= entry.getPath().segment(0);
-				if (entryKind == IClasspathEntry.CPE_CONTAINER && JavaRuntime.JRE_CONTAINER.equals(segment0)
-						|| entryKind == IClasspathEntry.CPE_VARIABLE && JavaRuntime.JRELIB_VARIABLE.equals(segment0)) {
-					jreContainerFound= true;
-				} else {
-					if (jreContainerFound)
-						addLocations(getAppendBootpath(), JavaRuntime.resolveRuntimeClasspathEntry(entry, jproject));
-					else
-						addLocations(getPrependBootpath(), JavaRuntime.resolveRuntimeClasspathEntry(entry, jproject));
-				}
-			} else {
-				addLocations(getClasspath(), JavaRuntime.resolveRuntimeClasspathEntry(entry, jproject));
-			}
-		}			
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeClasspath(java.lang.String, int)
-	 */
-	public void contributeClasspath(String classpath, int typeFlag) {
-		contributeClasspath(ProxyLaunchSupport.convertStringPathToURL(classpath), typeFlag);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeClasspath(java.net.URL, int)
-	 */
-	public void contributeClasspath(URL classpathURL, int typeFlag) {
-		if (classpathURL == null)
-			return;
-		switch (typeFlag) {
-			case PREPEND_BOOT_CLASSPATH:
-				if (!getPrependBootpath().contains(classpathURL))
-					getPrependBootpath().add(classpathURL);
-				break;
-			case PREPEND_USER_CLASSPATH:
-				if (!getClasspath().contains(classpathURL))
-					getClasspath().add(0, classpathURL);
-				break;
-			case APPEND_USER_CLASSPATH:
-				if (!getClasspath().contains(classpathURL))					
-					getClasspath().add(classpathURL);
-				break;				
-			case APPEND_BOOT_CLASSPATH:
-				if (!getAppendBootpath().contains(classpathURL))					
-					getAppendBootpath().add(classpathURL);
-				break;
-			case APPEND_JAVA_LIBRARY_PATH:
-				if (!getJavaLibraryPath().contains(classpathURL))					
-					getJavaLibraryPath().add(classpathURL);
-				break;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeClasspath(org.osgi.framework.Bundle, java.lang.String, int, boolean)
-	 */
-	public void contributeClasspath(Bundle bundle, String relativePath, int typeFlag, boolean nlsLocalize) {
-		// If not nls localize, or if it is java library path, then just find the one in the plugin/fragment and add it.
-		if (nlsLocalize)
-			contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeAllFromBundleAndFragments(bundle, relativePath), typeFlag);
-		else if (typeFlag == IConfigurationContributionController.APPEND_JAVA_LIBRARY_PATH) {
-			if (relativePath == null || relativePath.length() == 0) {
-				// PDE is not here to help us extract that @#$ dll
-			    JEMUtilPlugin.getLogger().log("Can't extract a directory from the root of a plugin."); //$NON-NLS-1$
-			    return;
-			}
-			URL contribution = ProxyPlugin.getPlugin().urlLocalizeFromBundleAndFragments(bundle, relativePath);
-			contributeClasspath(contribution, typeFlag);			
-		} else {
-			if (relativePath != null)
-				contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeFromBundleOnly(bundle, relativePath), typeFlag);
-			else
-				contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeBundle(bundle), typeFlag);
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeClasspath(org.osgi.framework.Bundle, org.eclipse.core.runtime.IPath, int, boolean)
-	 */
-	public void contributeClasspath(Bundle bundle, IPath relativePath, int typeFlag, boolean nlsLocalize) {
-		if (nlsLocalize)
-			if (relativePath != null)
-				contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeAllFromBundleAndFragments(bundle, relativePath), typeFlag);
-			else
-				contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeBundleAndFragments(bundle), typeFlag);
-		else if (typeFlag == IConfigurationContributionController.APPEND_JAVA_LIBRARY_PATH) {
-			if (relativePath == null || relativePath.segmentCount() == 0) {
-				// PDE is not here to help us extract that @#$ dll
-			    JEMUtilPlugin.getLogger().log("Can't extract a directory from the root of a plugin."); //$NON-NLS-1$
-			    return;
-			}
-			URL contribution = ProxyPlugin.getPlugin().urlLocalizeFromBundleAndFragments(bundle, relativePath);
-			contributeClasspath(contribution, typeFlag);			
-		} else {
-			if (relativePath != null)
-				contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeFromBundleOnly(bundle, relativePath), typeFlag);
-			else
-				contributeClasspath(ProxyPlugin.getPlugin().urlLocalizeBundle(bundle), typeFlag);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeClasspath(java.lang.String[], int)
-	 */
-	public void contributeClasspath(String[] classpaths, int typeFlag) {
-		contributeClasspath(ProxyLaunchSupport.convertStringPathsToURL(classpaths), typeFlag);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionController#contributeClasspath(java.net.URL[], int)
-	 */
-	public void contributeClasspath(URL[] classpathURLs, int typeFlag) {
-		if (classpathURLs == null)
-			return;
-		switch (typeFlag) {
-			case PREPEND_BOOT_CLASSPATH:
-				addAll(getPrependBootpath(), classpathURLs, -1);
-				break;
-			case PREPEND_USER_CLASSPATH:
-				addAll(getClasspath(), classpathURLs, 0);
-				break;
-			case APPEND_USER_CLASSPATH:
-				addAll(getClasspath(), classpathURLs, -1);
-				break;				
-			case APPEND_BOOT_CLASSPATH:
-				addAll(getAppendBootpath(), classpathURLs, -1);
-				break;
-			case APPEND_JAVA_LIBRARY_PATH:
-				addAll(getJavaLibraryPath(), classpathURLs, -1);
-				break;
-		}
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/LocalProxyLaunchDelegate.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/LocalProxyLaunchDelegate.java
deleted file mode 100644
index e42d7da..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/LocalProxyLaunchDelegate.java
+++ /dev/null
@@ -1,473 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * $RCSfile: LocalProxyLaunchDelegate.java,v $ $Revision: 1.31 $ $Date: 2005/10/14 17:45:02 $
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.*;
-import java.text.MessageFormat;
-import java.util.*;
-import java.util.logging.Level;
-
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.debug.core.*;
-import org.eclipse.debug.core.model.*;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.launching.*;
-
-import org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.remote.awt.REMRegisterAWT;
-import org.eclipse.jem.util.TimerTests;
-import org.eclipse.jem.util.logger.proxy.Logger;
-
-
-/**
- * Launch Delegate for launching Local (i.e. remote vm is on local system). Here "remote" means the
- * registry is not in the IDE but in a separate VM, and "local" means that is in on the local
- * physical machine and not on a separate machine.
- * 
- * @since 1.0.0
- */
-public class LocalProxyLaunchDelegate extends AbstractJavaLaunchConfigurationDelegate {
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.debug.core.model.ILaunchConfigurationDelegate#launch(org.eclipse.debug.core.ILaunchConfiguration,
-	 *      java.lang.String, org.eclipse.debug.core.ILaunch,
-	 *      org.eclipse.core.runtime.IProgressMonitor)
-	 */
-	public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor pm) throws CoreException {
-
-		String launchKey = configuration.getAttribute(IProxyConstants.ATTRIBUTE_LAUNCH_KEY, (String) null);
-		if (launchKey == null)
-			abort(ProxyRemoteMessages.ProxyRemoteNoLaunchKey, null, 0); 
-
-		// In Eclipse, even if private, a launch will show up in the debug process tree and in the console viewer.
-		// To be absolutely private, we need to remove the launch which has already been added.
-		if (ProxyLaunchSupport.ATTR_PRIVATE != null && configuration.getAttribute(ProxyLaunchSupport.ATTR_PRIVATE, false)) 
-			DebugPlugin.getDefault().getLaunchManager().removeLaunch(launch);		
-		if (pm == null) {
-			pm = new NullProgressMonitor();
-		}
-
-		IJavaProject project = getJavaProject(configuration);
-		String name = configuration.getAttribute(IProxyConstants.ATTRIBUTE_VM_TITLE, (String) null);
-		if (name == null)
-			name = MessageFormat.format(ProxyRemoteMessages.ProxyRemoteVMName, new Object[] { project != null ? project.getProject().getName() : "" }); 
-		else
-			name = MessageFormat.format(ProxyRemoteMessages.ProxyRemoteVMNameWithComment, new Object[] { project != null ? project.getProject().getName() : "", name }); 
-
-		String stepId = "Launch VM ( " + name + " )"; //$NON-NLS-1$ //$NON-NLS-2$
-		TimerTests.basicTest.startStep(stepId);
-		// Problem with launch, can't have double-quotes in vmName.
-		if (name.indexOf('"') != -1)
-			name = name.replace('"', '\'');
-
-		pm.beginTask("", 500); //$NON-NLS-1$
-		pm.subTask(MessageFormat.format(ProxyRemoteMessages.ProxyRemoteLaunchVM, new Object[] { name })); 
-		// check for cancellation
-		if (pm.isCanceled())
-			return;
-
-		IVMInstall vm = verifyVMInstall(configuration);
-
-		IVMRunner runner = vm.getVMRunner(mode);
-		if (runner == null) {
-			abort(MessageFormat.format(ProxyRemoteMessages.Proxy_NoRunner_ERROR_, new Object[] { name }), null, 0); 
-		}
-
-		File workingDir = verifyWorkingDirectory(configuration);
-		String workingDirName = null;
-		if (workingDir != null) {
-			workingDirName = workingDir.getAbsolutePath();
-		}
-
-		// Environment variables
-		String[] envp = DebugPlugin.getDefault().getLaunchManager().getEnvironment(configuration);
-
-		// Program & VM args
-		String pgmArgs = getProgramArguments(configuration);
-		String vmArgs = getVMArguments(configuration);
-		ExecutionArguments execArgs = new ExecutionArguments(vmArgs, pgmArgs);
-
-		// VM-specific attributes
-		Map vmAttributesMap = getVMSpecificAttributesMap(configuration);
-
-		pm.worked(100);
-		
-		// Now let's get the classpaths created through the contributors.
-		URL[] classpath = ProxyLaunchSupport.convertStringPathsToURL(getClasspath(configuration));
-		String[][] bootpathInfoStrings = getBootpathExt(vmAttributesMap);
-		URL[][] bootpathInfo = new URL[][]{
-				ProxyLaunchSupport.convertStringPathsToURL(bootpathInfoStrings[0]),
-				ProxyLaunchSupport.convertStringPathsToURL(bootpathInfoStrings[1]),
-				ProxyLaunchSupport.convertStringPathsToURL(bootpathInfoStrings[2]),
-		};
-		ProxyLaunchSupport.LaunchInfo launchInfo = ProxyLaunchSupport.getInfo(launchKey);
-		final IConfigurationContributor[] contributors = launchInfo.contributors;
-		final LocalFileConfigurationContributorController controller =
-			new LocalFileConfigurationContributorController(classpath, bootpathInfo, launchInfo);
-		if (contributors != null) {		
-			for (int i = 0; i < contributors.length; i++) {
-				// Run in safe mode so that anything happens we don't go away.
-				final int ii = i;
-				Platform.run(new ISafeRunnable() {
-					public void handleException(Throwable exception) {
-						// Don't need to do anything. Platform.run logs it for me.
-					}
-
-					public void run() throws Exception {
-						contributors[ii].contributeClasspaths(controller);
-					}
-				});
-			}
-		}
-
-		// Add in the required ones by the Proxy support. These are hard-coded since they are
-		// required.
-		ProxyRemoteUtil.updateClassPaths(controller);
-		addInFragmentLibraries(controller, launchInfo.getConfigInfo());
-
-		classpath = controller.getFinalClasspath();
-		if (bootpathInfo[0] != controller.getFinalPrependBootpath()) {
-		    if (vmAttributesMap == null)
-		        vmAttributesMap = new HashMap(2);
-		    vmAttributesMap.put(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_PREPEND, ProxyLaunchSupport.convertURLsToStrings(bootpathInfo[0]));
-		}
-		if (bootpathInfo[2] != controller.getFinalAppendBootpath()) {
-		    if (vmAttributesMap == null)
-		        vmAttributesMap = new HashMap(2);
-		    vmAttributesMap.put(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_APPEND, ProxyLaunchSupport.convertURLsToStrings(bootpathInfo[2]));
-		}
-
-		// check for cancellation
-		if (pm.isCanceled())
-			return;
-		pm.worked(100);
-
-		// Create VM config
-		VMRunnerConfiguration runConfig =
-			new VMRunnerConfiguration("org.eclipse.jem.internal.proxy.vm.remote.RemoteVMApplication", ProxyLaunchSupport.convertURLsToStrings(classpath)); //$NON-NLS-1$
-
-		REMProxyFactoryRegistry registry = new REMProxyFactoryRegistry(ProxyRemoteUtil.getRegistryController(), name);
-		Integer registryKey = registry.getRegistryKey();
-
-		Integer bufSize = Integer.getInteger("proxyvm.bufsize"); //$NON-NLS-1$
-		if (bufSize == null)
-			bufSize = new Integer(16000);
-
-		int masterServerPort = ProxyRemoteUtil.getRegistryController().getMasterSocketPort();
-
-		// See if debug mode is requested.
-		DebugModeHelper dh = new DebugModeHelper();
-		boolean debugMode = dh.debugMode(name);
-		boolean useNoverify = ProxyPlugin.getPlugin().getPluginPreferences().getBoolean(ProxyPlugin.PREFERENCES_VM_NOVERIFY_KEY);
-
-		String[] evmArgs = execArgs.getVMArgumentsArray();
-		
-		int extraArgs = 4;	// Number of extra standard args added (if number changes below, this must change)
-		if (debugMode)
-			extraArgs+=4;	// Number of extra args added for debug mode (if number changes below, this must change).
-		if(useNoverify)
-			extraArgs++; // An extra arg added for '-noverify' flag (if number changes below, this must change).
-		
-		boolean useExpressionTracing = "true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyLaunchSupport.EXPRESSION_TRACING)); //$NON-NLS-1$
-		long expressionTracingThreshold = -1;
-		if (useExpressionTracing) {
-			extraArgs++;
-			String thresholdString = Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyLaunchSupport.EXPRESSION_TRACEING_TIMER_THRESHOLD);
-			if (thresholdString != null) {
-				try {
-					expressionTracingThreshold = Long.valueOf(thresholdString).longValue();
-					extraArgs++;
-				} catch (NumberFormatException e) {
-				}
-			}
-		}
-		
-		List javaLibPaths = controller.getFinalJavaLibraryPath();
-		int existingLibpaths = -1;
-		if (!javaLibPaths.isEmpty()) {
-			// first need to see if java lib path also specified in standard args by someone configuring the configuration by hand.
-			for (int i = 0; i < evmArgs.length; i++) {
-				if (evmArgs[i].startsWith("-Djava.library.path")) { //$NON-NLS-1$
-					// We found one already here, save the spot so we update it later.
-					existingLibpaths = i;
-					break;
-				}
-			}
-			if (existingLibpaths == -1)
-				++extraArgs;	// Need to have room for one more.
-		}
-		
-		String[] cvmArgs = new String[evmArgs.length + extraArgs];
-		System.arraycopy(evmArgs, 0, cvmArgs, extraArgs, evmArgs.length);	// Put existing into new list at the end.		
-		
-		int cvmArgsCount=0;
-		cvmArgs[cvmArgsCount++] = "-Dproxyvm.registryKey=" + registryKey; //$NON-NLS-1$
-		cvmArgs[cvmArgsCount++] = "-Dproxyvm.masterPort=" + String.valueOf(masterServerPort); //$NON-NLS-1$
-		cvmArgs[cvmArgsCount++] = "-Dproxyvm.bufsize=" + bufSize; //$NON-NLS-1$
-		cvmArgs[cvmArgsCount++] = "-Dproxyvm.servername=" + name; //$NON-NLS-1$
-		
-		if(useNoverify)
-			cvmArgs[cvmArgsCount++] = "-noverify"; //$NON-NLS-1$
-		
-		if (useExpressionTracing) {
-			cvmArgs[cvmArgsCount++] = "-D"+ExpressionCommands.EXPRESSIONTRACE+"=true"; //$NON-NLS-1$ //$NON-NLS-2$
-			if (expressionTracingThreshold != -1)
-				cvmArgs[cvmArgsCount++] = "-D"+ExpressionCommands.EXPRESSIONTRACE_TIMER_THRESHOLD+'='+String.valueOf(expressionTracingThreshold); //$NON-NLS-1$
-		}
-
-		// If in debug mode, we need to find a port for it to use.
-		int dport = -1;
-		if (debugMode) {
-			dport = findUnusedLocalPort("localhost", 5000, 15000, new int[0]); //$NON-NLS-1$
-			cvmArgs[cvmArgsCount++] = "-Djava.compiler=NONE"; //$NON-NLS-1$
-			cvmArgs[cvmArgsCount++] = "-Xdebug"; //$NON-NLS-1$
-			cvmArgs[cvmArgsCount++] = "-Xnoagent"; //$NON-NLS-1$
-			cvmArgs[cvmArgsCount++] = "-Xrunjdwp:transport=dt_socket,server=y,address=" + dport; //$NON-NLS-1$
-		}
-		
-		if (!javaLibPaths.isEmpty()) {
-			StringBuffer appendTo = null;
-			if (existingLibpaths != -1) {
-				appendTo = new StringBuffer(evmArgs[existingLibpaths]); 
-				appendTo.append(File.pathSeparatorChar);	// Plus a separator so we can append
-			} else 
-				appendTo = new StringBuffer("-Djava.library.path="); //$NON-NLS-1$
-			String [] libPaths = ProxyLaunchSupport.convertURLsToStrings((URL[]) javaLibPaths.toArray(new URL[javaLibPaths.size()]));
-			for (int i = 0; i < libPaths.length; i++) {
-				if (i != 0)
-					appendTo.append(File.pathSeparator);
-				appendTo.append(libPaths[i]);
-			}
-			if (existingLibpaths != -1)
-				cvmArgs[extraArgs+existingLibpaths] = appendTo.toString();
-			else
-				cvmArgs[extraArgs-1] = appendTo.toString();
-		}
-
-		runConfig.setProgramArguments(execArgs.getProgramArgumentsArray());
-		runConfig.setEnvironment(envp);
-		runConfig.setVMArguments(cvmArgs);
-		runConfig.setWorkingDirectory(workingDirName);
-		runConfig.setVMSpecificAttributesMap(vmAttributesMap);
-
-		// Bootpath
-		runConfig.setBootClassPath(getBootpath(configuration));
-
-		// check for cancellation
-		if (pm.isCanceled())
-			return;
-		pm.worked(100);
-
-		// set the default source locator if required
-		setDefaultSourceLocator(launch, configuration);
-
-		// Launch the configuration - 1 unit of work
-		runner.run(runConfig, launch, new SubProgressMonitor(pm, 100));
-
-		// check for cancellation
-		if (pm.isCanceled())
-			return;
-
-		IProcess[] processes = launch.getProcesses();
-		IProcess process = processes[0]; // There is only one.
-		// Check if it is already terminated. If it is, then there was a bad error, so just
-		// print out the results from it.
-		if (process.isTerminated()) {
-			IStreamsProxy stProxy = process.getStreamsProxy();
-			// Using a printWriter for println capability, but it needs to be on another
-			// writer, which will be string
-			java.io.StringWriter s = new java.io.StringWriter();
-			java.io.PrintWriter w = new java.io.PrintWriter(s);
-
-			w.println(ProxyRemoteMessages.VM_TERMINATED_INFO_); 
-			w.println(ProxyRemoteMessages.VM_TERMINATED_LINE1); 
-			w.println(stProxy.getErrorStreamMonitor().getContents());
-			w.println(ProxyRemoteMessages.VM_TERMINATED_LINE2); 
-			w.println(stProxy.getOutputStreamMonitor().getContents());
-			w.println(ProxyRemoteMessages.VM_TERMINATED_LINE3); 
-			w.close();
-
-			String msg = MessageFormat.format(ProxyRemoteMessages.Proxy_Terminated_too_soon_ERROR_, new Object[] { name }); 
-			dh.displayErrorMessage(ProxyRemoteMessages.Proxy_Error_Title, msg); 
-			throw new CoreException(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, s.toString(), null));
-		} else {
-			final String traceName = name;
-			IStreamsProxy fStreamsProxy = process.getStreamsProxy();
-
-			/**
-			 * StreamListener. Should not be created if ProxyPlugin logger is not logging the requested level.
-			 * 
-			 * @since 1.1.0
-			 */
-			class StreamListener implements IStreamListener {
-				String tracePrefix;
-				Level level;
-				Job printJob;	// Job to try to gather printing together.
-				Logger logger;
-				StringBuffer gatheredText = new StringBuffer(100);
-				{
-					logger = ProxyPlugin.getPlugin().getLogger();
-					printJob = new Job("") { //$NON-NLS-1$
-
-						protected IStatus run(IProgressMonitor monitor) {
-							monitor.beginTask(ProxyRemoteMessages.LocalProxyLaunchDelegate_Monitor_PrintRemoteTrace_Text, 1); 
-							while(true) {
-								String output = null;
-								synchronized (gatheredText) {
-									if (gatheredText.length() <= tracePrefix.length())
-										break;	// We've reached the end, no more to print.
-									output = gatheredText.toString();
-									gatheredText.setLength(tracePrefix.length());	// Reset the length to the prefix.
-								}
-								logger.log(output, level);
-							}
-							monitor.done();
-							return Status.OK_STATUS;
-						}
-					};
-					printJob.setPriority(Job.SHORT);
-					printJob.setSystem(true);
-				}
-				
-				public StreamListener(String type, Level level, Logger logger) {
-					tracePrefix = traceName + ':' + type + '>' + System.getProperty("line.separator"); //$NON-NLS-1$
-					gatheredText.append(tracePrefix);
-					this.level = level;
-					this.logger = logger;
-				}
-
-				public void streamAppended(String newText, IStreamMonitor monitor) {
-					synchronized(gatheredText) {
-						gatheredText.append(newText);
-					}
-					printJob.schedule(100L);	// Wait tenth of second to gather as much as can together.
-				}
-			};
-
-			Logger logger = ProxyPlugin.getPlugin().getLogger();
-			if (logger.isLoggingLevel(Level.WARNING)) {
-				// Always listen to System.err output if we are at least logging warnings.
-				IStreamMonitor monitor = fStreamsProxy.getErrorStreamMonitor();
-				if (monitor != null)
-					monitor.addListener(new StreamListener("err", Level.WARNING, logger)); //$NON-NLS-1$
-			}
-
-			// If debug trace is requested, then attach trace listener for System.out
-			// Expression tracing requires debug trace too because it prints to sysout. However, it requesting expressionTracing, change logging level to INFO,
-			// we want them to show if this true. It is confusing to also have to change logging level in .options file.
-			if (useExpressionTracing)
-				if (!logger.isLoggingLevel(Level.INFO))
-					logger.setLevel(Level.INFO);
-			if (useExpressionTracing || "true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyRemoteUtil.DEBUG_VM_TRACEOUT))) { //$NON-NLS-1$
-				// Want to trace the output of the remote vm's. And we are logging at least level info.
-				if (logger.isLoggingLevel(Level.INFO)) {
-					IStreamMonitor monitor = fStreamsProxy.getOutputStreamMonitor();
-					if (monitor != null)
-						monitor.addListener(new StreamListener("out", Level.INFO, logger)); //$NON-NLS-1$							
-				}							
-			}
-		}
-
-		// If in debug mode, tester must start debugger before going on.
-		if (debugMode) {
-			if (!dh.promptPort(dport)) {
-				process.terminate();
-				throw new CoreException(
-					new Status(
-						IStatus.WARNING,
-						ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
-						0,
-						"Debugger attach canceled", //$NON-NLS-1$
-						null));
-			}
-		}
-
-		// Now set up the registry.
-		registry.initializeRegistry(process);
-		new REMStandardBeanTypeProxyFactory(registry);
-		new REMStandardBeanProxyFactory(registry);
-		new REMMethodProxyFactory(registry);
-
-		if (debugMode || REMProxyFactoryRegistry.fGlobalNoTimeouts)
-			registry.fNoTimeouts = true;
-		if (configuration.getAttribute(IProxyConstants.ATTRIBUTE_AWT_SWING, true))
-			REMRegisterAWT.registerAWT(registry);
-
-		launchInfo.resultRegistry = registry;
-
-		pm.done();
-		TimerTests.basicTest.stopStep(stepId);
-	}
-
-	/**
-	 * @param controller
-	 * @param info 
-	 * @throws CoreException
-	 * 
-	 * @since 1.0.2
-	 */
-	private void addInFragmentLibraries(IConfigurationContributionController controller, IConfigurationContributionInfo info) throws CoreException {
-		IPDEContributeClasspath instance = IPDEContributeClasspath.INSTANCE;
-		if (instance != null) {
-			instance.getPDEContributions(controller, info);
-		}
-	}
-
-	// Utilities to find the free port
-	private static final Random fgRandom = new Random(System.currentTimeMillis());
-
-	private static int findUnusedLocalPort(String host, int searchFrom, int searchTo, int[] exclude) {
-		for (int i = 0; i < 10; i++) {
-			int port = 0;
-			newport : while (true) {
-				port = getRandomPort(searchFrom, searchTo);
-				if (exclude != null)
-					for (int e = 0; e < exclude.length; e++)
-						if (port == exclude[e])
-							continue newport;
-				break;
-			}
-			try {
-				new Socket(host, port);
-			} catch (ConnectException e) {
-				return port;
-			} catch (IOException e) {
-			}
-		}
-		return -1;
-	}
-
-	private static int getRandomPort(int low, int high) {
-		return (int) (fgRandom.nextFloat() * (high - low)) + low;
-	}
-	
-	private String[][] getBootpathExt(Map vmMap) {
-	    String[][] ext = new String[3][];
-	    if (vmMap != null) {
-		    ext[0] = (String[]) vmMap.get(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_PREPEND);
-		    ext[1] = (String[]) vmMap.get(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH);
-		    ext[2] = (String[]) vmMap.get(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_APPEND);
-	    }
-	    return ext;
-	}
-	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/MessageDialog.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/MessageDialog.java
deleted file mode 100644
index aa614e5..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/MessageDialog.java
+++ /dev/null
@@ -1,331 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: MessageDialog.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.awt.*;
-/**
- * This is an AWT message dialog. It will only be used
- * if not running in the workbench by the debug mode helper.
- * It won't be loaded unless AWT is available, so it can be
- * distributed without causing problems on systems that
- * don't have AWT because it won't be loaded in that case.
- */
-class MessageDialog extends Dialog {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = 2547670349372067345L;
-	private java.awt.Panel ivjContentsPane = null;
-	IvjEventHandler ivjEventHandler = new IvjEventHandler();
-	private java.awt.TextArea ivjTextArea1 = null;
-	private java.awt.Button ivjButton1 = null;
-	public int result = 2;	// Nothing hit is the same as button 2.
-	private java.awt.Button ivjButton2 = null;
-
-class IvjEventHandler implements java.awt.event.ActionListener, java.awt.event.WindowListener {
-		public void actionPerformed(java.awt.event.ActionEvent e) {
-			if (e.getSource() == MessageDialog.this.getButton1()) 
-				connEtoC2(e);
-			if (e.getSource() == MessageDialog.this.getButton2()) 
-				connEtoC3(e);
-		};
-		public void windowActivated(java.awt.event.WindowEvent e) {};
-		public void windowClosed(java.awt.event.WindowEvent e) {};
-		public void windowClosing(java.awt.event.WindowEvent e) {
-			if (e.getSource() == MessageDialog.this) 
-				connEtoC1(e);
-		};
-		public void windowDeactivated(java.awt.event.WindowEvent e) {};
-		public void windowDeiconified(java.awt.event.WindowEvent e) {};
-		public void windowIconified(java.awt.event.WindowEvent e) {};
-		public void windowOpened(java.awt.event.WindowEvent e) {};
-	};
-/**
- * MessageDialog constructor comment.
- * @param owner java.awt.Frame
- * @param title java.lang.String
- * @param modal boolean
- */
-public MessageDialog(Frame owner, String title, boolean modal, String msg, String button1, String button2) {
-	super(owner, title, modal);
-
-	initialize();
-	getTextArea1().setText(msg);
-	getButton1().setLabel(button1);
-	if (button2 != null)
-		getButton2().setLabel(button2);
-	else {
-		// We only want one button, so remove button2
-		getContentsPane().remove(getButton2());
-	}
-	
-}
-/**
- * Comment
- */
-public void button1_ActionPerformed() {
-	result = 1;
-	setVisible(false);
-	return;
-}
-/**
- * Comment
- */
-public void button2_ActionPerformed() {
-	result = 2;
-	setVisible(false);
-	return;
-}
-/**
- * connEtoC1:  (MessageDialog.window.windowClosing(java.awt.event.WindowEvent) --> MessageDialog.dispose()V)
- * @param arg1 java.awt.event.WindowEvent
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private void connEtoC1(java.awt.event.WindowEvent arg1) {
-	try {
-		// user code begin {1}
-		// user code end
-		this.dispose();
-		// user code begin {2}
-		// user code end
-	} catch (java.lang.Throwable ivjExc) {
-		// user code begin {3}
-		// user code end
-		handleException(ivjExc);
-	}
-}
-/**
- * connEtoC2:  (Button1.action.actionPerformed(java.awt.event.ActionEvent) --> MessageDialog.button1_ActionPerformed()V)
- * @param arg1 java.awt.event.ActionEvent
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private void connEtoC2(java.awt.event.ActionEvent arg1) {
-	try {
-		// user code begin {1}
-		// user code end
-		this.button1_ActionPerformed();
-		// user code begin {2}
-		// user code end
-	} catch (java.lang.Throwable ivjExc) {
-		// user code begin {3}
-		// user code end
-		handleException(ivjExc);
-	}
-}
-/**
- * connEtoC3:  (Button2.action.actionPerformed(java.awt.event.ActionEvent) --> MessageDialog.button2_ActionPerformed()V)
- * @param arg1 java.awt.event.ActionEvent
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private void connEtoC3(java.awt.event.ActionEvent arg1) {
-	try {
-		// user code begin {1}
-		// user code end
-		this.button2_ActionPerformed();
-		// user code begin {2}
-		// user code end
-	} catch (java.lang.Throwable ivjExc) {
-		// user code begin {3}
-		// user code end
-		handleException(ivjExc);
-	}
-}
-/**
- * Display dialog.
- * @param args java.lang.String[]
- */
-public static int doit(String title, String message, String button1, String button2) {
-	try {
-		Frame f = new java.awt.Frame(title);
-		f.setVisible(true);
-		// Need to massage the method since AWT doesn't have wordwrap. This is for left to right only.
-		String msg = message;
-		if (message.length() > 95) {
-			msg = ""; //$NON-NLS-1$
-nextSeg:	while (message.length() > 95) {
-				// Too wide, wrapping should be done. This is just a rough guess.
-				for (int i=95; 0<=i; i--) {
-					if (message.charAt(i) == ' ') {
-						// Break here.
-						msg = msg + message.substring(0, i) + '\n';
-						if (i+1 < message.length())
-							message = message.substring(i+1);
-						else
-							message = ""; //$NON-NLS-1$
-						continue nextSeg;
-					}
-				}
-				// If we got here, then there weren't any spaces in the first 80, so look right for first space.
-				for (int i=96; i<message.length(); i++) {
-					if (message.charAt(i) == ' ') {
-						// Break here
-						msg = msg + message.substring(0, i) + '\n';
-						if (i+1 < message.length())
-							message = message.substring(i+1);
-						else
-							message = ""; //$NON-NLS-1$
-						continue nextSeg;
-					}
-				}
-			}
-			msg += message;	// Now put on whatever is left.
-		}
-		MessageDialog aMessageDialog = new MessageDialog(f,title,true, msg, button1, button2);
-		aMessageDialog.pack();
-		aMessageDialog.getToolkit().beep();
-		aMessageDialog.setVisible(true);
-		f.dispose();
-		aMessageDialog.dispose();
-
-		return aMessageDialog.result;
-	} catch (Throwable exception) {
-	}
-
-	return 2;
-}
-/**
- * Return the Button1 property value.
- * @return java.awt.Button
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private java.awt.Button getButton1() {
-	if (ivjButton1 == null) {
-		try {
-			ivjButton1 = new java.awt.Button();
-			ivjButton1.setName("Button1"); //$NON-NLS-1$
-			ivjButton1.setLabel("Button1"); //$NON-NLS-1$
-			// user code begin {1}
-			// user code end
-		} catch (java.lang.Throwable ivjExc) {
-			// user code begin {2}
-			// user code end
-			handleException(ivjExc);
-		}
-	}
-	return ivjButton1;
-}
-/**
- * Return the Button2 property value.
- * @return java.awt.Button
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private java.awt.Button getButton2() {
-	if (ivjButton2 == null) {
-		try {
-			ivjButton2 = new java.awt.Button();
-			ivjButton2.setName("Button2"); //$NON-NLS-1$
-			ivjButton2.setLabel("Button2"); //$NON-NLS-1$
-			// user code begin {1}
-			// user code end
-		} catch (java.lang.Throwable ivjExc) {
-			// user code begin {2}
-			// user code end
-			handleException(ivjExc);
-		}
-	}
-	return ivjButton2;
-}
-/**
- * Return the ContentsPane property value.
- * @return java.awt.Panel
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private java.awt.Panel getContentsPane() {
-	if (ivjContentsPane == null) {
-		try {
-			ivjContentsPane = new java.awt.Panel();
-			ivjContentsPane.setName("ContentsPane"); //$NON-NLS-1$
-			ivjContentsPane.setLayout(new java.awt.FlowLayout());
-			getContentsPane().add(getTextArea1(), getTextArea1().getName());
-			getContentsPane().add(getButton1(), getButton1().getName());
-			getContentsPane().add(getButton2(), getButton2().getName());
-			// user code begin {1}
-			// user code end
-		} catch (java.lang.Throwable ivjExc) {
-			// user code begin {2}
-			// user code end
-			handleException(ivjExc);
-		}
-	}
-	return ivjContentsPane;
-}
-/**
- * Return the TextArea1 property value.
- * @return java.awt.TextArea
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private java.awt.TextArea getTextArea1() {
-	if (ivjTextArea1 == null) {
-		try {
-			ivjTextArea1 = new TextArea();
-			ivjTextArea1.setName("TextArea1"); //$NON-NLS-1$
-			ivjTextArea1.setText("TextArea1"); //$NON-NLS-1$
-			ivjTextArea1.setRows(20);
-			ivjTextArea1.setColumns(100);
-			ivjTextArea1.setEditable(false);
-			// user code begin {1}
-			// user code end
-		} catch (java.lang.Throwable ivjExc) {
-			// user code begin {2}
-			// user code end
-			handleException(ivjExc);
-		}
-	}
-	return ivjTextArea1;
-}
-/**
- * Called whenever the part throws an exception.
- * @param exception java.lang.Throwable
- */
-private void handleException(java.lang.Throwable exception) {
-
-	/* Uncomment the following lines to print uncaught exceptions to stdout */
-	// ProxyPlugin.getPlugin().getMsgLogger().write(Level.WARNING,"--------- UNCAUGHT EXCEPTION ---------");
-	// ProxyPlugin.getPlugin().getMsgLogger().write(Level.WARNING,exception);
-}
-/**
- * Initializes connections
- * @exception java.lang.Exception The exception description.
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private void initConnections() throws java.lang.Exception {
-	// user code begin {1}
-	// user code end
-	this.addWindowListener(ivjEventHandler);
-	getButton1().addActionListener(ivjEventHandler);
-	getButton2().addActionListener(ivjEventHandler);
-}
-/**
- * Initialize the class.
- */
-/* WARNING: THIS METHOD WILL BE REGENERATED. */
-private void initialize() {
-	try {
-		// user code begin {1}
-		// user code end
-		setName("MessageDialog"); //$NON-NLS-1$
-		setLayout(new java.awt.BorderLayout());
-		setSize(426, 240);
-		add(getContentsPane(), "Center"); //$NON-NLS-1$
-		initConnections();
-	} catch (java.lang.Throwable ivjExc) {
-		handleException(ivjExc);
-	}
-	// user code begin {2}
-	// user code end
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/ProxyRemoteMessages.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/ProxyRemoteMessages.java
deleted file mode 100644
index f2bf8d4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/ProxyRemoteMessages.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class ProxyRemoteMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.proxy.remote.messages";//$NON-NLS-1$
-
-	private ProxyRemoteMessages() {
-		// Do not instantiate
-	}
-
-	public static String NO_OUTPUT_FOLDER_EXC_;
-	public static String VM_TERMINATED_INFO_;
-	public static String VM_TERMINATED_LINE1;
-	public static String VM_TERMINATED_LINE2;
-	public static String VM_TERMINATED_LINE3;
-	public static String REMOTE_VM_TRACE_INFO_;
-	public static String REMOTE_VM_LOCAL_TRACE_INFO_;
-	public static String Classcast_EXC_;
-	public static String Instantiate_EXC_;
-	public static String RemoteCmd_EXC_;
-	public static String ExceptionErrorMsg_EXC_;
-	public static String OK_7;
-	public static String Proxy_NoRunner_ERROR_;
-	public static String Proxy_Error_Title;
-	public static String Proxy_Terminated_too_soon_ERROR_;
-	public static String ProxyRemoteVMName;
-	public static String ProxyRemoteVMNameWithComment;
-	public static String ProxyRemoteNoLaunchKey;
-	public static String ProxyRemoteLaunchVM;
-	public static String CleanupJob_title;
-	public static String REMProxyFactoryRegistry_CallbackConnectionNotWorking_EXC_;
-	public static String REMProxyFactoryRegistry_ConnectionCreationFailed_INFO_;
-	public static String REMProxyFactoryRegistry_Job_TerminateProcess_Title;
-	public static String REMProxyFactoryRegistry_CouldNotCreateSocketConnectionToRemoteVM_EXC_;
-	public static String REMExpression_IOExceptionSeeLog_INFO_;
-	public static String REMExpression_CommandExceptionSeeLog_INFO_;
-	public static String LocalProxyLaunchDelegate_Monitor_PrintRemoteTrace_Text;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, ProxyRemoteMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/ProxyRemoteUtil.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/ProxyRemoteUtil.java
deleted file mode 100644
index ae4e5b6..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/ProxyRemoteUtil.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: ProxyRemoteUtil.java,v $
- *  $Revision: 1.12 $  $Date: 2005/10/26 14:24:51 $ 
- */
-
-
-import org.eclipse.core.runtime.IPath;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.proxy.core.IConfigurationContributionController;
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-
-
-public class ProxyRemoteUtil {
-
-	// Debug options
-	public static final String DEBUG_VM = "/remote/debug/debugvm", // Bring up debugger on remote vm's. //$NON-NLS-1$
-		IO_CONSOLE = "/remote/debug/ioconsole", // IO Through console (system in and out) for asking questions. //$NON-NLS-1$
-		DEBUG_VM_TRACEOUT = "/remote/debug/vmtraceout", // Trace the output from the remote vm's. //$NON-NLS-1$
-		NO_TIMEOUTS = "/remote/debug/notimeouts";	// No socket timeouts when talking to remote vm. Turn this on when doing callback testing. Not needed otherwise. //$NON-NLS-1$
-	
-	private static REMRegistryController pluginRegistryController;
-	
-	/**
-	 * Return the registry controller.
-	 */
-	public synchronized static REMRegistryController getRegistryController() {
-		return pluginRegistryController != null ? pluginRegistryController : (pluginRegistryController = new REMRegistryController());
-	}
-	
-	/**
-	 * Method to update any class paths with any
-	 * paths that need to be added to a VM. In this case, it is
-	 * the remotevm.jar and the remotecommon.jar that need to be added. The first jar contains
-	 * the code necessary to run the remote vm and listen for commands. The second jar contains
-	 * the common code that is required to be shared on both the IDE side and remote side. It
-	 * is the interface code so that they both talk the same language.
-	 * support.
-	 */
-	public static void updateClassPaths(IConfigurationContributionController controller) {
-		Bundle proxyBundle = ProxyPlugin.getPlugin().getBundle();
-		// Need to have our jars at the beginning. (Struts causes a problem because 
-		// they have a jar (commons-fileupload.jar) that if when searching for a class and
-		// this jar is reached, it causes the class loader to barf. Our jars used to be at
-		// the end, and so it found the fileupload jar first and no remote vm could be started
-		// because of this.
-		controller.contributeClasspath(proxyBundle, (IPath) null, IConfigurationContributionController.PREPEND_USER_CLASSPATH, false); //$NON-NLS-1$
-		controller.contributeClasspath(proxyBundle, "vm/remotevm.jar", IConfigurationContributionController.PREPEND_USER_CLASSPATH, false); //$NON-NLS-1$		
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractBeanProxy.java
deleted file mode 100644
index 10c921a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractBeanProxy.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMAbstractBeanProxy.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-/**
- * An abstract base class of IREMBeanProxy that doesn't
- * have the bean type stored in it. The subclasses will
- * supply it. It does however have an ID because it does
- * exist over on the remote VM.
- */
-public abstract class REMAbstractBeanProxy implements IREMBeanProxy {
-	protected final REMProxyFactoryRegistry fFactory;
-	private Integer fID;
-	
-	/**
-	 * Set the bean we are proxying.  We are a proxy for a bean running on the remote VM. 
-	 */
-	protected REMAbstractBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID){
-		fFactory = aRegistry;
-		fID = anID;
-	}
-	
-	/**
-	 * equals: Equal if:
-	 *         1) This proxy == (identity) to the other object
-	 *         2) Else if other is an IBeanProxy and not a constant one, then if
-	 *            equals on the server.
-	 *         3) If this is a constant proxy and the other is too or is a constant
-	 *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
-	 */
-	public boolean equals(Object anObject) {
-		if (super.equals(anObject))
-			return true;	// Identity
-		if (anObject instanceof IBeanProxy && !(anObject instanceof IREMConstantBeanProxy) && fFactory.isValid() && ((IBeanProxy) anObject).getProxyFactoryRegistry() == fFactory)
-			try {
-				// The other is a bean proxy and is not a constant one, let the server do the check.
-				return ((IBooleanBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getObjectEquals().invoke(this, (IBeanProxy) anObject)).booleanValue();
-			} catch (ThrowableProxy e) {
-			}
-		return false;
-	}	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		return this == aBeanProxy;	// We can be assured in Remote Proxy that identity of proxy and identity of object are the same.
-	}
-		
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fFactory;
-	}
-	
-	/**
-	 * Get ID. An internal method to be used only within the ProxyFactory family.
-	 */
-	public Integer getID() {
-		return fID;
-	}
-	
-	/**
-	 * isValid.
-	 */
-	public boolean isValid() {
-		return fID != null;
-	}
-	
-	/**
-	 * Proxy is about to be released, MUST mark it invalid.
-	 * This is required. Resources can also be cleaned up
-	 * if they are being held and need to be cleaned up.
-	 *
-	 * NOTE: This method will only be called when the proxy
-	 * is explicitly released. If it is simply garbage collected,
-	 * then this method will not be called. Simple garbage collection
-	 * means that no one is referencing this proxy. The proxy factory
-	 * will know what id this proxy was referencing and will release it
-	 * on the server at GC time.
-	 *
-	 * If there are resources
-	 * that absolutely must be released, then the finalize method
-	 * should be implemented to do the clean up. However, try not
-	 * to have this be the case. Finalize methods add overhead that is
-	 * usually better not to have. The better way is for any users
-	 * that get this kind of proxy object know to call release on
-	 * ProxyFactoryRegistry to release it before garbage collection.	 
-	 */
-	public void release() {
-		fID = null;
-	}
-			
-	/**
-	 * Return the toString of the actual bean on the remote side.
-	 */
-	public String toBeanString() {
-		IStringBeanProxy string = (IStringBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getObjectToString().invokeCatchThrowableExceptions(this);
-		return (string != null) ? string.stringValue() : null;
-	}
-	
-	/**
-	 * Render the bean proxy into the value field.
-	 */
-	public void renderBean(Commands.ValueObject value) {
-		value.setObjectID(isValid() ? getID().intValue() : Commands.VOID);	// No longer exists, so send over null.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractBeanTypeProxy.java
deleted file mode 100644
index 91d15f0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractBeanTypeProxy.java
+++ /dev/null
@@ -1,701 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMAbstractBeanTypeProxy.java,v $
- *  $Revision: 1.15 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.TransmitableArray;
-
-/**
- * This implementation of IBeanTypeProxy is for where the Bean is on a different VM then the IDE
- * 
- * Creation date: (12/3/99 12:29:26 PM)
- * 
- * @author: Joe Winchester
- */
-public abstract class REMAbstractBeanTypeProxy implements IREMBeanTypeProxy {
-
-	private Integer fID;
-
-	protected final REMProxyFactoryRegistry fRegistry;
-
-	protected final String fClassname; // This is cached here so that we don't need to go over the line to get it.
-
-	private IBeanTypeProxy fSuperType; // This is cached so as not to have to go over the line for it.
-
-	/**
-	 * Create with a registry and a class. It is protected so that only subclasses and the factory with this REM package can call it.
-	 */
-	protected REMAbstractBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-		fRegistry = aRegistry;
-		fID = anID;
-		fClassname = aClassname;
-		fSuperType = aSuperType;
-	}
-
-	/**
-	 * equals: Equal if: 1) This proxy == (identity) to the other object This is all that is needed for BeanTypes because we know these are classes,
-	 * there is only one per class, and Class equals is true only for identity.
-	 */
-	public boolean equals(Object anObject) {
-		return super.equals(anObject);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		return this == aBeanProxy; // We can be assured in Remote Proxy that identity of proxy and identity of object are the same.
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanProxy#getID()
-	 */
-	public Integer getID() {
-		return fID;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#isValid()
-	 */
-	public boolean isValid() {
-		return fID != null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanProxy#release()
-	 */
-	public void release() {
-		// Clear the id and supertype (supertype is cleared so that
-		// it won't hold onto it and will let the supertype be GC'd
-		// if necessary.
-
-		fID = null;
-		fSuperType = null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(java.lang.String[])
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames) {
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		// Turn class names into array of BeanTypes.
-		IBeanTypeProxy[] argTypes = null;
-		if (argumentClassNames != null) {
-			IStandardBeanTypeProxyFactory typeFactory = fRegistry.getBeanTypeProxyFactory();
-			argTypes = new IBeanTypeProxy[argumentClassNames.length];
-			for (int i = 0; i < argumentClassNames.length; i++) {
-				IBeanTypeProxy type = argTypes[i] = typeFactory.getBeanTypeProxy(argumentClassNames[i]);
-				if (type == null)
-					return null; // Couldn't find the type.
-			}
-		}
-
-		return getConstructorProxy(argTypes);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		IREMMethodProxy getCtorMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassConstructor();
-
-		// Create the argument array
-		Object[] getParms = (argumentTypes != null) ? new Object[] { new TransmitableArray(Commands.CLASS_CLASS, argumentTypes)} : // Get Ctor has
-																																   // only one parm,
-																																   // the array of
-																																   // parm types.
-				null;
-
-		try {
-			return (IConstructorProxy) getCtorMethod.invokeWithParms(this, getParms);
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IConstructorProxy[] getConstructors() {
-
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		IREMMethodProxy getCtorMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassConstructors();
-
-		try {
-			IArrayBeanProxy ctors = (IArrayBeanProxy) getCtorMethod.invokeWithParms(this, null);
-			IBeanProxy[] proxies = ctors.getSnapshot();
-			IConstructorProxy[] ctorproxies = new IConstructorProxy[proxies.length];
-			System.arraycopy(proxies, 0, ctorproxies, 0, proxies.length);
-			return ctorproxies;
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(java.lang.String[])
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames) {
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		// Turn class names into array of BeanTypes.
-		IBeanTypeProxy[] argTypes = null;
-		if (argumentClassNames != null) {
-			IStandardBeanTypeProxyFactory typeFactory = fRegistry.getBeanTypeProxyFactory();
-			argTypes = new IBeanTypeProxy[argumentClassNames.length];
-			for (int i = 0; i < argumentClassNames.length; i++) {
-				IBeanTypeProxy type = argTypes[i] = typeFactory.getBeanTypeProxy(argumentClassNames[i]);
-				if (type == null)
-					return null; // Couldn't find the type.
-			}
-		}
-
-		return getDeclaredConstructorProxy(argTypes);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		IREMMethodProxy getCtorMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getDeclaredClassConstructor();
-
-		// Create the argument array
-		Object[] getParms = (argumentTypes != null) ? new Object[] { new TransmitableArray(Commands.CLASS_CLASS, argumentTypes)} : // Get Ctor has
-																																   // only one parm,
-																																   // the array of
-																																   // parm types.
-				null;
-
-		try {
-			return (IConstructorProxy) getCtorMethod.invokeWithParms(this, getParms);
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IConstructorProxy[] getDeclaredConstructors() {
-
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		IREMMethodProxy getCtorMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getDeclaredClassConstructors();
-
-		try {
-			IArrayBeanProxy ctors = (IArrayBeanProxy) getCtorMethod.invokeWithParms(this, null);
-			IBeanProxy[] proxies = ctors.getSnapshot();
-			IConstructorProxy[] ctorproxies = new IConstructorProxy[proxies.length];
-			System.arraycopy(proxies, 0, ctorproxies, 0, proxies.length);
-			return ctorproxies;
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IFieldProxy[] getFields() {
-
-		IREMMethodProxy getFieldsMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassGetFields();
-
-		try {
-			IArrayBeanProxy fields = (IArrayBeanProxy) getFieldsMethod.invokeWithParms(this, null);
-			IBeanProxy[] proxies = fields.getSnapshot();
-			IFieldProxy[] fieldProxies = new IFieldProxy[proxies.length];
-			System.arraycopy(proxies, 0, fieldProxies, 0, proxies.length);
-			return fieldProxies;
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IFieldProxy[] getDeclaredFields() {
-
-		IREMMethodProxy getDeclaredFieldsMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassGetDeclaredFields();
-
-		try {
-			IArrayBeanProxy fields = (IArrayBeanProxy) getDeclaredFieldsMethod.invokeWithParms(this, null);
-			IBeanProxy[] proxies = fields.getSnapshot();
-			IFieldProxy[] fieldProxies = new IFieldProxy[proxies.length];
-			System.arraycopy(proxies, 0, fieldProxies, 0, proxies.length);
-			return fieldProxies;
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getDeclaredFieldProxy(java.lang.String)
-	 */
-	public IFieldProxy getDeclaredFieldProxy(String fieldName) {
-		return (IFieldProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassGetDeclaredField().invokeCatchThrowableExceptions(this,
-				fRegistry.getBeanProxyFactory().createBeanProxyWith(fieldName));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getFieldProxy(java.lang.String)
-	 */
-	public IFieldProxy getFieldProxy(String fieldName) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getFieldProxy(this,fieldName);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String)
-	 */
-	public IProxyField getFieldProxy(IExpression expression, String fieldName) {
-		REMProxyFactoryRegistry registry = (REMProxyFactoryRegistry) expression.getRegistry();
-		return ((REMMethodProxyFactory) registry.getMethodProxyFactory()).getFieldProxy(expression, this, fieldName);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IMethodProxy[] getMethods() {
-
-		IREMMethodProxy getMethodsMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassMethods();
-
-		try {
-			IArrayBeanProxy methods = (IArrayBeanProxy) getMethodsMethod.invokeWithParms(this, null);
-			IBeanProxy[] proxies = methods.getSnapshot();
-			IMethodProxy[] methodProxies = new IMethodProxy[proxies.length];
-			System.arraycopy(proxies, 0, methodProxies, 0, proxies.length);
-			return methodProxies;
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IMethodProxy[] getDeclaredMethods() {
-
-		IREMMethodProxy getDeclaredMethodsMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassDeclaredMethods();
-
-		try {
-			IArrayBeanProxy methods = (IArrayBeanProxy) getDeclaredMethodsMethod.invokeWithParms(this, null);
-			IBeanProxy[] proxies = methods.getSnapshot();
-			IMethodProxy[] methodProxies = new IMethodProxy[proxies.length];
-			System.arraycopy(proxies, 0, methodProxies, 0, proxies.length);
-			return methodProxies;
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String)
-	 */
-	public IMethodProxy getMethodProxy(String methodName) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getMethodProxy(this,methodName,(String[])null);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, java.lang.String[])
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getMethodProxy(this,methodName,argumentClassNames);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameterTypes) {
-		REMProxyFactoryRegistry registry = (REMProxyFactoryRegistry) expression.getRegistry();
-		return ((REMMethodProxyFactory) registry.getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes) {
-		REMProxyFactoryRegistry registry = (REMProxyFactoryRegistry) expression.getRegistry();
-		return ((REMMethodProxyFactory) registry.getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes);
-	}
-
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName) {
-		return getMethodProxy(expression, methodName, (IProxyBeanType[]) null);
-	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, java.lang.String)
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String argumentQualifiedTypeName) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getMethodProxy(this,methodName,new String[] {argumentQualifiedTypeName});
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getMethodProxy(this,methodName,argumentTypes);
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(java.lang.String[])
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames) {
-
-		// Turn class names into array of BeanTypes.
-		IBeanTypeProxy[] argTypes = null;
-		if (argumentClassNames != null) {
-			IStandardBeanTypeProxyFactory typeFactory = fRegistry.getBeanTypeProxyFactory();
-			argTypes = new IBeanTypeProxy[argumentClassNames.length];
-			for (int i = 0; i < argumentClassNames.length; i++) {
-				IBeanTypeProxy type = argTypes[i] = typeFactory.getBeanTypeProxy(argumentClassNames[i]);
-				if (type == null)
-					return null; // Couldn't find the type.
-			}
-		}
-
-		return getDeclaredMethodProxy(methodName, argTypes);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		IREMMethodProxy getDeclaredMethodMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassDeclaredMethod();
-		IBeanProxy nameProxy = fRegistry.getBeanProxyFactory().createBeanProxyWith(methodName);
-		// Create the argument array
-		Object[] getParms = (argumentTypes != null) ? new Object[] { nameProxy, new TransmitableArray(Commands.CLASS_CLASS, argumentTypes)} : new Object[] {nameProxy, null};
-
-		try {
-			return (IMethodProxy) getDeclaredMethodMethod.invokeWithParms(this, getParms);
-		} catch (ThrowableProxy e) {
-			fRegistry.releaseProxy(e);
-			return null;
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String)
-	 */
-	public IInvokable getInvokable(String methodName) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getInvokable(this,methodName,(String[])null);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, java.lang.String[])
-	 */
-	public IInvokable getInvokable(String methodName, String[] argumentClassNames) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getInvokable(this,methodName,argumentClassNames);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, java.lang.String)
-	 */
-	public IInvokable getInvokable(String methodName, String argumentQualifiedTypeName) {
-		return getInvokable(methodName, new String[] { argumentQualifiedTypeName});
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IInvokable getInvokable(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).proxyConstants.getInvokable(this,methodName,argumentTypes);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getNullConstructorProxy()
-	 */
-	public IConstructorProxy getNullConstructorProxy() {
-		return getConstructorProxy((IBeanTypeProxy[]) null);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#getProxyFactoryRegistry()
-	 */
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fRegistry;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getSuperBeanTypeProxy()
-	 */
-	public IBeanTypeProxy getSuperBeanTypeProxy() {
-		return fSuperType;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getTypeName()
-	 */
-	public String getTypeName() {
-		return fClassname;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isArray()
-	 */
-	public boolean isArray() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isInterface()
-	 */
-	public boolean isInterface() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isPrimitive()
-	 */
-	public boolean isPrimitive() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isKindOf(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy)
-	 */
-	public boolean isKindOf(IBeanTypeProxy aBeanProxyType) {
-		return ((IBooleanBeanProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getClassIsAssignableFrom().invokeCatchThrowableExceptions(
-				aBeanProxyType, this)).booleanValue();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance(java.lang.String)
-	 */
-	public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-		try {
-			return ((REMStandardBeanProxyFactory) fRegistry.getBeanProxyFactory()).createBeanProxy(this, initializationString);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			return null;
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		return super.toString() + "(" + getTypeName() + ")"; //$NON-NLS-2$//$NON-NLS-1$
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#getTypeProxy()
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).classClass;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#toBeanString()
-	 */
-	public String toBeanString() {
-		return getTypeName();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance()
-	 */
-	public IBeanProxy newInstance() throws ThrowableProxy {
-		return ((REMStandardBeanProxyFactory) fRegistry.getBeanProxyFactory()).createBeanProxy(this);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanProxy#renderBean(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void renderBean(Commands.ValueObject value) {
-		value.setObjectID(getID().intValue());
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getFormalTypeName()
-	 */
-	public String getFormalTypeName() {
-		return getTypeName();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInitializationError()
-	 */
-	public String getInitializationError() {
-		return null; // By default none have an initialization error. There is a special instance for init errors.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) throws NoSuchMethodException, AmbiguousMethodException {
-		if (isInterface())
-			return null; // Interfaces don't have ctor's.
-
-		IREMMethodProxy findCompatibleMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getFindCompatibleConstructorMethod();
-
-		// Create the argument array
-		Object[] getParms = (argumentTypes != null) ? new Object[] { this, new TransmitableArray(Commands.CLASS_CLASS, argumentTypes)} : new Object[] {this, null};
-
-		try {
-			return (IConstructorProxy) findCompatibleMethod.invokeWithParms(this, getParms);
-		} catch (ThrowableProxy e) {
-			try {
-				if (e.getTypeProxy().equals(fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy("java.lang.NoSuchMethodException"))) //$NON-NLS-1$
-					throw new NoSuchMethodException(e.getProxyLocalizedMessage());
-				else if (e.getTypeProxy().equals(fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy("org.eclipse.jem.internal.proxy.common.AmbiguousMethodException"))) //$NON-NLS-1$
-					throw new AmbiguousMethodException(e.getProxyLocalizedMessage());
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				return null;
-			} finally {
-				fRegistry.releaseProxy(e);
-			}
-		}
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) throws NoSuchMethodException, AmbiguousMethodException {
-
-		IREMMethodProxy findCompatibleMethod = (IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getFindCompatibleMethodMethod();
-		IBeanProxy methodNameProxy = fRegistry.getBeanProxyFactory().createBeanProxyWith(methodName);
-
-		// Create the argument array
-		Object[] getParms = (argumentTypes != null) ? new Object[] { this, methodNameProxy, new TransmitableArray(Commands.CLASS_CLASS, argumentTypes)} : new Object[] {this, methodNameProxy, null};
-
-		try {
-			return (IMethodProxy) findCompatibleMethod.invokeWithParms(this, getParms);
-		} catch (ThrowableProxy e) {
-			try {
-				if (e.getTypeProxy().equals(fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy("java.lang.NoSuchMethodException"))) //$NON-NLS-1$
-					throw new NoSuchMethodException(e.getProxyLocalizedMessage());
-				else if (e.getTypeProxy().equals(fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy("org.eclipse.jem.internal.proxy.common.AmbiguousMethodException"))) //$NON-NLS-1$
-					throw new AmbiguousMethodException(e.getProxyLocalizedMessage());
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				return null;
-			} finally {
-				fRegistry.releaseProxy(e);
-			}
-		}
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractNumberBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractNumberBeanTypeProxy.java
deleted file mode 100644
index fa0c749..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAbstractNumberBeanTypeProxy.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMAbstractNumberBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Abstract class for any of the number bean type subclasses.
- * NOTE: This does not represent the beantype Number. It is a
- * class that provides functions for Number subclass beantypes.
- * The Number beantype itself is simply a REMBeanTypeProxy since
- * Number is abstract and has no necessary extra function.
- * Creation date: (08/31/00 11:49:12 AM)
- * @author: Administrator
- */
-public abstract class REMAbstractNumberBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMConstantBeanTypeProxy {
-
-protected REMAbstractNumberBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-	super(aRegistry, anID, aClassname, aSuperType);
-}
-/**
- * Helper to create a bean proxy
- * protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-protected abstract INumberBeanProxy createNumberBeanProxy(Number aNumber);
-
-/**
- * Create a new bean proxy with the specified id.
- *
- * For all of the Number types, this is an invalid operation. They are created
- * explicitly through the appropriate create method.
- */
-public IREMBeanProxy newBeanProxy(Integer anID) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the Number types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Each beantype will return a default value (usually a value of 0).
- */
-public abstract IBeanProxy newInstance() throws ThrowableProxy;
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAccessibleObjectProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAccessibleObjectProxy.java
deleted file mode 100644
index f7e9336..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAccessibleObjectProxy.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMAccessibleObjectProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.IAccessibleObjectProxy;
-import org.eclipse.jem.internal.proxy.core.ThrowableProxy;
- 
-/**
- * AccessibleObject Proxy.
- * 
- * @since 1.0.0
- */
-public class REMAccessibleObjectProxy extends REMAbstractBeanProxy implements IAccessibleObjectProxy {
-
-	protected REMAccessibleObjectProxy(REMProxyFactoryRegistry aRegistry, Integer anID) {
-		super(aRegistry, anID);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IAccessibleObjectProxy#isAccessible()
-	 */
-	public boolean isAccessible() throws ThrowableProxy {
-		return ((IBooleanBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getAccessibleIsAccessible().invoke(this)).booleanValue();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IAccessibleObjectProxy#setAccessible(boolean)
-	 */
-	public void setAccessible(boolean flag) throws ThrowableProxy {
-		REMStandardBeanProxyConstants.getConstants(fFactory).getAccessibleSetAccessible().invoke(this, fFactory.getBeanProxyFactory().createBeanProxyWith(flag));
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#getTypeProxy()
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMMethodProxyFactory) fFactory.getMethodProxyFactory()).accessibleType;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAnAbstractBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAnAbstractBeanTypeProxy.java
deleted file mode 100644
index c8baf18..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMAnAbstractBeanTypeProxy.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMAnAbstractBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * This is a proxy for an abstract bean type. I.e. you can't create a new instance of it.
- * It can be used as a general abstract type. It will pass newBeanTypeForClass unto
- * the main super type passed in.
- */
- 
-public class REMAnAbstractBeanTypeProxy extends REMAbstractBeanTypeProxy {
-
-	protected IREMSpecialBeanTypeProxy fMainSuperType;	// The type that this was created from so that
-							// any non-abstract subclasses can create the correct
-							// type of beantype proxy.
-					
-	public REMAnAbstractBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType, IREMSpecialBeanTypeProxy aType) {
-		super(aRegistry, anID, aClassname, aSuperType);
-		fMainSuperType = aType;
-	}
-	
-	/**
-	 * Create a new bean proxy with the specified id.
-	 *
-	 * For all of the abstract types, this is an invalid operation. 
-	 */
-	public IREMBeanProxy newBeanProxy(Integer anID) {
-		throw new UnsupportedOperationException();
-	}	
-	
-	/**
-	 * Note: Since new instances of abstract classes can never be done,
-	 * this function is not supported.
-	 */
-	public IBeanProxy newInstance() { 
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return fMainSuperType.newBeanTypeForClass(anID, aClassname, anAbstract, this);
-	}
-	
-	/**
-	 * release - BeanType is about to be released.
-	 * Clear the fMainSupertype (supertype is cleared so that
-	 * it won't hold onto it and will let the supertype be GC'd
-	 * if necessary.
-	 */
-	public void release() {
-		fMainSuperType = null;
-		super.release();
-	}					
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMArrayBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMArrayBeanProxy.java
deleted file mode 100644
index 81533aa..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMArrayBeanProxy.java
+++ /dev/null
@@ -1,253 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMArrayBeanProxy.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.lang.reflect.Array;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.CommandErrorException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * IDE VM version of the Array proxy
- */
-
-public final class REMArrayBeanProxy extends REMBeanProxy implements IArrayBeanProxy {
-	private int fLength = -1;
-	
-	REMArrayBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType) {
-		super(aRegistry, anID, aType);
-	}
-
-
-	/**
-	 * Get the object at the specified index.
-	 */
-	public IBeanProxy get(int index) throws ThrowableProxy {
-		// Format of getter parms is: (Object (array), int (index)).
-		Object[] parms = new Object[] {this, new Integer(index)};
-		// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
-		// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-		IBeanTypeProxy compType = ((IArrayBeanTypeProxy) getTypeProxy()).getComponentType();
-		if (!compType.isPrimitive()) {
-			// Use standard getter.
-			return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGet()).invokeWithParms(null, parms);
-		} else {
-			// Use the correct primitive getter.
-			int id = ((IREMBeanProxy) compType).getID().intValue();
-			switch (id) {
-				case Commands.BYTE_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetByte()).invokeWithParms(null, parms);
-				case Commands.BOOLEAN_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetBoolean()).invokeWithParms(null, parms);
-				case Commands.CHARACTER_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetChar()).invokeWithParms(null, parms);
-				case Commands.DOUBLE_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetDouble()).invokeWithParms(null, parms);
-				case Commands.FLOAT_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetFloat()).invokeWithParms(null, parms);
-				case Commands.INTEGER_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetInt()).invokeWithParms(null, parms);
-				case Commands.LONG_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetLong()).invokeWithParms(null, parms);
-				case Commands.SHORT_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetShort()).invokeWithParms(null, parms);
-			}
-		}
-		
-		return null;
-	}
-
-	/**
-	 * Get the object at the specified multi-dimensional index.
-	 * The array must be at least the number of dimensions specified,
-	 * and each index along the way must exist.
-	 * The number of dimensions can't be greater than the number
-	 * of dimensions of the real object.
-	 */
-	public IBeanProxy get(int [] indexes) throws ThrowableProxy {
-		// Format of getter parms is: (Object (array), int[] (indexes)).
-		Object[] parms = new Object[] {this, indexes};
-		// If the component type at the specified dimension is primitive, we need to use the correct getter so that a valid value is returned,
-		// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-		int dims = ((IArrayBeanTypeProxy) getTypeProxy()).getDimensions();
-		if (dims < indexes.length)
-			throw new IllegalArgumentException();	// Too many dimensions
-		IBeanTypeProxy finalCompType = ((IArrayBeanTypeProxy) getTypeProxy()).getFinalComponentType();			
-		if (dims == indexes.length && finalCompType.isPrimitive()) {
-			// Use the correct primitive getter because we are accessing the final component and it is primitive.
-			int id = ((IREMBeanProxy) finalCompType).getID().intValue();
-			switch (id) {
-				case Commands.BYTE_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetByte()).invokeWithParms(null, parms);
-				case Commands.BOOLEAN_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetBoolean()).invokeWithParms(null, parms);
-				case Commands.CHARACTER_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetChar()).invokeWithParms(null, parms);
-				case Commands.DOUBLE_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetDouble()).invokeWithParms(null, parms);
-				case Commands.FLOAT_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetFloat()).invokeWithParms(null, parms);
-				case Commands.INTEGER_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetInt()).invokeWithParms(null, parms);
-				case Commands.LONG_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetLong()).invokeWithParms(null, parms);
-				case Commands.SHORT_TYPE:
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGetShort()).invokeWithParms(null, parms);
-			}
-		} else {
-			// It is not the final component, or it is not primitive, use the standard accessor.
-			return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperGet()).invokeWithParms(null, parms);
-		}
-		
-		return null;
-	}
-	
-	/**
-	 * Set the object at the specified index.
-	 */
-	public void set(IBeanProxy value, int index) throws ThrowableProxy {
-		// Format of setter parms is: (Object (array), int (index), Object (value)).
-		Object[] parms = new Object[] {this, new Integer(index), value};
-		((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArraySet()).invokeWithParms(null, parms);
-	}
-		
-	/**
-	 * Set the object at the specified multi-dimensional index.
-	 * The array must be at least the number of dimensions specified,
-	 * and each index along the way must exist.
-	 * The number of dimensions can't be greater than the number
-	 * of dimensions of the real object.
-	 */
-	public void set(IBeanProxy value, int [] indexes) throws ThrowableProxy {
-		// Format of setter parms is: (Object (array), int[] (indexes), Object (value)).
-		Object[] parms = new Object[] {this, indexes, value};
-		((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayHelperSet()).invokeWithParms(null, parms);
-	}
-	
-	/**
-	 * Get the length of the first dimension of this array.
-	 * If there are multi-dimensions, you must get the appropriate
-	 * dimension from the get method to see the size of that dimension.
-	 *
-	 * e.g.
-	 *    int [3] returns 3
-	 *    int [3][2] returns 3
-	 *
-	 *    ((IArrayBeanProxy) get(1)).getLength() returns 2
-	 *    Since arrays do not have to be homogenous, there could
-	 *    be a different length array for each of the arrays 
-	 *    returned from the first dimension, the returned length
-	 *    from get(2) and get(3) could result in a different value
-	 *    from get(1).
-	 */
-	public int getLength() {
-		if (fLength == -1) {
-			// It hasn't yet been quiered.
-			fLength = ((IIntegerBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getArrayGetLength().invokeCatchThrowableExceptions(null, this)).intValue();
-		}
-		return fLength;
-	}	
-	
-	public IBeanProxy getCatchThrowableException(int index){
-		try {
-			return get(index);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e));		 //$NON-NLS-1$
-			fFactory.releaseProxy(e);	// Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}		
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IArrayBeanProxy#getSnapshot()
-	 */
-	public IBeanProxy[] getSnapshot() throws ThrowableProxy {
-		IREMConnection connect = fFactory.getFreeConnection();
-		REMStandardBeanProxyFactory proxyFactory = (REMStandardBeanProxyFactory) fFactory.getBeanProxyFactory();
-		proxyFactory.startTransaction(); // This is definately a transaction, so start it.
-		try {
-			Commands.ValueObject returnValue = new Commands.ValueObject();
-			try {
-				try {
-					connect.getArrayContents(getID().intValue(), returnValue);
-					return processReturnValue(connect, returnValue);
-				} catch (CommandErrorException e) {
-					proxyFactory.processErrorReturn(e);
-				}
-			} catch (CommandException e) {
-				if (!e.isRecoverable()) {
-					// Close the connection and try again.
-					fFactory.closeConnection(connect);
-					connect = null;
-					connect = fFactory.getFreeConnection();
-					try {
-						connect.getArrayContents(getID().intValue(), returnValue);
-						return processReturnValue(connect, returnValue);
-					} catch (CommandException eAgain) {
-						// Failed again. Just close and print trace.
-						fFactory.closeConnection(connect);
-						connect = null;
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
-						return null;
-					}
-				} else {
-					// A recoverable error, print trace and return
-					ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-					return null;
-				}
-			}
-		} finally {
-			proxyFactory.stopTransaction();
-			if (connect != null)
-				fFactory.returnConnection(connect);
-		}
-		return null;
-	}
-
-
-	/*
-	 * @param returnValue
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	private IBeanProxy[] processReturnValue(IREMConnection connection, ValueObject returnValue) throws CommandException, ThrowableProxy {
-		// It is an array containing IDs, as it normally would be.
-		// However it will become IBeanProxy[]. That is because if ID's
-		// they must be proxies over here.
-		BeanProxyValueSender valueSender = new BeanProxyValueSender((REMStandardBeanProxyFactory) fFactory.getBeanProxyFactory(), returnValue);
-		connection.readProxyArrayValues(returnValue, valueSender, false);
-		Exception e = valueSender.getException();
-		if (e != null) {
-			if (e instanceof ThrowableProxy)
-				throw (ThrowableProxy) e;
-			else
-				throw (CommandException) e;
-		}
-		Object vals = valueSender.getArray();
-		IBeanProxy[] proxyArray = new IBeanProxy[Array.getLength(vals)];
-		System.arraycopy(vals, 0, proxyArray, 0, proxyArray.length);
-		return proxyArray;
-	}
-	
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMArrayBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMArrayBeanTypeProxy.java
deleted file mode 100644
index 36e40a8..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMArrayBeanTypeProxy.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMArrayBeanTypeProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-
-import org.eclipse.jem.internal.proxy.common.MapTypes;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Array Type Proxy for the IDE VM.
- *
- * The class is final because array's are special and shouldn't have
- * any subclasses since the factory would never call it.
- */
-
-public final class REMArrayBeanTypeProxy extends REMAbstractBeanTypeProxy implements IArrayBeanTypeProxy {
-	
-	/**
-	 * Create with a registry and a class. It is package so that only 
-	 * the factory with this IDE package can call it.
-	 */
-	protected REMArrayBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy objectType) {
-		super(aRegistry, anID, aClassname, objectType);
-	}
-	/**
-	 * This is an array type!
-	 */
-	public boolean isArray() {
-		return true;
-	}
-	/**
-	 * Return the final component type.
-	 */
-	public IBeanTypeProxy getFinalComponentType() {
-		// Component type is strip off all '[' and return class name (if we ever add classLoader support, this won't work).
-		// However, if the type is a primitive we need to go through the change table).
-		int typeStart = getTypeName().lastIndexOf('[')+1;
-		if (getTypeName().charAt(typeStart) == 'L') {
-			// It is a class.
-			// Strip off up to the 'L', and the trailing ';'. That is the class name.
-			return fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(getTypeName().substring(typeStart+1, getTypeName().length()-1));
-		} else {
-			// It is a type. Need to map it.
-			Class aType = (Class) MapTypes.MAP_SHORTSIG_TO_TYPE.get(getTypeName().substring(typeStart, typeStart+1));
-			return aType != null ? fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(aType.getName()) : null;
-		}
-	}
-	
-	/**
-	 * Return the component type.
-	 */
-	public IBeanTypeProxy getComponentType() {
-		// Component type is strip off first '[' and return class name (if we ever add classLoader support, this won't work).
-		// However, if the type is a primitive we need to go through the change table).
-		if (getTypeName().charAt(1) != '[') {
-			// It is a one dimensional array, just send to getFinalComponentType to figure out the type.
-			return getFinalComponentType();
-		} else {
-			// It is a multi-dimensional array. Just strip off one '[' and send that to the bean type factory.
-			return fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(getTypeName().substring(1));
-		}
-	}
-	/**
-	 * Return the number of dimensions.
-	 */
-	public int getDimensions() {
-		return getTypeName().lastIndexOf('[')+1;
-	}
-	
-	/**
-	 * Create a new bean proxy with the specified object
-	 * Use the constructor that allows the type proxy to be set as well as the bean
-	 * because we are the type and by setting it now we might avoid it being lookup for in the
-	 * factory the first time it is asked for.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer anID) {
-		return new REMArrayBeanProxy(fRegistry, anID, this);
-	}
-	
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * Arrays can't be subclassed.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the null ctor proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */		
-	public IConstructorProxy getNullConstructorProxy() {	
-		throw new UnsupportedOperationException();
-	}
-		
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy[] getConstructors() {
-		throw new UnsupportedOperationException();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy[] getDeclaredConstructors() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes) {	
-		throw new UnsupportedOperationException();
-	}	
-	
-	/**
-	 * Return a proxy to the field for the target VM being the same as the REM
-	 * For all of the array types, this is an invalid operation.	 
-	 */	
-	public IFieldProxy getFieldProxy(String fieldName) {	
-		throw new UnsupportedOperationException();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the array types, this is an invalid operation.
-	 */
-	public IFieldProxy[] getFields() {
-		throw new UnsupportedOperationException();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the array types, this is an invalid operation.
-	 */
-	public IFieldProxy[] getDeclaredFields() {
-		throw new UnsupportedOperationException();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy[] getMethods() {
-		throw new UnsupportedOperationException();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy[] getDeclaredMethods() {
-		throw new UnsupportedOperationException();
-	}
-
-	
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-		
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-		
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}	
-	
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */	
-	public IMethodProxy getMethodProxy(String methodName, String argumentQualifiedTypeName) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the array types, this is an invalid operation.	 
-	 */		
-	public IMethodProxy getMethodProxy(String methodName) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Create an array bean proxy.
-	 *
-	 *   - (int, new int[2] {3, 4}) will create:
-	 *      int [3] [4]
-	 *
-	 *   - (int[], new int[1] {1})
-	 *      int [1]
-	 *
-	 *   - (int[], new int[2] {2,3})
-	 *      int [2] [3]
-	 * 
-	 *
-	 *   - (int[], null) or (int[], new int[0]) or (int, null) or (int, new int[0])
-	 *      int [0]
-	 *     (int[][], null) or (int[][], new int[0])
-	 *      int[0][]
-	 *     This is because an array instance with no dimensions specified is not valid. 
-	 *
-	 *   - (int[][], new int[1] {3})
-	 *      int[3][]
-	 *
-	 * It is package protected so that only the REM Factory can call it.
-	 */
-	REMArrayBeanProxy  createBeanProxyWith(int[] dimensions) throws ThrowableProxy {
-		// If the dimensions is null or zero length, then create the
-		// array as a 0 sized array one dimensional array.
-		if (dimensions == null || dimensions.length == 0)
-			return createBeanProxyWith(new int[] {0});
-			
-		// Remove from this type the number of dimensions specified
-		// coming in, up to but no further than the final component.
-		// From here we can then use the appropriate java.lang.reflect.Array
-		// method to create the array.
-		IBeanTypeProxy compType = null;	// The type of array to create (it may be different number of dimensions).
-		int numDims = getDimensions();
-		if (numDims <= dimensions.length)
-			compType = getFinalComponentType();	// There are the same or more requested dimensions, so use final component type
-		else {
-			// There are fewer requested dimensions, so strip off that many
-			String compClass = getTypeName().substring(dimensions.length);
-			compType = fRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(compClass);
-		}
-		
-		if (dimensions.length == 1) {
-			// Use the one dimension call
-			Object[] parms = new Object[] {compType, new Integer(dimensions[0])};
-			return (REMArrayBeanProxy) ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getArrayNewInstanceOneDimension()).invokeWithParms(null, parms);
-		} else {
-			// Use the multi dimension call
-			Object[] parms = new Object[] {compType, dimensions};
-			return (REMArrayBeanProxy) ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fRegistry).getArrayNewInstanceMultiDimension()).invokeWithParms(null, parms);
-		}
-	}
-		
-	/**
-	 * @see IBeanTypeProxy#getFormalTypeName()
-	 */
-	public String getFormalTypeName() {
-		String name = getTypeName();
-		int dims = name.lastIndexOf('[') + 1;
-		String type = getFinalComponentType().getTypeName();
-		StringBuffer formalType = new StringBuffer(type.length()+("[]".length()*dims)); //$NON-NLS-1$
-		formalType.append(type);
-		for (int i=0; i<dims; i++)
-			formalType.append("[]"); //$NON-NLS-1$
-		return formalType.toString();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBeanProxy.java
deleted file mode 100644
index 03b23d0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBeanProxy.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Standard implementation of IREMBeanProxy
- */
-
-public class REMBeanProxy extends REMAbstractBeanProxy {
-	private IBeanTypeProxy fType;
-
-	protected REMBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType){
-		super(aRegistry, anID);
-		fType = aType;
-	}
-	
-	public IBeanTypeProxy getTypeProxy() {
-		return fType;
-	}
-	
-	public void release() {
-		fType = null;
-		super.release();
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBeanTypeProxy.java
deleted file mode 100644
index 11afbf2..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBeanTypeProxy.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-/**
- * Default implementation for a BeanTypeProxy. This is what is used
- * for regular default beans and beantypes when no special beans or bean types are needed.
- */
-public class REMBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMSpecialBeanTypeProxy {
-
-	/**
-	 * Create with a registry and a class. It is protected so that only subclasses
-	 * and the factory with this REM package can call it.
-	 */
-	public REMBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-		super(aRegistry, anID, aClassname, aSuperType);
-	}
-
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * NOTE: All subclasses must override this to return the correct type of BeanTypeProxy.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return newBeanTypeForClass(anID, aClassname, anAbstract, this);
-	}
-
-	/**
-	 * The special method to handle subclassing from an abstract).
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract, IBeanTypeProxy superType) {
-		if (!anAbstract) 
-			return new REMBeanTypeProxy(fRegistry, anID, aClassname, superType);
-		else
-			return new REMAnAbstractBeanTypeProxy(fRegistry, anID, aClassname, superType, this);
-	}
-	
-	/**
-	 * Create a new bean proxy with the specified id.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer anID){
-	
-		return new REMBeanProxy(fRegistry, anID, this);
-	
-	}
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigDecimalBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigDecimalBeanProxy.java
deleted file mode 100644
index fe796af..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigDecimalBeanProxy.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBigDecimalBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import java.math.BigDecimal;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Proxy for BigDecimals.
- */
-class REMBigDecimalBeanProxy extends REMNumberBeanProxy {
-
-REMBigDecimalBeanProxy(REMProxyFactoryRegistry aRegistry, BigDecimal aBigDecimal) {
-	super(aRegistry, aBigDecimal);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).bigDecimalClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(numberValue(), ((IREMBeanTypeProxy) getTypeProxy()).getID().intValue());
-}	
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigDecimalBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigDecimalBeanTypeProxy.java
deleted file mode 100644
index fa6045a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigDecimalBeanTypeProxy.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBigDecimalBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import java.math.BigDecimal;
-/**
- * Remote Implementation of IBeanTypeProxy for BigDecimal.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMBigDecimalBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final static BigDecimal zeroValue = new BigDecimal(0D);
-
-REMBigDecimalBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.BIG_DECIMAL_CLASS), BigDecimal.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMBigDecimalBeanProxy(aRegistry, zeroValue);	
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createBigDecimalBeanProxy(BigDecimal aBigDecimal) {
-	return (!zeroValue.equals(aBigDecimal)) ?
-		new REMBigDecimalBeanProxy(fRegistry, aBigDecimal) : zeroProxy;
-}
-
-/**
- * Generic way to create an BigDecimal proxy, however, the Number must be a BigDecimal.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createBigDecimalBeanProxy((BigDecimal) aNumber);
-}
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createBigDecimalBeanProxy((BigDecimal) value.anObject);
-}	
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigIntegerBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigIntegerBeanProxy.java
deleted file mode 100644
index 8715b4e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigIntegerBeanProxy.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBigIntegerBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import java.math.BigInteger;
-/**
- * Remote Proxy for BigIntegers.
- */
-class REMBigIntegerBeanProxy extends REMNumberBeanProxy {
-
-REMBigIntegerBeanProxy(REMProxyFactoryRegistry aRegistry, BigInteger aBigInteger) {
-	super(aRegistry, aBigInteger);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).bigIntegerClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(numberValue(), ((IREMBeanTypeProxy) getTypeProxy()).getID().intValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigIntegerBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigIntegerBeanTypeProxy.java
deleted file mode 100644
index 341bc6e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBigIntegerBeanTypeProxy.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBigIntegerBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import java.math.BigInteger;
-/**
- * Remote Implementation of IBeanTypeProxy for BigInteger.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMBigIntegerBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final static BigInteger zeroValue = new BigInteger("0"); //$NON-NLS-1$
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMBigIntegerBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.BIG_INTEGER_CLASS), BigInteger.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMBigIntegerBeanProxy(aRegistry, zeroValue);	
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createBigIntegerBeanProxy(BigInteger aBigInteger) {
-	return (!zeroValue.equals(aBigInteger)) ?
-		new REMBigIntegerBeanProxy(fRegistry, aBigInteger) : zeroProxy;
-}
-
-/**
- * Generic way to create an BigInteger proxy, however, the Number must be a BigInteger.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createBigIntegerBeanProxy((BigInteger) aNumber);
-}	
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createBigIntegerBeanProxy((BigInteger) value.anObject);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanClassBeanProxy.java
deleted file mode 100644
index 94269d6..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanClassBeanProxy.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBooleanClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBooleanBeanProxy for Boolean.class.
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-final class REMBooleanClassBeanProxy extends REMConstantBeanProxy implements IBooleanBeanProxy {
-	private final Boolean fBooleanValue;
-
-/**
- * Store the boolean value so that we can return the booleanValue faster
- * without the need for going across the line. It is package protected because it is created in
- * special way, so no one else should create these.
- * @param aBean java.lang.Object
- */
-REMBooleanClassBeanProxy(REMProxyFactoryRegistry aRegistry, Boolean value) {
-	super(aRegistry);
-	fBooleanValue = value;
-}
-
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMBooleanClassBeanProxy)
-		return fBooleanValue.booleanValue() == ((REMBooleanClassBeanProxy) anObject).booleanValue();
-	if (anObject instanceof Boolean)
-		return fBooleanValue.booleanValue() == ((Boolean) anObject).booleanValue();
-	return false;
-}
-
-/**
- * Return the boolean value
- */
-public boolean booleanValue() {
-	return fBooleanValue.booleanValue();
-}
-/**
- * Return the java.lang.Boolean value
- */
-public Boolean getBooleanValue() {
-	return fBooleanValue;
-}
-
-/**
- * Return the toString of the bean itself.
- */
-public String toBeanString() {
-	return fBooleanValue.toString();
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).booleanClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fBooleanValue);
-}
-}
-
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanClassBeanTypeProxy.java
deleted file mode 100644
index 062fa26..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanClassBeanTypeProxy.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBooleanClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Boolean BeanType Proxy for Boolean.class. 
- * Creation date: (2/23/00 1:59:02 PM)
- * @author: Richard Lee Kulp
- */
-final class REMBooleanClassBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMConstantBeanTypeProxy {
-
-	// Cache these instances. Since the BeanType proxies are cached also, only one instance
-	// of true/false will be in system.
-	protected final IBooleanBeanProxy trueProxy;
-	protected final IBooleanBeanProxy falseProxy;
-/**
- * REMBooleanBeanTypeProxy constructor comment.
- */
-protected REMBooleanClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy objectType) {
-	super(aRegistry, new Integer(Commands.BOOLEAN_CLASS), Boolean.class.getName(), objectType);
-	
-	trueProxy = new REMBooleanClassBeanProxy( fRegistry, Boolean.TRUE);
-	falseProxy = new REMBooleanClassBeanProxy( fRegistry, Boolean.FALSE);	
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- * Use the cache.
- */
-IBooleanBeanProxy createBooleanBeanProxy(Boolean aBoolean) {
-	return aBoolean.booleanValue() ? trueProxy : falseProxy;
-}
-
-/**
- * Create a new bean proxy with the specified id.
- *
- * For all of the primitive wrapper types, this is an invalid operation. They are created
- * explicitly through the appropriate create method.
- */
-public IREMBeanProxy newBeanProxy(Integer anID) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the primitive wrapper types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newInstance method. Boolean doesn't have a default ctor, so the standard way won't work.
- * Return the falseProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return falseProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createBooleanBeanProxy(value.aBool ? Boolean.TRUE : Boolean.FALSE);
-}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanTypeBeanProxy.java
deleted file mode 100644
index 96a3740..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanTypeBeanProxy.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBooleanTypeBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of IBooleanBeanProxy for Boolean.TYPE.
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-final class REMBooleanTypeBeanProxy extends REMConstantBeanProxy implements IBooleanBeanProxy {
-	private final boolean fBoolean;
-
-/**
- * Store the boolean value so that we can return the booleanValue faster
- * without the need for going across the line. It is package protected because it is created in
- * special way, so no one else should create these.
- * @param aBean java.lang.Object
- */
-REMBooleanTypeBeanProxy(REMProxyFactoryRegistry aRegistry, boolean value) {
-	super(aRegistry);
-	fBoolean = value;
-}
-
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMBooleanTypeBeanProxy)
-		return fBoolean == ((REMBooleanTypeBeanProxy) anObject).booleanValue();
-	if (anObject instanceof Boolean)
-		return fBoolean == ((Boolean) anObject).booleanValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMBooleanTypeBeanProxy)
-		return fBoolean == ((REMBooleanTypeBeanProxy) aBeanProxy).booleanValue();
-	return false;
-}
-
-/**
- * Return the boolean value
- */
-public boolean booleanValue() {
-	return fBoolean;
-}
-/**
- * Return the java.lang.Boolean value
- */
-public Boolean getBooleanValue() {
-	return fBoolean ? Boolean.TRUE : Boolean.FALSE;
-}
-
-/**
- * Return the toString of the bean itself.
- */
-public String toBeanString() {
-	return fBoolean ? Boolean.TRUE.toString() : Boolean.FALSE.toString();
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).booleanType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fBoolean);
-}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanTypeBeanTypeProxy.java
deleted file mode 100644
index bf45c61..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMBooleanTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMBooleanTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Boolean BeanType Proxy for Boolean.TYPE
- * Creation date: (2/23/00 1:59:02 PM)
- * @author: Richard Lee Kulp
- */
-final class REMBooleanTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-
-	// Cache these instances. Since the BeanType proxies are cached also, only one instance
-	// of true/false will be in system.
-	protected final IBooleanBeanProxy trueProxy;
-	protected final IBooleanBeanProxy falseProxy;
-/**
- * REMBooleanBeanTypeProxy constructor comment.
- */
-protected REMBooleanTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.BOOLEAN_TYPE), Boolean.TYPE.getName());
-	
-	trueProxy = new REMBooleanTypeBeanProxy( fRegistry, true);
-	falseProxy = new REMBooleanTypeBeanProxy( fRegistry, false);	
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- * Use the cache.
- */
-IBooleanBeanProxy createBooleanBeanProxy(boolean aBoolean) {
-	return aBoolean ? trueProxy : falseProxy;
-}
-
-
-/**
- * newInstance method. boolean is a primitive, so the standard way won't work.
- * Return the falseProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return falseProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createBooleanBeanProxy(value.aBool);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteClassBeanProxy.java
deleted file mode 100644
index 3688ff9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteClassBeanProxy.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMByteClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * Remote Proxy for Byte.class.
- */
-class REMByteClassBeanProxy extends REMNumberBeanProxy {
-
-REMByteClassBeanProxy(REMProxyFactoryRegistry aRegistry, Byte aByte) {
-	super(aRegistry, aByte);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).byteClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set((Byte) numberValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteClassBeanTypeProxy.java
deleted file mode 100644
index 59bca7a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteClassBeanTypeProxy.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMByteClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * BeanType Proxy for Byte.class. 
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMByteClassBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final INumberBeanProxy oneProxy;
-	private final INumberBeanProxy twoProxy;
-	private final INumberBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMByteClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.BYTE_CLASS), Byte.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMByteClassBeanProxy(aRegistry, new Byte((byte)0));	
-	oneProxy = new REMByteClassBeanProxy(aRegistry, new Byte((byte)1));
-	twoProxy = new REMByteClassBeanProxy(aRegistry, new Byte((byte)2));
-	threeProxy = new REMByteClassBeanProxy(aRegistry, new Byte((byte)3));		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createByteBeanProxy(Byte aByte) {
-	switch(aByte.byteValue()) {
-		case 0: return zeroProxy;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new REMByteClassBeanProxy(fRegistry, aByte);
-	}
-}
-
-/**
- * Generic way to create an Integer proxy, however, the Number must be an Integer.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createByteBeanProxy((Byte) aNumber);
-}
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createByteBeanProxy(new Byte(value.aByte));
-}	
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteTypeBeanProxy.java
deleted file mode 100644
index 9b2ba2a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteTypeBeanProxy.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMByteTypeBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of INumberBeanProxy for Byte.TYPE.
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class REMByteTypeBeanProxy extends REMConstantBeanProxy implements INumberBeanProxy {
-	private final byte fByte;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMByteTypeBeanProxy(REMProxyFactoryRegistry aRegistry, byte aByte) {
-	super(aRegistry);
-	fByte = aByte;
-}
-
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMByteTypeBeanProxy)
-		return fByte == ((REMByteTypeBeanProxy) anObject).byteValue();
-	if (anObject instanceof Byte)
-		return fByte == ((Byte) anObject).byteValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMByteTypeBeanProxy)
-		return fByte == ((REMByteTypeBeanProxy) aBeanProxy).byteValue();
-	return false;
-}
-
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return fByte;
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fByte;
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fByte;
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return fByte;
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return fByte;
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return new Byte(fByte);
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return fByte;
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return String.valueOf(fByte);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).byteType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fByte);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteTypeBeanTypeProxy.java
deleted file mode 100644
index 9f5db70..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMByteTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMByteTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Byte.TYPE.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMByteTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final INumberBeanProxy oneProxy;
-	private final INumberBeanProxy twoProxy;
-	private final INumberBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMByteTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.BYTE_TYPE), Byte.TYPE.getName());
-	
-	// Create the cached values
-	zeroProxy = new REMByteTypeBeanProxy(aRegistry, (byte)0);	
-	oneProxy = new REMByteTypeBeanProxy(aRegistry, (byte)1);
-	twoProxy = new REMByteTypeBeanProxy(aRegistry, (byte)2);
-	threeProxy = new REMByteTypeBeanProxy(aRegistry, (byte)3);		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createByteBeanProxy(byte aByte) {
-	switch(aByte) {
-		case 0: return zeroProxy;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new REMByteTypeBeanProxy(fRegistry, aByte);
-	}
-}
-
-/**
- * newInstance method. byte is a primitive, so the standard way won't work.
- * Return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}	
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createByteBeanProxy(value.aByte);
-}
-
-/**
- * Short cut for newInstance where the string follows the
- * specific pattern we expect. That way it won't be necessary to ship over to the vm 
- * to process it.
- *
- * The pattern it can accept is:
- * 	1) (byte) validNumber - number can be any number because (byte) explicitly casts it down.
- *	2) validNumber
- * It will use the decode function of byte to determine the valid number.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	String trim = initializationString.trim();
-	if (trim.length() == 0)
-		return super.newInstance(initializationString);	
-	byte aByte;
-	if (trim.startsWith("(byte)")) { //$NON-NLS-1$
-		Number v = parseString(trim.substring("(byte)".length()).trim()); //$NON-NLS-1$
-		if (v != null)
-			aByte = v.byteValue();
-		else
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-	} else {
-		try {
-			aByte = Byte.decode(trim).byteValue();	// See if valid byte format.
-		} catch (NumberFormatException e) {
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-		}
-	}
-
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(aByte);
-}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackInputStream.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackInputStream.java
deleted file mode 100644
index 039b05d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackInputStream.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMCallbackInputStream.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.io.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.IOCommandException;
-/**
- * This is the inputstream used to return a lot of data from
- * the server.
- */
-
-public class REMCallbackInputStream extends InputStream {
-	
-	protected DataInputStream fIn;
-	protected DataOutputStream fOut;
-	protected byte[] fBuffer;
-	protected int fNextByte = 0;
-	protected int fLastByte = 0;
-	
-	public REMCallbackInputStream(DataInputStream in, DataOutputStream out) {
-		fIn = in;
-		fOut = out;
-		
-		Integer bufSize = Integer.getInteger("proxyvm.bufsize"); //$NON-NLS-1$
-		if (bufSize == null)
-			bufSize = new Integer(16000);		
-		fBuffer = new byte[bufSize.intValue()];
-	}
-	
-	protected void clearStream() {
-		fIn = null;
-		fOut = null;
-		fBuffer = null;
-	}
-	
-	protected void fillBuffer() throws IOException {
-		if (fIn == null)
-			throw new InterruptedIOException();
-		try {
-			if (fLastByte != -1) {
-				fLastByte = Commands.readBytes(fIn, fBuffer);
-				if (fLastByte != -1)
-					fNextByte = 0;
-				else {
-					fNextByte = -1;
-				}
-			}	
-		} catch (CommandException e) {
-			try {
-				close(false);
-			} catch (IOException e1) {
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e1));	// Error during close, just log it. //$NON-NLS-1$
-			}
-			throw new IOCommandException(e);
-		}
-	}
-			
-	public int read() throws IOException {
-		if (fNextByte >= fLastByte) {
-			fillBuffer();
-		}
-		if (fLastByte == -1)
-			return -1;	// We've previously reached the end.		
-		
-		return fBuffer[fNextByte++] & 0xFF;	// So that it is in range 0 to 255.
-	}
-	
-	public int read(byte b[], int off, int len) throws IOException {
-		if (b == null) {
-			throw new NullPointerException();
-		} else if ((off < 0) || (off > b.length) || (len < 0) ||
-			((off + len) > b.length) || ((off + len) < 0)) {
-			throw new IndexOutOfBoundsException();
-		} else if (len == 0) {
-			return 0;
-		}
-		
-		int read = 0;
-		while (len > 0) {
-			if (fNextByte >= fLastByte)
-				fillBuffer();
-			if (fLastByte == -1)
-				return read != 0 ? read : -1;	// No more, return amount read, or if none read, then -1
-			int move = fLastByte - fNextByte;
-			if (move > len)
-				move = len;
-			System.arraycopy(fBuffer, fNextByte, b, off, move);
-			read += move;
-			fNextByte += move;
-			off += move;
-			len -= move;
-		}
-		
-		return read;
-	}
-			
-	public int available() throws IOException {
-		return fLastByte != -1 ? fLastByte - fNextByte : 0;
-	}
-	
-	public void close() throws IOException {
-		close(true);
-	}
-	
-	protected void close(boolean wait) throws IOException {
-		if (fOut == null)
-			return;	// Already closed.
-		try {
-			fOut.writeByte(Commands.CALLBACK_STREAM_TERMINATE);
-			fOut.flush();
-			fOut = null;	// So that we know we closed already if error occurs during in read() below.
-			if (wait) {
-				// Need to read until End of stream because we need to flush out the
-				// stream so that next time we use this connection we start fresh.
-				// If the server has already finished writing, we will read until then.
-				// If the server has not yet finished writing, when it reads the terminate
-				// request it will send an end of stream marker for us to read. But either
-				// way we can't leave until we've read everything from the stream.
-				
-				// If called with no wait, then we are closing hard and will be closing the socket too.
-				while (read() != -1) {
-				}
-			}
-		} finally {
-			clearStream();
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackRegistry.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackRegistry.java
deleted file mode 100644
index df52619..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackRegistry.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMCallbackRegistry.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.net.Socket;
-import java.util.*;
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
-
-/**
- * This registry will handle callbacks.
- * It is package protected because no one
- * should access it outside.
- */
-class REMCallbackRegistry implements ICallbackRegistry {
-	final REMProxyFactoryRegistry fFactory;
-	final String fNamePostfix;
-	List fThreads = Collections.synchronizedList(new LinkedList());	// List of active callback threads.	
-	
-	Map fIdToCallback = new HashMap(5);	// ID to Callback map.
-	Map fCallbackProxyToId = new HashMap(5);	// Callback to ID map. This will also hold onto the callback proxies so that they don't get GC'd while the callback is registered.
-		
-	IREMMethodProxy fInitializeCallback;
-	IBeanProxy fRemoteServer;
-	
-	boolean registryOpen = true;
-	
-	public REMCallbackRegistry(String name, REMProxyFactoryRegistry aFactory) {
-	
-		fFactory = aFactory;
-		fNamePostfix = name;
-		
-		// Now register common proxies.
-		IREMBeanTypeProxy callbackType = new REMInterfaceBeanTypeProxy(fFactory, new Integer(Commands.ICALLBACK_CLASS), "org.eclipse.jem.internal.proxy.vm.remote.ICallback"); //$NON-NLS-1$
-	
-		fInitializeCallback = (IREMMethodProxy) ((REMMethodProxyFactory) fFactory.getMethodProxyFactory()).methodType.newBeanProxy(new Integer(Commands.INITIALIZECALLBACK_METHOD_ID));
-		
-		fRemoteServer = aFactory.getBeanProxyFactory().getIVMServerProxy();	// For us, the IVMServer on the remote vm ALSO implements IVMCallbackServer.
-
-		((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).registerBeanTypeProxy(callbackType, true);
-		((REMStandardBeanProxyFactory) fFactory.getBeanProxyFactory()).registerProxy(fInitializeCallback);
-		
-	}
-	
-	public boolean createCallback(Socket incoming) {
-		if (registryOpen) {
-			Thread st = new REMCallbackThread(incoming, this, "Callback Thread-"+fNamePostfix, fFactory, fFactory.fNoTimeouts); //$NON-NLS-1$
-			fThreads.add(st);
-			st.start();
-			return true;
-		} else
-			return false;
-	}
-	
-	/**
-	 * Use this to request a shutdown. If the server is already shutdown, this will return false.
-	 */
-	public boolean requestShutdown() {		
-		if (registryOpen)
-			shutdown();
-		else
-			return false;
-		return true;
-	}
-	
-	/**
-	 * Remove a thread from the list.
-	 */
-	public void removeCallbackThread(REMCallbackThread thread) {
-		fThreads.remove(thread);
-	}
-	
-	private void shutdown() {
-		
-		// Go through each thread and ask it to close. Make a copy of the list so that we
-		// won't get into deadlocks.
-		REMCallbackThread[] threadsArray = (REMCallbackThread[]) fThreads.toArray(new REMCallbackThread[fThreads.size()]);
-		for (int i=0; i<threadsArray.length; i++) {
-			// This is a harsh way to shut a connection down, but there's no
-			// other way I know of to interrupt the read on a socket.
-			threadsArray[i].close();
-		}
-			
-		// Now that they've been told to close, wait on each one to finish.
-		for (int i=0; i<threadsArray.length; i++)
-			try {
-				threadsArray[i].join(10000);	// Wait ten seconds, if longer, just go on to next one.
-			} catch (InterruptedException e) {
-			}
-			
-		fThreads.clear();
-		fIdToCallback.clear();
-		fCallbackProxyToId.clear();
-		fInitializeCallback = null;
-		fRemoteServer = null;
-			
-	}		
-	
-	public ICallback getRegisteredCallback(int id) {
-		synchronized(fIdToCallback)	{	
-			return (ICallback) fIdToCallback.get(new Integer(id));
-		}
-	}
-		
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.ICallbackRegistry#registerCallback(org.eclipse.jem.internal.proxy.core.IBeanProxy, org.eclipse.jem.internal.proxy.core.ICallback)
-	 */
-	public void registerCallback(IBeanProxy callbackProxy, ICallback cb) {
-		synchronized(fIdToCallback) {
-			fIdToCallback.put(((IREMBeanProxy) callbackProxy).getID(), cb);
-			fCallbackProxyToId.put(callbackProxy, ((IREMBeanProxy) callbackProxy).getID());
-			fInitializeCallback.invokeCatchThrowableExceptions(callbackProxy, new IBeanProxy[] {fRemoteServer, fFactory.getBeanProxyFactory().createBeanProxyWith(((IREMBeanProxy) callbackProxy).getID().intValue())});
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.ICallbackRegistry#registerCallback(org.eclipse.jem.internal.proxy.core.IProxy, org.eclipse.jem.internal.proxy.core.ICallback, org.eclipse.jem.internal.proxy.core.IExpression)
-	 */
-	public void registerCallback(IProxy callbackProxy, final ICallback cb, IExpression expression) {
-		final Integer id;
-		if (callbackProxy.isBeanProxy()) {
-			id = ((IREMBeanProxy) callbackProxy).getID();
-			synchronized(fIdToCallback) {
-				fIdToCallback.put(id, cb);
-				fCallbackProxyToId.put(callbackProxy, id);
-			}
-		} else {
-			id = new Integer(callbackProxy.hashCode());
-			synchronized (fIdToCallback) {
-				fIdToCallback.put(id, cb);	// This is so that it is registered in case callback is invoked from remote vm during expression processing.
-			}
-			((ExpressionProxy) callbackProxy).addProxyListener(new ExpressionProxy.ProxyListener() {
-				public void proxyResolved(ProxyEvent event) {
-					synchronized(fIdToCallback) {
-						fCallbackProxyToId.put(event.getProxy(), id);
-					}
-				}
-				
-				public void proxyNotResolved(ProxyEvent event) {
-					// Failed, so remove registration completely.
-					synchronized (fIdToCallback) {
-						fIdToCallback.remove(id);
-					}
-				}
-				
-				public void proxyVoid(ProxyEvent event) {
-					// Failed, so remove registration completely.
-					synchronized (fIdToCallback) {
-						fIdToCallback.remove(id);
-					}
-				}
-				
-			});
-		}
-		expression.createSimpleMethodInvoke(fInitializeCallback, callbackProxy, new IProxy[] {fRemoteServer, fFactory.getBeanProxyFactory().createBeanProxyWith(id.intValue())}, false);
-	}
-	
-	/**
-	 * The public interface for deregistering callbacks.
-	 */
-	public void deregisterCallback(IBeanProxy callbackProxy) {
-		synchronized(fIdToCallback)	{
-			Integer id = (Integer) fCallbackProxyToId.remove(callbackProxy);
-			fIdToCallback.remove(id);
-		}
-	}
-	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackThread.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackThread.java
deleted file mode 100644
index ed4169d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCallbackThread.java
+++ /dev/null
@@ -1,327 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMCallbackThread.java,v $
- *  $Revision: 1.16 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.io.*;
-import java.net.Socket;
-import java.util.logging.Level;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.TransmitableArray;
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * This thread handles the actual callback.
- * It is package protected because no one else should access it.
- */
-class REMCallbackThread extends Thread {
-	final REMConnection fConnection;	// A connection to use
-	final REMCallbackRegistry fServer;
-	final REMStandardBeanProxyFactory fFactory;
-	final REMStandardBeanTypeProxyFactory fTypeFactory;
-	final REMProxyFactoryRegistry registry;
-	protected boolean shuttingDown;
-	protected boolean inTransaction;	// Is this thread currently participating in a transaction, (i.e. reading/writing), if so then we can't use it for another transaction.
-	
-
-	/**
-	 * Is this callback thread currently participating in a transaction (reading/writing). If so then it can't be used for an
-	 * independent new transaction. In other words you can't write/read data using this callback thread's
-	 * connection because it is being used by someone else expecting to have exclusive read/write on this connection.
-	 * 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean inTransaction() {
-		return inTransaction;
-	}
-	
-	/**
-	 * Set whether this callback thread is in a transaction or not. If it is in a transaction it cannot be used
-	 * for an independent new transaction. In other words you can't write/read data using this callback thread's
-	 * connection because it is being used by someone else expecting to have exclusive read/write on this connection.
-	 * @param inTransaction
-	 * 
-	 * @since 1.1.0
-	 */
-	public void setIntransaction(boolean inTransaction) {
-		this.inTransaction = inTransaction;
-	}
-	
-	// Kludge: Bug in Linux 1.3.xxx of JVM. Closing a socket while the socket is being read/accept will not interrupt the
-	// wait. Need to timeout to the socket read/accept before the socket close will be noticed. This has been fixed
-	// in Linux 1.4. So on Linux 1.3 need to put timeouts in on those sockets that can be separately closed while reading/accepting.
-	static boolean LINUX_1_3 = "linux".equalsIgnoreCase(System.getProperty("os.name")) && System.getProperty("java.version","").startsWith("1.3");	 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	
-	public REMCallbackThread(Socket socket, REMCallbackRegistry server, String name, REMProxyFactoryRegistry registry, boolean noTimeouts) {
-		super(name);
-		
-		fConnection = new REMConnection(socket, true);	// No timeouts since this is a server thread.
-		this.registry = registry;
-		fServer = server;
-		fFactory = (REMStandardBeanProxyFactory) registry.getBeanProxyFactory();
-		fTypeFactory = (REMStandardBeanTypeProxyFactory) registry.getBeanTypeProxyFactory();		
-	}
-	
-	/**
-	 * Request the thread to close down.
-	 */
-	public void close() {
-		try {
-			shuttingDown = true;	// So that if this is a forced close then it will know not to print error msgs.
-			if (fConnection.fSocket != null)
-				fConnection.fSocket.close();
-		} catch (Exception e) {
-		}
-	}
-	
-	
-	/*
-	 * Return the IREMConnection associated with this callback. Used by
-	 * the connection server to return this connection for any requests 
-	 * made on this thread.
-	 * <package-protected> so that only remote proxy can access.
-	 */
-	IREMConnection getConnection() {
-		return fConnection;
-	}
-	
-	public void run() {
-
-		DataInputStream in = fConnection.in;
-		DataOutputStream out = fConnection.out;	
-		InputStream ins = null;	
-		boolean shutdown = false;
-		Commands.ValueObject valueObject = new Commands.ValueObject();	// Working value object so not continually recreated.
-		BeanProxyValueSender valueSender = new BeanProxyValueSender(this.fFactory);	// Working valuesender so not continually recreated. 
-		try {
-			boolean doLoop = true;
-
-			/**
-			 * Note: In the cases below you will see a lot of finally clauses that null variables out.
-			 * This is because this is a long running loop, and variables declared within blocks are not
-			 * garbage collected until the method is terminated, so these variables once set would never
-			 * be GC'd. The nulling at the end of the case makes sure that any of those objects set are
-			 * now available for garbage collection when necessary.
-			 */		
-			while(doLoop) {
-				byte cmd = 0;
-				try {
-					if (LINUX_1_3)
-						fConnection.fSocket.setSoTimeout(1000);	// Linux 1.3 bug, see static LINUX_1_3 above
-					cmd = in.readByte();
-					if (LINUX_1_3)
-						fConnection.fSocket.setSoTimeout(0);	// Linux 1.3 bug, see static LINUX_1_3 above
-				} catch (InterruptedIOException e) {
-					continue;	// Timed out, try again
-				}
-					
-				switch (cmd) {
-					case Commands.QUIT_CONNECTION:				
-						doLoop = false;	
-						break;	// Close this connection
-						
-					case Commands.TERMINATE_SERVER:
-						doLoop = false;		
-						shutdown = true;	// Shutdown everything
-						break;
-						
-					case Commands.CALLBACK:
-						int callID = in.readInt();	// The id of the registered callback to call.
-						int msgID = in.readInt();	// The id of the message to call.
-						Object parm = null;
-						Object result = null;
-						ICallback cb = null;
-						try {
-							// The register callback handler will know how to handle the parm,
-							// it will know if it is an array of proxies, or an object of some kind.
-							fFactory.startTransaction();	// Start a transaction.
-							setIntransaction(true);	// Also tell ourselves that we are in a transaction.
-							boolean isProxies = true;							
-							try {
-								Commands.readValue(in, valueObject);
-								if (valueObject.type == Commands.ARRAY_IDS) {
-									// It is an array containing IDs, as it normally would be.
-									// However it will become IBeanProxy[]. That is because if ID's
-									// they must be proxies over here.
-									valueSender.initialize(valueObject);
-									Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-									if (valueSender.getException() != null) {
-										close();	// Something wrong, close the thread so next time we get a new one.
-									}
-									parm = valueSender.getArray();
-								} else {
-									// It is object or null. It could be an array of objects, or one object.
-									isProxies = false;
-									parm = valueObject.getAsObject();
-								}
-							} finally {
-								setIntransaction(false);
-								fFactory.stopTransaction();
-							}
-							// Now perform the callback.
-							cb = fServer.getRegisteredCallback(callID);
-							if (cb != null) {
-								// Callback still registered. If proxies, then if first entry is just a proxy,
-								// then we are sending only one. A convienence factor for callbacks.
-								// If not a single entry of IBeanProxy, then send whole array.
-								try {
-									if (isProxies)
-										if (((Object[]) parm).length == 1 && (((Object[]) parm)[0] == null || ((Object[]) parm)[0] instanceof IBeanProxy))
-											result = cb.calledBack(msgID, (IBeanProxy) ((Object[]) parm)[0]);
-										else
-											result = cb.calledBack(msgID, (Object[]) parm);
-									else
-										result = cb.calledBack(msgID, parm);
-									// We only accept null, IREMBeanProxies, and Object[], where
-									// contents of Object[] are bean proxies.
-									valueObject.set();
-									if (result instanceof IREMBeanProxy)
-										 ((IREMBeanProxy) result).renderBean(valueObject);
-									else if (result instanceof Object[]) {
-										class Retriever implements Commands.ValueRetrieve {
-											int index = 0;
-											Object[] array;
-											Commands.ValueObject worker = new Commands.ValueObject();
-
-											public Retriever(Object[] anArray) {
-												array = anArray;
-											}
-
-											public Commands.ValueObject nextValue() {
-												Object retParm = array[index++];
-												if (retParm != null)
-													if (retParm instanceof IREMBeanProxy)
-														 ((IREMBeanProxy) retParm).renderBean(worker);
-													else if (retParm instanceof TransmitableArray) {
-														// It is another array, create a new
-														// retriever.
-														worker.setArrayIDS(
-															new Retriever(((TransmitableArray) retParm).array),
-															((TransmitableArray) retParm).array.length,
-															((TransmitableArray) retParm).componentTypeID);
-													} else {
-														// It's an object. Need to get bean
-														// type so that we can send it.
-														IREMBeanProxy type =
-															(IREMBeanProxy) fTypeFactory.getBeanTypeProxy(retParm.getClass().getName());
-														if (type == null)
-															throw new IllegalArgumentException();
-														int classID = type.getID().intValue();
-														worker.setAsObject(retParm, classID);
-													}
-												else
-													worker.set();
-												return worker; 
-											}
-										};
-
-										valueObject.setArrayIDS(
-											new Retriever((Object[]) result),
-											((Object[]) result).length,
-											Commands.OBJECT_CLASS);
-									}
-									
-									Commands.sendCallbackDoneCommand(out, valueObject, Commands.NO_ERROR);
-								} catch (RuntimeException e) {
-									// Something happened, turn it into an error object
-									// to send back.
-									valueObject.set(e.getClass().getName() + ':' + e.getLocalizedMessage());
-									Commands.sendCallbackDoneCommand(out, valueObject, Commands.CALLBACK_RUNTIME_EXCEPTION);
-									ProxyPlugin.getPlugin().getLogger().log(e, Level.INFO);	// Just log it, but assume safe enough to just go back and wait for next callback request.
-								}
-							} else {
-								valueObject.set();
-								Commands.sendCallbackDoneCommand(out, valueObject, Commands.CALLBACK_NOT_REGISTERED);	// Send error msg back to indicate we weren't registered.								
-							}
-						} finally {
-							parm = null;	// Clear out for GC to work
-							result = null;
-							cb = null;
-							valueObject.set();
-							valueSender.clear();
-						}
-						break;
-						
-					case Commands.CALLBACK_STREAM:
-						// A request for a stream
-						callID = in.readInt();	// The id of the registered callback to call.
-						msgID = in.readInt();	// The id of the message to call.
-						cb = null;
-						try {
-							// Now perform the callback.
-							cb = fServer.getRegisteredCallback(callID);
-							if (cb != null) {
-								// Callback still registered
-								valueObject.set();								
-								Commands.sendCallbackDoneCommand(out, valueObject, Commands.NO_ERROR);	// Send null to let it know we've accepted the stream
-								ins = new REMCallbackInputStream(in, out);
-								try {
-									cb.calledBackStream(msgID, ins);
-								} finally {
-									try {
-										ins.close();	// Make sure it's closed.
-									} catch (IOException e) {
-										// Exception while closing, just log it and then mark to end the loop so we close connection too.
-										doLoop = false;
-										ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "In REMCallbackThread", e)); //$NON-NLS-1$										
-									}
-								}
-							} else {
-								valueObject.set();
-								Commands.sendCallbackDoneCommand(out, valueObject, Commands.CALLBACK_NOT_REGISTERED);	// Send error msg back to indicate we weren't registered.								
-							}
-						} finally {
-							cb = null;	// Clear out for GC to work
-							ins = null;
-							valueObject.set();							
-						}
-						break;																	
-						
-					default:
-						// Unknown command. We don't know how long the command is, so we need to close the connection.
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "REMCallback: Invalid cmd sent="+cmd, null)); //$NON-NLS-1$
-						doLoop = false;						
-						break;
-				}
-			}
-		} catch (EOFException e) {
-			// This is ok. It means that the connection on the other side was terminated.
-			// So just accept this and go down.
-		} catch (Throwable e) {
-			if (!shuttingDown)
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "In REMCallbackThread", e)); //$NON-NLS-1$
-		} finally {
-			if (in != null)
-				try {
-					in.close();
-				} catch (Exception e) {
-				}
-			if (out != null)
-				try {
-					out.close();
-				} catch (Exception e) {
-				}
-			close();
-		}		
-		fServer.removeCallbackThread(this);
-		if (shutdown)
-			fServer.requestShutdown();
-	}	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterClassBeanProxy.java
deleted file mode 100644
index 4fc5cf9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterClassBeanProxy.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- * $RCSfile: REMCharacterClassBeanProxy.java,v $ $Revision: 1.6 $ $Date: 2005/08/24 20:39:06 $
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * IDE Implementation of ICharacterBeanProxy for the Character class. Creation date: (2/6/00
- * 9:02:54 AM) @author: Joe Winchester
- */
-final class REMCharacterClassBeanProxy extends REMConstantBeanProxy implements ICharacterBeanProxy {
-	protected Character fCharValue;
-
-	/**
-	 * As well as storing the bean store the char value so that we can return the charValue faster
-	 * without the need for repeated re-casting. It is package protected because it is created in
-	 * special way, so no one else should create these.
-	 * 
-	 * @param aBean
-	 *            java.lang.Object
-	 */
-	REMCharacterClassBeanProxy(REMProxyFactoryRegistry aRegistry, Character value) {
-		super(aRegistry);
-		fCharValue = value;
-	}
-
-	/**
-	 * equals: Equal if: 1) This proxy == (identity) to the other object 2) Else if other is an
-	 * IBeanProxy and not a constant one, then if equals on the server. 3) If this is a constant
-	 * proxy and the other is too or is a constant value (e.g. IStringBeanProxy.equals(String),
-	 * then true if values are equals.
-	 */
-	public boolean equals(Object anObject) {
-		if (this == anObject)
-			return true; // Identity
-		if (anObject instanceof REMCharacterClassBeanProxy)
-			return fCharValue.charValue() == ((REMCharacterClassBeanProxy) anObject).charValue();
-		if (anObject instanceof Character)
-			return fCharValue.charValue() == ((Character) anObject).charValue();
-		return false;
-	}
-
-	/**
-	 * Return the char value
-	 */
-	public char charValue() {
-		return fCharValue.charValue();
-	}
-	/**
-	 * Return the java.lang.Character value
-	 */
-	public Character characterValue() {
-		return fCharValue;
-	}
-
-	/**
-	 * Answer the toString() of the value.
-	 */
-	public String toBeanString() {
-		return fCharValue.toString();
-	}
-
-	/**
-	 * Get the beantype
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).characterClass;
-	}
-
-	/**
-	 * Render the bean into value object.
-	 */
-	public void renderBean(Commands.ValueObject value) {
-		value.set(fCharValue);
-	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#byteValue()
-	 */
-	public byte byteValue() {
-		return (byte) fCharValue.charValue();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#doubleValue()
-	 */
-	public double doubleValue() {
-		return fCharValue.charValue();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#floatValue()
-	 */
-	public float floatValue() {
-		return fCharValue.charValue();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#intValue()
-	 */
-	public int intValue() {
-		return fCharValue.charValue();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#longValue()
-	 */
-	public long longValue() {
-		return fCharValue.charValue();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#numberValue()
-	 */
-	public Number numberValue() {
-		return new Integer(charValue()); // Kludge.
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#shortValue()
-	 */
-	public short shortValue() {
-		return (short) fCharValue.charValue();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterClassBeanTypeProxy.java
deleted file mode 100644
index abbcb0d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterClassBeanTypeProxy.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMCharacterClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * Character BeanType Proxy for Character.class.
- * Creation date: (2/23/00 1:59:02 PM)
- * @author: Richard Lee Kulp
- */
-final class REMCharacterClassBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMConstantBeanTypeProxy {
-	final REMCharacterClassBeanProxy nilProxy;	// Value of '\0'
-
-REMCharacterClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy objectType) {
-	super(aRegistry, new Integer(Commands.CHARACTER_CLASS), Character.class.getName(), objectType);
-	
-	nilProxy = new REMCharacterClassBeanProxy(aRegistry, new Character('\0'));
-}
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-ICharacterBeanProxy createCharacterBeanProxy(Character aCharacter) {
-	return (aCharacter.charValue() != '\0') ?
-		new REMCharacterClassBeanProxy(fRegistry, aCharacter) : nilProxy;
-}
-
-/**
- * Create a new bean proxy with the specified id.
- *
- * For all of the primitive wrapper types, this is an invalid operation. They are created
- * explicitly through the appropriate create method.
- */
-public IREMBeanProxy newBeanProxy(Integer anID) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the primitive wrapper types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newInstance method. Character doesn't have a default ctor, so the standard way won't work.
- * Return the nilProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return nilProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createCharacterBeanProxy(new Character(value.aChar));
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterTypeBeanProxy.java
deleted file mode 100644
index 1c8966b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterTypeBeanProxy.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- * $RCSfile: REMCharacterTypeBeanProxy.java,v $ $Revision: 1.6 $ $Date: 2005/08/24 20:39:07 $
- */
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote implementation of ICharacterBeanProxy. Creation date: (2/6/00 9:02:54 AM) @author: Joe
- * Winchester
- */
-final class REMCharacterTypeBeanProxy extends REMConstantBeanProxy implements ICharacterBeanProxy {
-	protected char fChar;
-
-	REMCharacterTypeBeanProxy(REMProxyFactoryRegistry aRegistry, char value) {
-		super(aRegistry);
-		fChar = value;
-	}
-
-	/**
-	 * equals: Equal if: 1) This proxy == (identity) to the other object 2) Else if other is an
-	 * IBeanProxy and not a constant one, then if equals on the server. 3) If this is a constant
-	 * proxy and the other is too or is a constant value (e.g. IStringBeanProxy.equals(String),
-	 * then true if values are equals.
-	 */
-	public boolean equals(Object anObject) {
-		if (this == anObject)
-			return true; // Identity
-		if (anObject instanceof REMCharacterTypeBeanProxy)
-			return fChar == ((REMCharacterTypeBeanProxy) anObject).charValue();
-		if (anObject instanceof Character)
-			return fChar == ((Character) anObject).charValue();
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		if (this == aBeanProxy)
-			return true; // Identity
-		if (aBeanProxy instanceof REMCharacterTypeBeanProxy)
-			return fChar == ((REMCharacterTypeBeanProxy) aBeanProxy).charValue();
-		return false;
-	}
-
-	/**
-	 * Return the char value
-	 */
-	public char charValue() {
-		return fChar;
-	}
-	/**
-	 * Return the java.lang.Character value
-	 */
-	public Character characterValue() {
-		return new Character(fChar);
-	}
-
-	/**
-	 * Answer the toString() of the value.
-	 */
-	public String toBeanString() {
-		return String.valueOf(fChar);
-	}
-
-	/**
-	 * Get the beantype
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).charType;
-	}
-
-	/**
-	 * Render the bean into value object.
-	 */
-	public void renderBean(Commands.ValueObject value) {
-		value.set(fChar);
-	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#byteValue()
-	 */
-	public byte byteValue() {
-		return (byte) fChar;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#doubleValue()
-	 */
-	public double doubleValue() {
-		return fChar;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#floatValue()
-	 */
-	public float floatValue() {
-		return fChar;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#intValue()
-	 */
-	public int intValue() {
-		return fChar;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#longValue()
-	 */
-	public long longValue() {
-		return fChar;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#numberValue()
-	 */
-	public Number numberValue() {
-		return new Integer(fChar); // Kludge
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#shortValue()
-	 */
-	public short shortValue() {
-		return (short) fChar;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterTypeBeanTypeProxy.java
deleted file mode 100644
index 417310a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMCharacterTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMCharacterTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * Character.TYPE BeanType Proxy.
- * Creation date: (2/23/00 1:59:02 PM)
- * @author: Richard Lee Kulp
- */
-final class REMCharacterTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-
-	final REMCharacterTypeBeanProxy nilProxy;	// Value of '\0'
-/**
- * REMCharacterBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMCharacterTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.CHARACTER_TYPE), Character.TYPE.getName());
-	
-	nilProxy = new REMCharacterTypeBeanProxy(aRegistry, '\0');
-}
-
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- * Use the cache.
- */
-ICharacterBeanProxy createCharacterBeanProxy(char aCharacter) {
-	return new REMCharacterTypeBeanProxy(fRegistry, aCharacter);
-}
-
-/**
- * newInstance method. Character doesn't have a default ctor, so the standard way won't work.
- * Return the nilProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return nilProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createCharacterBeanProxy(value.aChar);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMClassBeanTypeProxy.java
deleted file mode 100644
index 7b819df..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMClassBeanTypeProxy.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * This is a bean type for the Class object. It is needed so that
- * when a new object id comes in that represents a class, it will
- * go through this bean type to create it. We need to do something
- * special so that the correct bean type object is created.
- */
-
-final class REMClassBeanTypeProxy extends REMAbstractBeanTypeProxy {
-
-
-REMClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy objectType) {
-	super(aRegistry, new Integer(Commands.CLASS_CLASS), Class.class.getName(), objectType);
-}
-
-/**
- * Note: Since new instances of Class are never done through a default ctor,
- * this function is not supported.
- */
-public IBeanProxy newInstance() { 
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Note: Since new instances of Class are never done through a initialization strings,
- * this function is not supported.
- */
-public IBeanProxy newInstance(String initializationString) {
-	throw new UnsupportedOperationException();
-}		
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * NOTE: Since the Class type is final, this function isn't supported.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Create a new bean proxy with the specified id.
- *
- * In this case it means we need a new IBeanProxyType. We will let the 
- * Beantype factory handle this since it knows how to get the information
- * for a specific id.
- */
-public IREMBeanProxy newBeanProxy(Integer anID) {
-	return ((REMStandardBeanTypeProxyFactory) fRegistry.getBeanTypeProxyFactory()).createBeanTypeProxy(anID);
-}
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConnection.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConnection.java
deleted file mode 100644
index 3896805..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConnection.java
+++ /dev/null
@@ -1,342 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMConnection.java,v $
- *  $Revision: 1.20 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.io.*;
-import java.net.Socket;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands.*;
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-import org.eclipse.jem.util.TimerTests;
-/**
- * The default implementation of the connection.
- *
- * It uses the property "proxyvm.bufsize" to determine the buffer size to use. If not specified, it uses the system default
- */
-public class REMConnection implements IREMConnection, IREMExpressionConnection {
-	
-	public final static String INVOKE_STEP = "Invoke"; //$NON-NLS-1$
-	public final static String INVOKE_METHOD_STEP = "Invoke Method"; //$NON-NLS-1$
-	protected Socket fSocket = null;
-	protected DataInputStream in = null;
-	protected DataOutputStream out = null;
-	private static final int TIME_OUT = 1000 * 30;	// Wait up to half minute before timeout.
-	
-	public REMConnection(Socket socket, boolean noTimeouts) {
-		try {
-			fSocket = socket;
-			fSocket.setSoLinger(true, 10);	// Wait 10 seconds if necessary for the final stuff to go out after closing.
-			if (!noTimeouts)
-				fSocket.setSoTimeout(TIME_OUT);	// Timeout period
-			Integer bufSize = Integer.getInteger("proxyvm.bufsize"); //$NON-NLS-1$
-			if (bufSize == null)
-				bufSize = new Integer(16000);
-			out = new DataOutputStream(new BufferedOutputStream(fSocket.getOutputStream(), bufSize.intValue()));	// It didn't take the hint, so we will buffer it.
-			in = new DataInputStream(new BufferedInputStream(fSocket.getInputStream(), bufSize.intValue()));	// It didn't take the hint, so we will buffer it.
-		} catch (IOException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			
-			if (out != null)
-				try {
-					out.close();
-				} catch (IOException e2) {
-				}
-			if (in != null)
-				try {
-					in.close();
-				} catch (IOException e3) {
-				}
-			try {
-				fSocket.close();
-			} catch (IOException e4) {
-			}
-			fSocket = null;
-			in = null;
-			out = null;
-		}
-	}
-	
-	/**
-	 * Did this construct correctly.
-	 * This is needed because an exception could be thrown in the ctor and
-	 * that's not a good thing to do.
-	 */
-	public boolean isConnected() {
-		return fSocket != null;
-	}
-	
-	/**
-	 * Terminate the server. 
-	 */
-	public void terminateServer() {
-		if (isConnected()) {
-			try {
-				Commands.sendTerminateCommand(out);
-			} catch (IOException e) {
-			}
-			close();
-		}
-	}
-	
-	/**
-	 * Close the connection.
-	 */
-	public void close() {
-		if (isConnected()) {
-			try {
-				Commands.sendQuitCommand(out);
-			} catch (IOException e) {
-			} finally {
-				try {
-					out.close();
-				} catch (IOException e2) {
-				}
-				try {
-					in.close();
-				} catch (IOException e3) {
-				}
-				try {
-					fSocket.close();
-				} catch (IOException e4) {
-				}
-			}
-			fSocket = null;
-			in = null;
-			out = null;
-		}
-	}
-		
-					
-	/**
-	 * Return the class information.
-	 */
-	public GetClassReturn getClass(String className) throws CommandException {
-		if (isConnected())
-			try {
-				// It's simple, just pass onto Commands.
-				return Commands.sendGetClassCommand(out, in, className);
-			} catch (CommandErrorException e) {
-				if (e.getErrorCode() != Commands.GET_CLASS_NOT_FOUND)
-					throw e;	// Not class not found, send it on
-			}			
-		return null;	// Not found, so return null				
-	}
-	
-	
-	/**
-	 * Return the class information given an ID.
-	 */
-	public GetClassIDReturn getClassFromID(int classID) throws CommandException {
-		if (isConnected()) {
-			// It's simple, just pass onto Commands.
-			return Commands.sendGetClassFromIDCommand(out, in, classID);
-		}
-		return null;	// Not found, so return null		
-	}	
-	
-	/**
-	 * Get the object data from an id.
-	 */
-	public void getObjectData(int classID, Commands.ValueObject valueReturn) throws CommandException {
-		if (isConnected()) {
-			// Just pass onto Commands.
-			Commands.sendGetObjectData(out, in, classID, valueReturn);
-		} else
-			valueReturn.set();	// Set it to null since we aren't connected.
-	}	
-
-	/**
-	 * Get a new instance using an init string
-	 */
-	public void getNewInstance(int classID, String initString, Commands.ValueObject newInstance) throws CommandException {
-		if (isConnected()) {
-			// Just pass onto Commands.
-			Commands.sendNewInstance(out, in, classID, initString, newInstance);
-		} else
-			newInstance.set();	// Set it to null since we aren't connected.
-	}
-	
-	/**
-	 * Release the id.
-	 */
-	public void releaseID(int id){
-		if (isConnected())
-			try {
-				// Just pass onto Commands.
-				Commands.releaseObjectCommand(out, id);
-			} catch (IOException e) {
-				// Don't care it didn't work
-			}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMConnection#getArrayContents(int, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void getArrayContents(int arrayID, Commands.ValueObject returnValue) throws CommandException {
-		if (isConnected()) {
-			// It's simple, just pass onto Commands.
-			Commands.sendGetArrayContentsCommand(out, in, arrayID, returnValue);
-		}			
-	}
-	
-	/**
-	 * Invoke the method call
-	 */	
-	public void invokeMethod(int methodID, Commands.ValueObject invokeOn, Commands.ValueObject parms, Commands.ValueObject returnValue) throws CommandException {
-		if (isConnected()) {
-			// It's simple, just pass onto Commands.
-			TimerTests.basicTest.startCumulativeStep(INVOKE_METHOD_STEP);
-			Commands.sendInvokeMethodCommand(out, in, methodID, invokeOn, parms, returnValue);
-			TimerTests.basicTest.stopCumulativeStep(INVOKE_METHOD_STEP);
-		}			
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMConnection#invokeMethod(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject, java.lang.String, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void invokeMethod(ValueObject classType, String methodName, ValueObject parmTypes, ValueObject invokeOn, ValueObject parms,
-			ValueObject returnValue) throws CommandException {
-		if (isConnected()) {
-			// It's simple, just pass onto Commands.
-			TimerTests.basicTest.startCumulativeStep(INVOKE_STEP);
-			Commands.sendInvokeMethodCommand(out, in, classType, methodName, parmTypes, invokeOn, parms, returnValue);
-			TimerTests.basicTest.stopCumulativeStep(INVOKE_STEP);
-		}			
-	}
-	
-	/* ************************************************************
-	 * Put the Expression processing commands here.
-	 * 
-	 * ************************************************************/
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#startExpressionProcessing()
-	 */
-	public void startExpressionProcessing(int expressionID, byte trace) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendStartExpressionProcessingCommand(expressionID, trace, out);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pushExpressionCommand(byte)
-	 */
-	public void pushExpressionCommand(int expressionID, byte subcommand) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendExpressionCommand(expressionID, out, subcommand);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#stopExpressionProcessing()
-	 */
-	public void stopExpressionProcessing(int expressionID) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendEndExpressionProcessingCommand(expressionID, out);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pushValueObject(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void pushValueObject(ValueObject valueObject) throws CommandException {
-		if (isConnected())
-			Commands.writeValue(out, valueObject, false);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pushByte(byte)
-	 */
-	public void pushByte(byte abyte) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendByte(out, abyte);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pushInt(int)
-	 */
-	public void pushInt(int anInt) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendInt(out, anInt);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pushString(java.lang.String)
-	 */
-	public void pushString(String aString) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendString(out, aString);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pushBoolean(boolean)
-	 */
-	public void pushBoolean(boolean aBool) throws IOException {
-		if (isConnected())
-			ExpressionCommands.sendBoolean(out, aBool);
-	}
-
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#getFinalValue(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void getFinalValue(ValueObject result) throws CommandException {
-		if (isConnected())
-			Commands.readBackValue(in, result, Commands.NO_TYPE_CHECK);
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#pullValue(int, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void pullValue(int expressionID, ValueObject proxyids, ValueSender sender) throws CommandException {
-		if (isConnected())
-			ExpressionCommands.sendPullValueCommand(expressionID, out, in, proxyids, sender);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMExpressionConnection#sync(int, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void sync(int expressionID, ValueObject proxyids, ValueSender sender) throws CommandException {
-		if (isConnected())
-			ExpressionCommands.sendSyncCommand(expressionID, out, in, proxyids, sender);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMConnection#readProxyArrayValues(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject, org.eclipse.jem.internal.proxy.common.remote.Commands.ValueSender, boolean)
-	 */
-	public void readProxyArrayValues(Commands.ValueObject returnValue, Commands.ValueSender valueSender, boolean allowFlag) throws CommandException {
-		if (isConnected())
-			Commands.readArray(in, returnValue.anInt, valueSender, returnValue, allowFlag);
-	}
-
-	public void transferExpression(int expressionID, ValueObject expController) throws CommandException {
-		if (isConnected())
-			ExpressionCommands.sendTransferExpressionCommand(expressionID, out, in, expController);
-	}
-
-	public void resumeExpression(int expressionID, ValueObject expController) throws CommandException {
-		if (isConnected())
-			ExpressionCommands.sendResumeExpressionCommand(expressionID, out, expController);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstantBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstantBeanProxy.java
deleted file mode 100644
index d26f67d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstantBeanProxy.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMConstantBeanProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.IBeanProxy;
-import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
-/**
- * This is a base for bean proxies that are constants and
- * do not have an object on the remote VM side. They are
- * shipped back and forth by value.
- */
-
-public abstract class REMConstantBeanProxy implements IREMConstantBeanProxy {
-	protected final REMProxyFactoryRegistry fFactory;
-	private final static Integer ID = new Integer(Commands.NOT_AN_ID);
-	
-	protected REMConstantBeanProxy(REMProxyFactoryRegistry aFactory) {
-		fFactory = aFactory;
-	}
-	/**
-	 * Return the registry this proxy was created with.
-	 */
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fFactory;
-	}
-	
-	/**
-	 * equals: Equal if:
-	 *         1) This proxy == (identity) to the other object
-	 *         2) Else if other is an IBeanProxy and not a constant one, then if
-	 *            equals on the server.
-	 *         3) If this is a constant proxy and the other is too or is a constant
-	 *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
-	 * This is abstract because each type needs to do a unique test for equality.
-	 */
-	public abstract boolean equals(Object anObject);
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		// We can't be assured that there are not non-identical constants that are actually identical.
-		// This is because for constants we do not know the id of the original. That is not sent across from the vm.		
-		return this == aBeanProxy;	
-	}	
-	
-	/**
-	 * Return the ID of this proxy.
-	 * Constants have no id's, so we return -1.
-	 */
-	public Integer getID() {
-		return ID;
-	}
-	
-	/**
-	 * isValid. Constant ones are always valid unless the registry is terminated, except if an
-	 * override releases resources. In that case the overriding
-	 * subclass should also override isValid() to return false
-	 * if release() was called.
-	 */
-	public boolean isValid() {
-		return fFactory.isValid();
-	}
-	
-	/**
-	 * release. Constant ones don't need to typically be released, however
-	 * if an override does do something to release, then it MUST also
-	 * override isValid() to return false.
-	 */
-	public void release() {
-	}
-
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstructorProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstructorProxy.java
deleted file mode 100644
index 8184ac3..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstructorProxy.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMConstructorProxy.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.TransmitableArray;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Proxy for a constructor.
- */
-
-final class REMConstructorProxy extends REMAccessibleObjectProxy implements IConstructorProxy {
-
-	REMConstructorProxy(REMProxyFactoryRegistry aRegistry, Integer anID) {
-		super(aRegistry, anID);
-	}
-
-	/**
-	 * Using this constructor (assuming it takes no arguments) create a new instance.
-	 * Exception will be raised if this constructor takes arguments.
-	 */
-	public IBeanProxy newInstance() throws ThrowableProxy {
-		return newInstance(null);
-	}
-
-	/**
-	 * The type proxy is constant proxy out of the method factory.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMMethodProxyFactory) fFactory.getMethodProxyFactory()).ctorType;
-	}
-
-	/**
-	 * Using this constructor (with the arguments) create a new instance.
-	 * Exception will be raised if arguments don't match the constructor.
-	 */
-	public IBeanProxy newInstance(IBeanProxy[] creationArguments) throws ThrowableProxy {
-		IREMMethodProxy newInstanceMethod =
-			(IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getConstructorNewInstance();
-
-		// Constructor.newInstance takes one parm (Object[]) where [0] is an Object[] of the arguments to the constructor.
-		Object[] parms = null;
-		if (creationArguments != null)
-			parms = new Object[] { new TransmitableArray(Commands.OBJECT_CLASS, creationArguments)};
-
-		return newInstanceMethod.invokeWithParms(this, parms);
-	}
-	public IBeanProxy newInstanceCatchThrowableExceptions() {
-		try {
-			return newInstance();
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			fFactory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-	public IBeanProxy newInstanceCatchThrowableExceptions(IBeanProxy[] args) {
-		try {
-			return newInstance(args);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			fFactory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-	
-	private IBeanTypeProxy[] fParameterTypes;
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConstructorProxy#getParameterTypes()
-	 */
-	public synchronized IBeanTypeProxy[] getParameterTypes() {
-		if (fParameterTypes == null) {
-			IArrayBeanProxy parmTypes = (IArrayBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory)
-					.getConstructorParameterTypesMessage().invokeCatchThrowableExceptions(this);
-			if (parmTypes == null)
-				fParameterTypes = new IBeanTypeProxy[0]; // There was some error, only way null is returned
-			else {
-				int len = parmTypes.getLength();
-				fParameterTypes = new IBeanTypeProxy[len];
-				for (int i = 0; i < len; i++)
-					try {
-						fParameterTypes[i] = (IBeanTypeProxy) parmTypes.get(i);
-					} catch (ThrowableProxy e) {
-					}
-				fFactory.releaseProxy(parmTypes); // Don't need the array on the server anymore.
-			}
-		}
-
-		return fParameterTypes;
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstructorTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstructorTypeProxy.java
deleted file mode 100644
index c4ea783..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMConstructorTypeProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMConstructorTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * BeanType Proxy for Method class.
- */
-
-final class REMConstructorTypeProxy extends REMAbstractBeanTypeProxy {
-
-REMConstructorTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy accessibleTypeProxy) {
-	super(aRegistry, new Integer(Commands.CONSTRUCTOR_CLASS), java.lang.reflect.Constructor.class.getName(), accessibleTypeProxy);
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the accessible object types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Specialized from REMAbstractBeanTypeProxy to ensure Constructor proxies are created correctly.
- */
-public IREMBeanProxy newBeanProxy(Integer objectID) {
-	return new REMConstructorProxy(fRegistry, objectID);
-}
-
-/**
- * Note: Since new instances of Constructor are never done through a default ctor,
- * this function is not supported.
- */
-public IBeanProxy newInstance() { 
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Note: Since new instances of Constructor are never done through an initialization string,
- * this function is not supported.
- */
-public IBeanProxy newInstance(String initializationString) {
-	throw new UnsupportedOperationException();
-}		
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleClassBeanProxy.java
deleted file mode 100644
index 82cf29e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleClassBeanProxy.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMDoubleClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Proxy for Double.class.
- */
-class REMDoubleClassBeanProxy extends REMNumberBeanProxy {
-
-REMDoubleClassBeanProxy(REMProxyFactoryRegistry aRegistry, Double aDouble) {
-	super(aRegistry, aDouble);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).doubleClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set((Double) numberValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleClassBeanTypeProxy.java
deleted file mode 100644
index 1adaee4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleClassBeanTypeProxy.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMDoubleClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Double.class.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMDoubleClassBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMDoubleClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.DOUBLE_CLASS), Double.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMDoubleClassBeanProxy(aRegistry, new Double(0D));	
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createDoubleBeanProxy(Double aDouble) {
-	return (aDouble.doubleValue() != 0D) ?
-		new REMDoubleClassBeanProxy(fRegistry, aDouble) : zeroProxy;
-}
-
-/**
- * Generic way to create an Double proxy, however, the Number must be a Double.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createDoubleBeanProxy((Double) aNumber);
-}	
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createDoubleBeanProxy(new Double(value.aDouble));
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleTypeBeanProxy.java
deleted file mode 100644
index 2df521e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleTypeBeanProxy.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMDoubleTypeBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of INumberProxy for the primitive "double".
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class REMDoubleTypeBeanProxy extends REMConstantBeanProxy implements INumberBeanProxy {
-	private final double fDouble;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMDoubleTypeBeanProxy(REMProxyFactoryRegistry aRegistry, double aDouble) {
-	super(aRegistry);
-	fDouble = aDouble;
-}
-
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMDoubleTypeBeanProxy)
-		return fDouble == ((REMDoubleTypeBeanProxy) anObject).doubleValue();
-	if (anObject instanceof Double)
-		return fDouble == ((Double) anObject).doubleValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMDoubleTypeBeanProxy)
-		return fDouble == ((REMDoubleTypeBeanProxy) aBeanProxy).doubleValue();
-	return false;
-}
-
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return (byte) fDouble;
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fDouble;
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return (float) fDouble;
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return (int) fDouble;
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return (long) fDouble;
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return new Double(fDouble);
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return (short) fDouble;
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return String.valueOf(fDouble);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).doubleType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fDouble);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleTypeBeanTypeProxy.java
deleted file mode 100644
index 2da83fb..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMDoubleTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMDoubleTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Double.TYPE
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMDoubleTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMDoubleTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.DOUBLE_TYPE), Double.TYPE.getName());
-	
-	// Create the cached values
-	zeroProxy = new REMDoubleTypeBeanProxy(aRegistry, 0D);		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createDoubleBeanProxy(double aDouble) {
-	return (aDouble != 0D) ?
-		new REMDoubleTypeBeanProxy(fRegistry, aDouble) : zeroProxy;
-}
-
-/**
- * newInstance method. double is a primitive, so the standard way won't work.
- * Return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-	
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createDoubleBeanProxy(value.aDouble);
-}
-
-/**
- * Short cut for newInstance where the string follows the
- * specific pattern we expect. That way it won't be necessary to ship over to the vm 
- * to process it.
- *
- * The pattern it can accept is:
- * 	1) (double) validNumber - number can be any number because (double) explicitly casts it down.
- *	2) validNumber
- * It will use the decode function of double to determine the valid number.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	String trim = initializationString.trim();
-	if (trim.length() == 0)
-		return super.newInstance(initializationString);	
-	double aDouble;
-	if (trim.startsWith("(double)")) { //$NON-NLS-1$
-		Number v = parseString(trim.substring("(double)".length()).trim()); //$NON-NLS-1$
-		if (v != null)
-			aDouble = v.doubleValue();
-		else
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-	} else {
-		try {
-			aDouble = Double.valueOf(initializationString).doubleValue();	// See if valid double format.
-		} catch (NumberFormatException e) {
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-		}
-	}
-
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(aDouble);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMExpression.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMExpression.java
deleted file mode 100644
index fe2b94e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMExpression.java
+++ /dev/null
@@ -1,1864 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMExpression.java,v $
- *  $Revision: 1.19 $  $Date: 2005/09/07 14:06:08 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import java.io.*;
-import java.util.*;
-import java.util.logging.Level;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.initParser.tree.*;
- 
-/**
- * The Remote proxy version of Expression.
- * 
- * @since 1.0.0
- */
-public class REMExpression extends Expression {
-
-	private IREMExpressionConnection connection;
-	private boolean closed;	// Are we closed.
-	
-	protected Commands.ValueObject workerValue;	// A worker object so that we don't need to keep creating one and throwing it away.
-	
-	protected Map beanTypeCache;	// Use to cache pending BeanTypes. Used in conjunction with REMStandardBeanTypeFactory.
-	protected Map methodsCache;	// Use to cache pending expression method proxies. Used in conjunction with REMProxyConsants.
-	protected Map fieldsCache;	// Use to cache pending expression field proxies. Used in conjunction with REMProxyConsants.
-	
-	/*
-	 * This is very special list. It tries to eliminate unneeded traffic. For example a mark immediately followed by an endmark does
-	 * not need to be sent. Many expressions can look like: mark, endmark, endtransaction. This is a do nothing and we don't want
-	 * to create a connection to just send this. So this list is used to queue up these and remove them too when found as not needed.
-	 * 
-	 *  However, this is very tricky because all pushToProxy transactions that actually do something MUST call the processPending() method 
-	 *  first to make sure any pending transactions are submitted. Because once a real type transaction, such as assignment occurs, any
-	 *  pending transaction is a valid transaction, and no longer a do-nothing transaction.
-	 *  
-	 *  Each transaction type uses a subclass of PendingTransaction to be an entry on the list.
-	 *  
-	 *  The pendings currently supported are:
-	 *  mark/endmark
-	 *  try/catch/endtry
-	 *  block/endblock
-	 *  
-	 *  See each individual transaction type to see how it is handled.
-	 */
-	protected List pendingTransactions;
-	
-	/**
-	 * PendingTransaction entry.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected abstract static class PendingTransaction {
-		
-		/**
-		 * The transaction is now being pushed. The implementation should
-		 * actually do the push.
-		 * 
-		 * @param remExpression The REMExpression for this transaction.
-		 * 
-		 * @since 1.1.0
-		 */
-		public abstract void pushTransaction(REMExpression remExpression);
-	}
-	
-	/**
-	 * @param registry
-	 * 
-	 * @since 1.0.0
-	 */
-	public REMExpression(REMProxyFactoryRegistry registry) {
-		super(registry);
-	}
-	
-	/**
-	 * Return the expression id for this REMExpression. This id is used on the remote vm to
-	 * identify who the request is for.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected int getREMExpressionID() {
-		return this.hashCode();
-	}
-	/**
-	 * Get the pending transactions list.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected List getPendingTransactions() {
-		if (pendingTransactions == null)
-			pendingTransactions = new ArrayList();
-		return pendingTransactions;
-	}
-	
-	// Use this flag when debugging to test if errors are due to improper pending processing.
-	// If true they will be treated as if not pending and will be executed immediately.
-	private static final boolean EXECUTE_PENDING_IMMEDIATELY = false;
-	protected void addPendingTransaction(PendingTransaction pending) {
-		if (!EXECUTE_PENDING_IMMEDIATELY)
-			getPendingTransactions().add(pending);
-		else
-			pending.pushTransaction(this);
-	}
-
-	private boolean sentData;	// Flag to indicate if we have sent anything yet to the remote vm. This is used for the pending optimizations.
-	
-	/**
-	 * Have we sent any data in this transaction yet.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected boolean haveSentData() {
-		return sentData;
-	}
-	
-	/**
-	 * @return Returns the connection.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IREMExpressionConnection getConnection() {
-		if (connection == null) {
-			if (!sentData)
-				getREMBeanProxyFactory().startTransaction();	// This is the first time we send data, so start transaction.
-			
-			sentData = true;	// If we are getting a transaction, that means we are sending data.
-			connection = (IREMExpressionConnection) getREMRegistry().getFreeConnection();
-			// This will actually not be stopped until closeproxy. There could be a slight problem if the expression is never closed.
-			// But that shouldn't happen. This is to prevent any proxy that was released during the execution but was used by
-			// the expression from being released on the remote vm until after the expression is finished.
-			try {
-				if (workerValue == null)
-					workerValue = new Commands.ValueObject();
-				if (expressionProcesserController == null) {
-					byte trace = !isTraceSet() ? ExpressionCommands.TRACE_DEFAULT : (isTrace() ? ExpressionCommands.TRACE_ON : ExpressionCommands.TRACE_OFF); 
-					connection.startExpressionProcessing(getREMExpressionID(), trace);	// It is a new expression.
-				} else {
-					fillProxy(expressionProcesserController, workerValue);
-					connection.resumeExpression(getREMExpressionID(), workerValue);
-					expressionProcesserController = null;
-				}
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				throwIllegalStateException(IO_EXCEPTION_MSG);
-			} catch (CommandException e) {
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				if (!e.isRecoverable()) {
-					connection.close();
-					connection = null;
-				}
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}	
-		}
-		return connection;
-	}
-
-	/**
-	 * General IOException occurred msg.
-	 */
-	protected static final String IO_EXCEPTION_MSG = ProxyRemoteMessages.REMExpression_IOExceptionSeeLog_INFO_; 
-	
-	protected static final String COMMAND_EXCEPTION_MSG = ProxyRemoteMessages.REMExpression_CommandExceptionSeeLog_INFO_; 
-	
-	/**
-	 * Throw an an illegal state exception if some general error, in particular an I/O or Command Exception
-	 * occurred so that callers know there is something wrong.
-	 * 
-	 * @param msg
-	 * @throws IllegalStateException
-	 * 
-	 * @since 1.0.0
-	 */
-	protected void throwIllegalStateException(String msg) throws IllegalStateException {
-		throw new IllegalStateException(msg);
-	}
-	
-	/**
-	 * Return the registry as a REMProxyFactoryRegistry
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final REMProxyFactoryRegistry getREMRegistry() {
-		return (REMProxyFactoryRegistry) registry;
-	}
-	
-	/**
-	 * Return the bean proxy factory as a REMStandardBeanProxyFactory.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final REMStandardBeanProxyFactory getREMBeanProxyFactory() {
-		return (REMStandardBeanProxyFactory) beanProxyFactory;
-	}
-
-	/**
-	 * Process any pending transactions.
-	 * <p>
-	 * <b>Note: </b>It is required that all non-pending-participating transactions must
-	 * call this method first to make sure pending transactions are sent. If this is
-	 * not done, there will be errors in the expression.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void processPendingTransactions() {
-		if (pendingTransactions != null && !pendingTransactions.isEmpty()) {
-			try {
-				for (int i = 0; i < pendingTransactions.size(); i++) {
-					((PendingTransaction) pendingTransactions.get(i)).pushTransaction(this);
-				}
-			} finally {
-				pendingTransactions.clear();
-			}
-		}
-	}
-	
-	/**
-	 * Get the pending entry from top. If top is 1, then get top entry (i.e. last one added), 2 is next one. 
-	 * @param fromTop
-	 * @return entry requested, or <code>null</code> if no such entry.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected PendingTransaction getPendingEntryFromTop(int fromTop) {
-		if (pendingTransactions != null && pendingTransactions.size() >= fromTop) {
-			return (PendingTransaction) pendingTransactions.get(pendingTransactions.size()-fromTop);
-		} else
-			return null;
-	}
-	
-	/**
-	 * Pop up the top entry from the pending transactions queue.
-	 * @param fromTop how many entries to pop from the pending transaction list.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void popPendingEntry(int fromTop) {
-		if (pendingTransactions != null)
-			if (pendingTransactions.size() > fromTop) {
-				while(fromTop-- >0)
-					pendingTransactions.remove(pendingTransactions.size()-1);
-			} else
-				pendingTransactions.clear();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushToProxy(org.eclipse.jem.internal.proxy.core.IProxy)
-	 */
-	protected void pushToProxy(IProxy proxy) {
-		if (proxy == null || proxy.isBeanProxy())
-			pushToProxy((IBeanProxy) proxy);
-		else
-			pushToExpressionProxy((ExpressionProxy) proxy);
-	}
-	
-	private void pushToProxy(IBeanProxy proxy) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push proxy command is:
-			//	PushExpressionCommand(push to proxy) followed by:
-			//		ValueObject containing the rendered proxy.
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.PUSH_TO_PROXY_EXPRESSION_VALUE);
-			if (proxy == null)
-				workerValue.set();
-			else
-				((IREMBeanProxy) proxy).renderBean(workerValue);
-			connection.pushValueObject(workerValue);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#closeProxy()
-	 */
-	protected void closeProxy() {
-		if (!closed) {
-			try {
-				if (connection != null && connection.isConnected()) {
-					try {
-							connection.stopExpressionProcessing(getREMExpressionID());
-					} catch (IOException e) {
-						connection.close();
-						ProxyPlugin.getPlugin().getLogger().log(e, Level.INFO);
-						// Not throwing an illegal state here because we don't care, other than logging and not 
-						// returning the connection to the registry that there was an error on close.
-					} finally {
-						getREMRegistry().returnConnection(connection);
-					}
-				}
-			} finally {
-				closed = true;
-				if (sentData)
-					getREMBeanProxyFactory().stopTransaction();	// Resume proxy releases. We've sent data at least once.
-			}
-		}
-		methodsCache = null;
-		fieldsCache = null;
-		beanTypeCache = null;
-		pendingTransactions = null;
-		connection = null;
-	}
-	
-	private static final Object VOIDTYPE = new Object();	// A void type was sent in expression proxy resolution.
-	private static final Object NOTRESOLVED = new Object();	// A not resolved type was sent in expression proxy resolution.
-	
-	/*
-	 * Get the sender to use for pulling the expression proxy resolutions.
-	 */
-	private BeanProxyValueSender getExpressionProxiesSender() {
-		return new BeanProxyValueSender(getREMBeanProxyFactory()) {
-
-			/*
-			 * (non-Javadoc)
-			 * 
-			 * @see org.eclipse.jem.internal.proxy.remote.BeanProxyValueSender#sendValue(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-			 */
-			public void sendValue(ValueObject value) {
-				if (value.getType() == Commands.FLAG) {
-					switch (value.anInt) {
-						case ExpressionCommands.EXPRESSIONPROXY_NOTRESOLVED:
-							array[index++] = NOTRESOLVED;
-							break;
-						case ExpressionCommands.EXPRESSIONPROXY_VOIDTYPE:
-							array[index++] = VOIDTYPE;
-							break;
-						default:
-							// Shouldn't happen.
-							break;
-					}
-				} else
-					super.sendValue(value);
-			}
-		};
-	}
-		
-	/*
-	 * Process the pulled expression proxy resolutions.
-	 */
-	private void processpulledExpressionProxies(List expressionProxies, BeanProxyValueSender sender) {
-
-		// It is expected that each entry will coorespond to the next non-null expression proxy and will be the bean proxy or one of the special
-		// types.
-		int len = expressionProxies.size();
-		int j = 0;
-		Object[] resolveds = sender.getArray();
-		for (int i = 0; i < len; i++) {
-			ExpressionProxy ep = (ExpressionProxy) expressionProxies.get(i);
-			if (ep != null) {
-				Object resolved = resolveds[j++];
-				if (resolved == NOTRESOLVED)
-					fireProxyNotResolved(ep);
-				else if (resolved == VOIDTYPE)
-					fireProxyVoid(ep);
-				else
-					fireProxyResolved(ep, (IBeanProxy) resolved);
-			}
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pullProxyValue(int, java.util.List)
-	 */
-	protected IBeanProxy pullProxyValue(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException {
-		if (!haveSentData()) {
-			markAllProxiesNotResolved(expressionProxies);
-			return null;	// We haven't pushed any commands, so there is nothing to do. Don't create a connection for this.
-		}
-		// If there are any pending transactions at this point in time, there is no need to send them. They would be do nothings anyway.
-		
-		boolean processedExpressionProxies = false;
-		IREMExpressionConnection lclConnection = getConnection();
-		markInTransaction(lclConnection);
-		try {
-			Commands.ValueObject proxyids = null;
-			BeanProxyValueSender sender = null;
-			if (proxycount > 0) {
-				proxyids = createExpressionProxiesValueObject(proxycount, expressionProxies);
-				sender = getExpressionProxiesSender();
-			}
-			
-			lclConnection.pullValue(getREMExpressionID(), proxyids, sender);
-			// If we got this far, then if there are proxies, we need to process these too.
-			if (proxycount > 0)
-				processpulledExpressionProxies(expressionProxies, sender);
-			processedExpressionProxies =true;
-			lclConnection.getFinalValue(workerValue);	// Get the returned value.
-			return getREMBeanProxyFactory().getBeanProxy(workerValue);
-		} catch (CommandErrorException e) {
-			try {
-				if (e.getErrorCode() == ExpressionCommands.EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION) {
-					// Need to turn it into a Throwable.
-					ThrowableProxy t = null;
-					try {
-						getREMBeanProxyFactory().getBeanProxy(e.getValue());	// This will cause a throw to occur, but we don't want it going out, we want to capture it.
-					} catch (ThrowableProxy e1) {
-						t = e1;
-					}
-					throw new REMNoExpressionValueException(t);
-				}
-				getREMBeanProxyFactory().processErrorReturn(e);
-			} catch (CommandException e1) {
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				if (!e.isRecoverable()) {
-					lclConnection.close();
-					throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-				}			
-			}
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			if (!e.isRecoverable()) {
-				lclConnection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		} finally {
-			markEndTransaction(lclConnection);
-			if (!processedExpressionProxies)
-				markAllProxiesNotResolved(expressionProxies);	// We failed before we could process the expression proxies. So mark all as not resolved.
-		}
-		return null;
-	}
-	
-	/**
-	 * This is called by commands that write some data and will be reading data back immediately 
-	 * (i.e. pull value and invoke expression). If we are on a callback thread and have the 
-	 * used the connection from the callback thread, we need to tell the callback thread that
-	 * it is in a transaction. This is needed because while reading data back there are
-	 * sometimes calls back to the vm to get beantype data for new classes. This would 
-	 * normally be through a new connection so that it doesn't get stuck in the middle of the
-	 * data being sent back. But when running on a callback the same connection is used. So it
-	 * would stick data in the middle of the return stream of data. To prevent this we need
-	 * to tell the callback thread that it is in a transaction during this call so that any
-	 * such new connection requests will get a new connection.
-	 * <p>
-	 * This is not nestable (i.e. the first markEndTransaction will set it false, even if several nested
-	 * markInTransactions are called).
-	 * <p>
-	 * markEndTransaction must be called in ALL cases, such use try/finally.
-	 * @param remConnection the connection to see check against and mark in transaction for.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void markInTransaction(IREMExpressionConnection remConnection) {
-		Thread thread = Thread.currentThread();
-		if (thread instanceof REMCallbackThread) {
-			// We are in a callback, and the callback connection is our connection, tell the callback that it is in transaction.
-			REMCallbackThread callbackThread = (REMCallbackThread) thread;
-			if (callbackThread.getConnection() == remConnection) {
-				callbackThread.setIntransaction(true);
-			}
-		}
-	}
-	
-	/**
-	 * Mark end of transaction.
-	 * @param remConn REMConnection to test and mark not in connection for.
-	 * 
-	 * @see REMExpression#markInTransaction(IREMExpressionConnection)
-	 * @since 1.1.0
-	 */
-	protected void markEndTransaction(IREMExpressionConnection remConn) {
-		Thread thread = Thread.currentThread();
-		if (thread instanceof REMCallbackThread) {
-			// We are in a callback, and the callback connection is our connection, tell the callback that it is in transaction.
-			REMCallbackThread callbackThread = (REMCallbackThread) thread;
-			if (callbackThread.getConnection() == remConn) {
-				callbackThread.setIntransaction(false);
-			}
-		}		
-	}
-
-	/**
-	 * @param expressionProxies
-	 * 
-	 * @since 1.1.0
-	 */
-	private Commands.ValueObject createExpressionProxiesValueObject(int actualCount, List expressionProxies) {
-		class ExpressionProxyRetriever implements Commands.ValueRetrieve {
-			Iterator expressionProxiesItr;
-			Commands.ValueObject worker = new Commands.ValueObject();
-
-			public ExpressionProxyRetriever(List expressionProxies) {
-				this.expressionProxiesItr = expressionProxies.iterator();
-			}
-
-			public Commands.ValueObject nextValue() {
-				worker.set(-1);
-				while (expressionProxiesItr.hasNext()) {
-					Object parm = expressionProxiesItr.next();
-					if (parm != null) {
-						worker.set(((ExpressionProxy) parm).getProxyID());
-						break;
-					}
-				} 
-				return worker;
-			}
-		};
-
-		workerValue.setArrayIDS(new ExpressionProxyRetriever(expressionProxies), actualCount, Commands.INT);
-		return workerValue;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushCastToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushCastToProxy(IProxyBeanType type) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push cast to proxy command is:
-			//	PushExpressionCommand(push cast to proxy) followed by:
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.CAST_EXPRESSION_VALUE);
-			fillProxy(type, workerValue);
-			connection.pushValueObject(workerValue);
-		} catch (IOException e) {
-			connection.close();			
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/**
-	 * Push the proxy bean type in the format depending on expression proxy or beantype proxy.
-	 * @param type
-	 * @throws IOException
-	 * 
-	 * @since 1.1.0
-	 */
-	protected void fillProxy(IProxy type, Commands.ValueObject value) throws IOException {
-		//		ValueObject containing the rendered bean type proxy if IBeanTypeProxy or int (for expression proxy id) if expression proxy.
-		if (type.isBeanProxy()) {
-			((IREMBeanProxy) type).renderBean(value);
-		} else {
-			ExpressionProxy ep = (ExpressionProxy) type;
-			value.set(ep.getProxyID());
-		}
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushInstanceofToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushInstanceofToProxy(IProxyBeanType type) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push instanceof to proxy command is:
-			//	PushExpressionCommand(push instanceof to proxy) followed by:
-			//		ValueObject containing the rendered bean type proxy or the String representing the name of class.
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.INSTANCEOF_EXPRESSION_VALUE);
-			fillProxy(type, workerValue);
-			connection.pushValueObject(workerValue);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushInfixToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InfixOperator, int)
-	 */
-	protected void pushInfixToProxy(InfixOperator operator, InternalInfixOperandType operandType) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push infix to proxy command is:
-			//	PushExpressionCommand(push infix to proxy) followed by:
-			//		byte: operator
-			//		byte: operandType
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.INFIX_EXPRESSION_VALUE);
-			connection.pushByte((byte) operator.getValue());
-			connection.pushByte((byte) operandType.getValue());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}		
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushPrefixToProxy(org.eclipse.jem.internal.proxy.initParser.tree.PrefixOperator)
-	 */
-	protected void pushPrefixToProxy(PrefixOperator operator) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push prefix to proxy command is:
-			//	PushExpressionCommand(push prefix to proxy) followed by:
-			//		byte: operator
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.PREFIX_EXPRESSION_VALUE);
-			connection.pushByte((byte) operator.getValue());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushArrayAccessToProxy(int)
-	 */
-	protected void pushArrayAccessToProxy(int indexCount) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push array access to proxy command is:
-			//	PushExpressionCommand(push array acces to proxy) followed by:
-			//		int: indexCount
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.ARRAY_ACCESS_EXPRESSION_VALUE);
-			connection.pushInt(indexCount);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushArrayCreationToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType, int)
-	 */
-	protected void pushArrayCreationToProxy(IProxyBeanType type, int dimensionCount) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push array creation to proxy command is:
-			//	PushExpressionCommand(push array creation to proxy) followed by:
-			//		ValueObject containing the rendered bean type proxy or the expression proxy.
-			//		int: dimension count
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.ARRAY_CREATION_EXPRESSION_VALUE);
-			fillProxy(type, workerValue);
-			connection.pushValueObject(workerValue);
-			connection.pushInt(dimensionCount);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	protected void pushArrayInitializerToProxy(IProxyBeanType type, int stripCount, int expressionCount) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push array initializer to proxy command is:
-			//	PushExpressionCommand(push array initializer to proxy) followed by:
-			//		ValueObject containing the rendered bean type proxy or expression proxy.
-			//		int: strip count
-			//		int: expression count
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.ARRAY_INITIALIZER_EXPRESSION_VALUE);
-			fillProxy(type, workerValue);
-			connection.pushValueObject(workerValue);
-			connection.pushInt(stripCount);
-			connection.pushInt(expressionCount);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushClassInstanceCreationToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType, int)
-	 */
-	protected void pushClassInstanceCreationToProxy(IProxyBeanType type, int argumentCount) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push class instance creation to proxy command is:
-			//	PushExpressionCommand(push class instance creation to proxy) followed by:
-			//		ValueObject containing the rendered bean type proxy or the expression proxy
-			//		int: argument count
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.CLASS_INSTANCE_CREATION_EXPRESSION_VALUE);
-			fillProxy(type, workerValue);
-			connection.pushValueObject(workerValue);
-			connection.pushInt(argumentCount);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTypeReceiverToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */ 
-	protected void pushTypeReceiverToProxy(IProxyBeanType type) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push type receiver to proxy command is:
-			//	PushExpressionCommand(push type receiver to proxy) followed by:
-			//		ValueObject containing the rendered bean type proxy or the expression proxy.
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.TYPERECEIVER_EXPRESSION_VALUE);
-			fillProxy(type, workerValue);
-			connection.pushValueObject(workerValue);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushFieldAccessToProxy(java.lang.String, boolean)
-	 */
-	protected void pushFieldAccessToProxy(Object field, boolean hasReceiver) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push field access to proxy command is:
-			//	PushExpressionCommand(push field access to proxy) followed by:
-			//		Commands.Value: fieldName or IProxyField
-			//		boolean: hasReceiver
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.FIELD_ACCESS_EXPRESSION_VALUE);
-			if (field instanceof String) {
-				workerValue.set((String) field);
-			} else {
-				fillProxy((IProxy) field, workerValue);
-			}
-			connection.pushValueObject(workerValue);
-			connection.pushBoolean(hasReceiver);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushMethodInvocationToProxy(java.lang.String, boolean, int)
-	 */
-	protected void pushMethodInvocationToProxy(Object method, boolean hasReceiver, int argCount) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push method invocation to proxy command is:
-			//	PushExpressionCommand(push method invocation to proxy) followed by:
-			//		Commands.ValueObject: methodName or IMethodProxy
-			//		boolean: hasReceiver
-			//		int: argCount
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.METHOD_EXPRESSION_VALUE);
-			if (method instanceof String) {
-				workerValue.set((String) method);
-			} else {
-				fillProxy((IProxy) method, workerValue);
-			}
-			connection.pushValueObject(workerValue);
-			connection.pushBoolean(hasReceiver);
-			connection.pushInt(argCount);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushConditionalToProxy(int)
-	 */
-	protected void pushConditionalToProxy(InternalConditionalOperandType expressionType) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push conditional to proxy command is:
-			//	PushExpressionCommand(push conditional to proxy) followed by:
-			//		byte: expression type
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.CONDITIONAL_EXPRESSION_VALUE);
-			connection.pushByte((byte) expressionType.getValue());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/*
-	 * A special one that takes the ThrowableProxy for no expression value and 
-	 * wrappers it prints its stack trace instead, but still makes it a subclass
-	 * of NoExpressionValueException.
-	 * 
-	 * @since 1.1.0
-	 */
-	private static class REMNoExpressionValueException extends NoExpressionValueException {
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0
-		 */
-		private static final long serialVersionUID = 1692406777391812694L;
-
-
-		public REMNoExpressionValueException(ThrowableProxy e) {
-			super(e);
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Throwable#getLocalizedMessage()
-		 */
-		public String getLocalizedMessage() {
-			return ((ThrowableProxy) getCause()).getProxyLocalizedMessage();
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Throwable#getMessage()
-		 */
-		public String getMessage() {
-			return ((ThrowableProxy) getCause()).getProxyMessage();
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Throwable#printStackTrace()
-		 */
-		public void printStackTrace() {
-			getCause().printStackTrace();
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Throwable#printStackTrace(java.io.PrintStream)
-		 */
-		public void printStackTrace(PrintStream s) {
-			getCause().printStackTrace(s);
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Throwable#printStackTrace(java.io.PrintWriter)
-		 */
-		public void printStackTrace(PrintWriter s) {
-			getCause().printStackTrace(s);
-		}
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushInvoke(int, java.util.List)
-	 */
-	protected void pushInvoke(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException {
-		if (!haveSentData()) {
-			markAllProxiesNotResolved(expressionProxies);
-			return;	// We haven't pushed any commands, so there is nothing to do. Don't create a connection for this.
-		}
-		// If at this point there are pending transactions, there is no need to send them because they would all be do-nothings.
-		
-		boolean processedExpressionProxies = false;
-		IREMExpressionConnection lclConnection = getConnection();
-		markInTransaction(lclConnection);
-		try {
-			Commands.ValueObject proxyids = null;
-			BeanProxyValueSender sender = null;
-			if (proxycount > 0) {
-				proxyids = createExpressionProxiesValueObject(proxycount, expressionProxies);
-				sender = getExpressionProxiesSender();
-			}
-
-			lclConnection.sync(getREMExpressionID(), proxyids, sender);
-			
-			// If we got this far, then if there are proxies, we need to process these too.
-			if (proxycount > 0)
-				processpulledExpressionProxies(expressionProxies, sender);
-			processedExpressionProxies = true;
-			lclConnection.getFinalValue(workerValue);	// We don't care what it is, we just need to see if there is an error.
-		} catch (CommandErrorException e) {
-			try {
-				if (e.getErrorCode() == ExpressionCommands.EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION) {
-					// Need to turn it into a Throwable.
-					ThrowableProxy t = null;
-					try {
-						getREMBeanProxyFactory().getBeanProxy(e.getValue());	// This will cause a throw to occur, but we don't want it going out, we want to capture it.
-					} catch (ThrowableProxy e1) {
-						t = e1;
-					}
-					throw new REMNoExpressionValueException(t);
-				}
-				getREMBeanProxyFactory().processErrorReturn(e);
-			} catch (CommandException e1) {
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				if (!e.isRecoverable()) {
-					lclConnection.close();
-					throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-				}			
-			}
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			if (!e.isRecoverable()) {
-				lclConnection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		} finally {
-			markEndTransaction(lclConnection);
-			if (!processedExpressionProxies)
-				markAllProxiesNotResolved(expressionProxies);	// We failed before we could process the expression proxies. So mark all as not resolved.
-		}
-	}
-
-	private static class REMBeanTypeExpressionProxy extends ExpressionProxy implements IBeanTypeExpressionProxy {
-		
-		private String typeName;
-		
-		/**
-		 * @param proxyid
-		 * 
-		 * @since 1.1.0
-		 */
-		private REMBeanTypeExpressionProxy(int proxyid, Expression expression) {
-			super(proxyid, BEANTYPE_EXPRESSION_PROXY, expression);
-		}
-		
-		public void setTypeName(String typeName) {
-			this.typeName = typeName;
-		}
-		
-		public String getTypeName() {
-			return typeName;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString()
-		 */
-		public String toString() {
-			return super.toString()+" - "+getTypeName(); //$NON-NLS-1$
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-		 */
-		public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameterTypes) {
-			REMProxyFactoryRegistry registry = (REMProxyFactoryRegistry) expression.getRegistry();
-			return ((REMMethodProxyFactory) registry.getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes);
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String[])
-		 */
-		public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes) {
-			REMProxyFactoryRegistry registry = (REMProxyFactoryRegistry) expression.getRegistry();
-			return ((REMMethodProxyFactory) registry.getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes);
-		}
-		
-		public IProxyMethod getMethodProxy(IExpression expression, String methodName) {
-			return getMethodProxy(expression, methodName, (IProxyBeanType[]) null);
-		}
-
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String)
-		 */
-		public IProxyField getFieldProxy(IExpression expression, String fieldName) {
-			REMProxyFactoryRegistry registry = (REMProxyFactoryRegistry) expression.getRegistry();
-			return ((REMMethodProxyFactory) registry.getMethodProxyFactory()).getFieldProxy(expression, this, fieldName);
-		}
-	}
-	
-	private static class REMMethodExpressionProxy extends ExpressionProxy implements IProxyMethod {
-		
-			/**
-		 * @param proxyid
-		 * @param proxyType
-		 * @param expression
-		 * 
-		 * @since 1.1.0
-		 */
-		private REMMethodExpressionProxy(int proxyid, Expression expression) {
-			super(proxyid, METHOD_EXPRESSION_PROXY, expression);
-		}
-	}
-	
-	private static class REMFieldExpressionProxy extends ExpressionProxy implements IProxyField {
-		
-			/**
-		 * @param proxyid
-		 * @param proxyType
-		 * @param expression
-		 * 
-		 * @since 1.1.0
-		 */
-		private REMFieldExpressionProxy(int proxyid, Expression expression) {
-			super(proxyid, FIELD_EXPRESSION_PROXY, expression);
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#createExpressionProxy(int)
-	 */
-	protected ExpressionProxy createExpressionProxy(int proxyType, int proxyID) {
-		switch (proxyType) {
-			case NORMAL_EXPRESSION_PROXY:
-			default:
-				return new ExpressionProxy(proxyID, NORMAL_EXPRESSION_PROXY, this);
-			
-			case BEANTYPE_EXPRESSION_PROXY:
-				return new REMBeanTypeExpressionProxy(proxyID, this);
-				
-			case METHOD_EXPRESSION_PROXY:
-				return new REMMethodExpressionProxy(proxyID, this);
-				
-			case FIELD_EXPRESSION_PROXY:
-				return new REMFieldExpressionProxy(proxyID, this);
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushAssignmentToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy)
-	 */
-	protected void pushAssignmentToProxy(ExpressionProxy proxy) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push assignment to proxy command is:
-			//	PushExpressionCommand(push assignment to proxy) followed by:
-			//		int: proxy id
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION_VALUE);
-			connection.pushInt(proxy.getProxyID());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushAssignmentToProxy()
-	 */
-	protected void pushAssignmentToProxy() {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of the push assignment command is:
-			//   PushAssignmentCommand.
-			connection.pushExpressionCommand(getREMExpressionID(), (byte) InternalExpressionTypes.ASSIGNMENT_EXPRESSION_VALUE);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-	
-
-	private void pushToExpressionProxy(ExpressionProxy proxy) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to expression proxy command is:
-			//	PushExpressionCommand(push expression proxy to proxy) followed by:
-			//		int: proxy id
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.PUSH_TO_EXPRESSION_PROXY_EXPRESSION_VALUE);
-			connection.pushInt(proxy.getProxyID());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-
-	}
-	
-	private static class BlockBegin extends PendingTransaction {
-		public int blockNumber;
-		
-		public BlockBegin(int blockNumber) {
-			this.blockNumber = blockNumber;
-		}
-		
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push to block begin proxy command is:
-				//	PushExpressionCommand(push block begin proxy to proxy) followed by:
-				//		int: block id
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.BLOCK_BEGIN_EXPRESSION_VALUE);
-				connection.pushInt(blockNumber);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			}			
-		}
-		
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockBeginToProxy(int)
-	 */
-	protected void pushBlockBeginToProxy(int blockNumber) {
-		addPendingTransaction(new BlockBegin(blockNumber));
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockEndToProxy(int)
-	 */
-	protected void pushBlockEndToProxy(int blockNumber) {
-		// See if the top pending transactions is BreakBlock(blockNumber). If it is then the BreakBlock can be thrown away.
-		PendingTransaction topEntry = getPendingEntryFromTop(1);
-		if (topEntry instanceof BlockBreak && ((BlockBreak) topEntry).blockNumber == blockNumber) {
-			popPendingEntry(1);
-			topEntry = getPendingEntryFromTop(1);
-		}
-		// See if the top pending transaction is now BeginBlock(blockNumber). If it is, then this transaction and the block begin
-		// can be thrown away because they are an empty block.
-		if (topEntry instanceof BlockBegin && ((BlockBegin) topEntry).blockNumber == blockNumber) {
-			popPendingEntry(1);
-			return;
-		}
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to block end proxy command is:
-			//	PushExpressionCommand(push block end proxy to proxy) followed by:
-			//		int: block id
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.BLOCK_END_EXPRESSION_VALUE);
-			connection.pushInt(blockNumber);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-	
-	private static class BlockBreak extends PendingTransaction {
-		public int blockNumber;
-		
-		public BlockBreak(int blockNumber) {
-			this.blockNumber = blockNumber;
-		}
-		
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push to block break proxy command is:
-				//	PushExpressionCommand(push block break proxy to proxy) followed by:
-				//		int: block id
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.BLOCK_BREAK_EXPRESSION_VALUE);
-				connection.pushInt(blockNumber);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			}
-		}		
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockBreakToProxy(int)
-	 */
-	protected void pushBlockBreakToProxy(int blockNumber) {
-		// Even if there is no pending block begin for this block, we will pend the break.
-		// This is so that if the break occurred just before the block end, then it can be ignored.
-		addPendingTransaction(new BlockBreak(blockNumber));
-	}
-
-	private static class TryBegin extends PendingTransaction {
-
-		public final int tryNumber;
-		
-		public TryBegin(int tryNumber) {
-			this.tryNumber = tryNumber;
-			
-		}
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push to try begin proxy command is:
-				//	PushExpressionCommand(push try begin to proxy) followed by:
-				//		int: try id
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.TRY_BEGIN_EXPRESSION_VALUE);
-				connection.pushInt(tryNumber);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			}
-		}
-		
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryBeginToProxy(int)
-	 */
-	protected void pushTryBeginToProxy(int tryNumber) {
-		addPendingTransaction(new TryBegin(tryNumber));
-	}
-
-	private static class TryCatch extends PendingTransaction {
-
-		public final int tryNumber;
-		private final IProxyBeanType exceptionType;
-		private final ExpressionProxy ep;
-
-		public TryCatch(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep) {
-			this.tryNumber = tryNumber;
-			this.exceptionType = exceptionType;
-			this.ep = ep;
-		}
-		
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push to try begin proxy command is:
-				//	PushExpressionCommand(push try begin to proxy) followed by:
-				//		int: try id
-				//		object: expression type (as beantype or as expression proxy)
-				//		int: proxy id or (-1 if null).
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.TRY_CATCH_EXPRESSION_VALUE);
-				connection.pushInt(tryNumber);
-				remExpression.fillProxy(exceptionType, remExpression.workerValue);
-				connection.pushValueObject(remExpression.workerValue);
-				if (ep != null)
-					connection.pushInt(ep.getProxyID());
-				else
-					connection.pushInt(-1);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			} catch (CommandException e) {
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				if (!e.isRecoverable()) {
-					connection.close();
-					remExpression.throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-				}			
-			}
-		}
-		
-	}
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryCatchClauseToProxy(int, org.eclipse.jem.internal.proxy.core.IProxyBeanType, org.eclipse.jem.internal.proxy.core.ExpressionProxy)
-	 */
-	protected void pushTryCatchClauseToProxy(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep) {
-		addPendingTransaction(new TryCatch(tryNumber, exceptionType, ep));
-	}
-
-	private static class TryFinally extends PendingTransaction {
-		
-		public final int tryNumber;
-
-		public TryFinally(int tryNumber) {
-			this.tryNumber = tryNumber;
-			
-		}
-
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push to try begin proxy command is:
-				//	PushExpressionCommand(push try finally to proxy) followed by:
-				//		int: try id
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.TRY_FINALLY_EXPRESSION_VALUE);
-				connection.pushInt(tryNumber);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			}
-		}
-		
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryFinallyClauseToProxy(int)
-	 */
-	protected void pushTryFinallyClauseToProxy(int tryNumber) {
-		addPendingTransaction(new TryFinally(tryNumber));
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryEndToProxy(int)
-	 */
-	protected void pushTryEndToProxy(int tryNumber) {
-		// This is a little tricky. We need to find if there is nothing but try/catch/finally for this tryNumber on the pending
-		// transactions up to the try begin, if there is nothing else, then we can throw the entire try away. That
-		// means there was no code at all in any of the try/catch/finally blocks.
-		int fromTop = 0;
-		while (true) {
-			PendingTransaction topEntry = getPendingEntryFromTop(++fromTop);
-			if (topEntry instanceof TryFinally) {
-				if (((TryFinally) topEntry).tryNumber != tryNumber)
-					break;	// We met a finally that wasn't ours, so entire try group must be sent.
-			} else if (topEntry instanceof TryCatch) {
-				if (((TryCatch) topEntry).tryNumber != tryNumber)
-					break;	// We met a catch that wasn't ours, so entire try group must be sent.
-			} else if (topEntry instanceof TryBegin) {
-				if (((TryBegin) topEntry).tryNumber == tryNumber) {
-					// We've met our try begin, and nothing but empty catch/finally in between, so the entire group can be thrown away
-					popPendingEntry(fromTop);
-					return;
-				} else
-					break;	// We've hit a try begin that wasn't ours, so the entire try group must be sent.	
-			} else
-				break;	// We've hit something other than our try group, so process everything.
-		}
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to try begin proxy command is:
-			//	PushExpressionCommand(push try end to proxy) followed by:
-			//		int: try id
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.TRY_END_EXPRESSION_VALUE);
-			connection.pushInt(tryNumber);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushThrowToProxy()
-	 */
-	protected void pushThrowToProxy() {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to try begin proxy command is:
-			//	PushExpressionCommand(push throw to proxy)
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.THROW_EXPRESSION_VALUE);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushRethrowToProxy(int)
-	 */
-	protected void pushRethrowToProxy(int tryNumber) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to rethow proxy command is:
-			//	PushExpressionCommand(push rethrow to proxy)
-			//		int: try id
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.RETHROW_EXPRESSION_VALUE);
-			connection.pushInt(tryNumber);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBeanTypeToProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeExpressionProxy)
-	 */
-	protected void pushBeanTypeToProxy(IBeanTypeExpressionProxy proxy) {
-		// Push beantype to proxy is sent out of sequence without respect to where in expression we are,
-		// so no need to handle pending transactions at this point. They would not affect the result
-		// of this call.
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to beanType proxy command is:
-			//	PushExpressionCommand(push bean type expression proxy)
-			//		int: proxy id
-			//		string: typename
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.PUSH_BEANTYPE_EXPRESSIONPROXY_EXPRESSION_VALUE);
-			REMBeanTypeExpressionProxy ep = (REMBeanTypeExpressionProxy) proxy;
-			connection.pushInt(ep.getProxyID());
-			connection.pushString(ep.getTypeName());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushMethodToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy, org.eclipse.jem.internal.proxy.core.IProxyBeanType, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-	 */
-	protected void pushMethodToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes) {
-		// Push method to proxy is sent out of sequence without respect to where in expression we are,
-		// so no need to handle pending transactions at this point. They would not affect the result
-		// of this call.
-
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to method proxy command is:
-			//	PushExpressionCommand(push method type expression proxy)
-			//		int: proxy id
-			//		ValueObject: containing the rendered bean type proxy or the expression proxy for the declaring type
-			//		string: method name
-			//		int: number of parameter types
-			//		ValueObject(s): containing the rendered bean type proxy or the expression proxy for the parameter types.
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.PUSH_METHOD_EXPRESSIONPROXY_EXPRESSION_VALUE);
-			connection.pushInt(proxy.getProxyID());
-			fillProxy(declaringType, workerValue);
-			connection.pushValueObject(workerValue);
-			connection.pushString(methodName);
-			if (parameterTypes == null || parameterTypes.length == 0)
-				connection.pushInt(0);
-			else {
-				connection.pushInt(parameterTypes.length);
-				for (int i = 0; i < parameterTypes.length; i++) {
-					fillProxy(parameterTypes[i], workerValue);
-					connection.pushValueObject(workerValue);					
-				}
-			}
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushFieldToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy, org.eclipse.jem.internal.proxy.core.IProxyBeanType, java.lang.String)
-	 */
-	protected void pushFieldToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String fieldName) {
-		// Push field to proxy is sent out of sequence without respect to where in expression we are,
-		// so no need to handle pending transactions at this point. They would not affect the result
-		// of this call.
-
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to field proxy command is:
-			//	PushExpressionCommand(push field type expression proxy)
-			//		int: proxy id
-			//		ValueObject: containing the rendered bean type proxy or the expression proxy for the declaring type
-			//		string: field name
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.PUSH_FIELD_EXPRESSIONPROXY_EXPRESSION_VALUE);
-			connection.pushInt(proxy.getProxyID());
-			fillProxy(declaringType, workerValue);
-			connection.pushValueObject(workerValue);
-			connection.pushString(fieldName);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-	
-	/**
-	 * Get the map of IProxyMethods for a beantype. Meant to be used only in conjunction with REMProxyConstants.
-	 * It is here so the REMProxyConstants can store pending proxies per expression.
-	 * 
-	 * @param beanType
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public Map getMethods(IProxyBeanType beanType) {
-		if (methodsCache == null)
-			methodsCache = new HashMap();
-		Map methods = (Map) methodsCache.get(beanType.getTypeName());
-		if(methods == null){
-			methods = new HashMap(20);
-			methodsCache.put(beanType.getTypeName(),methods);
-		}
-		return methods;	
-	}
-	
-	/**
-	 * Get the map of IProxyFields for a beantype. Meant to be used only in conjunction with REMProxyConstants.
-	 * It is here so the REMProxyConstants can store pending proxies per expression.
-	 * 
-	 * @param beanType
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public Map getFields(IProxyBeanType beanType) {
-		if (fieldsCache == null)
-			fieldsCache = new HashMap();
-		Map fields = (Map) fieldsCache.get(beanType.getTypeName());
-		if(fields == null){
-			fields = new HashMap(20);
-			fieldsCache.put(beanType.getTypeName(),fields);
-		}
-		return fields;	
-	}
-	
-	/**
-	 * Get the map of IProxyBeanTypes for a beantype name. Meant to be used only in conjunction with REMSgtandardBeanTypeFactory.
-	 * It is here so the REMStandardBeanTypeFactory can store pending proxies per expression.
-	 * 
-	 * @param beanType
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyBeanType getBeanType(String beanTypeName) {
-		if (beanTypeCache == null)
-			beanTypeCache = new HashMap();
-		return (IProxyBeanType) beanTypeCache.get(beanTypeName);
-	}
-	
-	/**
-	 * Add the beantype expression proxy to the map of bean type expression proxies. Used in conjunction with REMStandardBeanTypeFactory.
-	 * It is here so the REMStandardBeanTypeFactory can store pending proxies per expression.
-	 * @param beanTypeName
-	 * @param beantype
-	 * 
-	 * @since 1.1.0
-	 */
-	public void addBeanType(String beanTypeName, IProxyBeanType beantype) {
-		beanTypeCache.put(beanTypeName, beantype);
-	}
-	
-	/**
-	 * Remove the beantype expression proxy from the map. This is called because there was a rollback due to an endmark.
-	 * @param beanTypeName
-	 * 
-	 * @since 1.1.0
-	 */
-	public void removeBeanType(String beanTypeName) {
-		beanTypeCache.remove(beanTypeName);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushIfTestToProxy()
-	 */
-	protected void pushIfTestToProxy() {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push if test to proxy command is:
-			//	PushExpressionCommand(push if test to proxy)
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.IF_TEST_EXPRESSION_VALUE);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushIfElseToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InternalIfElseOperandType)
-	 */
-	protected void pushIfElseToProxy(InternalIfElseOperandType clauseType) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push conditional to proxy command is:
-			//	PushExpressionCommand(push if/else clause to proxy) followed by:
-			//		byte: clause type
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.IF_ELSE_EXPRESSION_VALUE);
-			connection.pushByte((byte) clauseType.getValue());
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushNewInstanceToProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushNewInstanceToProxy(String initializationString, IProxyBeanType resultType) {
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push new instance from initstring to proxy command is:
-			//	PushExpressionCommand(push new instance to proxy) followed by:
-			//		string: init string
-			//		ValueObject: containing the rendered bean type proxy or the expression proxy for the declaring type
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.NEW_INSTANCE_VALUE);
-			connection.pushString(initializationString);
-			fillProxy(resultType, workerValue);
-			connection.pushValueObject(workerValue);			
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			if (!e.isRecoverable()) {
-				connection.close();
-				throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-			}			
-		}
-	}
-
-	private static class Mark extends PendingTransaction {
-		public int markID;
-		
-		public Mark(int markID) {
-			this.markID = markID;
-		}
-		
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push mark to proxy command is:
-				//	PushExpressionCommand(push mark to proxy) followed by:
-				//		int: markID
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.MARK_VALUE);
-				connection.pushInt(markID);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			}
-		}
-		
-	}
-	
-	protected void pushMarkToProxy(int markID) {
-		addPendingTransaction(new Mark(markID));
-	}
-
-	protected void pushEndmarkToProxy(int markID, boolean restore) {
-		// See if the top pending transaction is now Mark(markID). If it is, then this transaction and the mark begin
-		// can be thrown away because they are an empty block.
-		PendingTransaction topEntry = getPendingEntryFromTop(1);
-		if (topEntry instanceof Mark && ((Mark) topEntry).markID == markID) {
-			popPendingEntry(1);
-			return;
-		}
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push end mark to proxy command is:
-			//	PushExpressionCommand(push end mark to proxy) followed by:
-			//		int: markID
-			//		boolean: restore
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.ENDMARK_VALUE);
-			connection.pushInt(markID);
-			connection.pushBoolean(restore);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-	}
-
-	// This is the expression processor controller used to transfer.
-	// This is the guy that maintains continuity of the transaction as
-	// it is passed from one connection to another.
-	protected IBeanProxy expressionProcesserController;	
-	protected void pushBeginTransferThreadToProxy() throws ThrowableProxy {
-		// If the controller is not null, that means we had already requested a transfer
-		// but had not used it in this thread so there is no need to do anything. It
-		// will be handled when switching back to the other thread.
-		// If the connection is null, no need to do anything since there is no connection
-		// to transfer.
-		if (connection != null && expressionProcesserController == null) {
-			IREMExpressionConnection lclConnection = getConnection();
-			markInTransaction(lclConnection);
-			try {
-				workerValue.set();
-				lclConnection.transferExpression(getREMExpressionID(), workerValue);
-				expressionProcesserController = getREMBeanProxyFactory().getBeanProxy(workerValue);
-				getREMRegistry().returnConnection(lclConnection);
-				this.connection = null;
-			} catch (CommandException e) {
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				if (!e.isRecoverable()) {
-					lclConnection.close();
-					throwIllegalStateException(COMMAND_EXCEPTION_MSG);
-				}			
-			} finally {
-				markEndTransaction(lclConnection);
-			}
-		}
-	}
-
-	protected void pushTransferThreadToProxy() {
-		// Don't need to do anything. The next time we need to push data across, we will get a connection and the getConnection()
-		// will hook up the expression processor controller for us. This way if nothing happens in this thread then we won't
-		// waste communication time on it.
-	}
-
-	private static class SubexpressionBegin extends PendingTransaction {
-		public int subexpressionNumber;
-		
-		public SubexpressionBegin(int subexpressionNumber) {
-			this.subexpressionNumber = subexpressionNumber;
-		}
-		
-		public void pushTransaction(REMExpression remExpression) {
-			IREMExpressionConnection connection = remExpression.getConnection();
-			try {
-				// Format of push to subexpression begin proxy command is:
-				//	PushExpressionCommand(push subexpression begin proxy to proxy) followed by:
-				//		int: subexpression id
-				connection.pushExpressionCommand(remExpression.getREMExpressionID(), (byte)InternalExpressionTypes.SUBEXPRESSION_BEGIN_EXPRESSION_VALUE);
-				connection.pushInt(subexpressionNumber);
-			} catch (IOException e) {
-				connection.close();
-				ProxyPlugin.getPlugin().getLogger().log(e);
-				remExpression.markInvalid(e.getLocalizedMessage());
-				remExpression.throwIllegalStateException(IO_EXCEPTION_MSG);
-			}			
-		}
-		
-	}
-
-	protected void pushSubexpressionBeginToProxy(int subexpressionNumber) {
-		addPendingTransaction(new SubexpressionBegin(subexpressionNumber));
-	}
-
-	protected void pushSubexpressionEndToProxy(int subexpressionNumber) {
-		// See if the top pending transactions is SubexpressionBegin(subexpressionNumber). If it is then the SubexpressionBegin can be thrown away.
-		PendingTransaction topEntry = getPendingEntryFromTop(1);
-		if (topEntry instanceof SubexpressionBegin && ((SubexpressionBegin) topEntry).subexpressionNumber == subexpressionNumber) {
-			popPendingEntry(1);
-			return;
-		}
-		processPendingTransactions();
-		IREMExpressionConnection connection = getConnection();
-		try {
-			// Format of push to block end proxy command is:
-			//	PushExpressionCommand(push subexpression end proxy to proxy) followed by:
-			//		int: subexpression id
-			connection.pushExpressionCommand(getREMExpressionID(), (byte)InternalExpressionTypes.SUBEXPRESSION_END_EXPRESSION_VALUE);
-			connection.pushInt(subexpressionNumber);
-		} catch (IOException e) {
-			connection.close();
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			markInvalid(e.getLocalizedMessage());
-			throwIllegalStateException(IO_EXCEPTION_MSG);
-		}
-		}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFieldProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFieldProxy.java
deleted file mode 100644
index 20bbd4f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFieldProxy.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMFieldProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-final class REMFieldProxy extends REMAccessibleObjectProxy implements IFieldProxy {
-	private IBeanTypeProxy fFieldType;
-
-	REMFieldProxy(REMProxyFactoryRegistry aRegistry, Integer anID) {
-		super(aRegistry, anID);
-	}
-
-	/**
-	 * Return the type of the field.
-	 */
-	public IBeanTypeProxy getFieldType() {
-		if (fFieldType == null)
-			fFieldType =
-				(IBeanTypeProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetType().invokeCatchThrowableExceptions(
-					this);
-
-		return fFieldType;
-	}
-
-	/**
-	 * Release the proxy, i.e. mark it invalid.
-	 */
-	public void release() {
-		fFieldType = null;
-		super.release();
-	}
-
-	/**
-	 * Get the value of this field from the subject
-	 */
-	public IBeanProxy get(IBeanProxy subject) throws ThrowableProxy {
-		// Format of getter parms is: (Object (subject)).
-		// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
-		// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-		IBeanTypeProxy fieldType = getFieldType();
-		if (!fieldType.isPrimitive()) {
-			// Use standard getter.
-			return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGet()).invoke(this, subject);
-		} else {
-			// Use the correct primitive getter.
-			int id = ((IREMBeanProxy) fieldType).getID().intValue();
-			switch (id) {
-				case Commands.BYTE_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetByte()).invoke(this, subject);
-				case Commands.BOOLEAN_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetBoolean()).invoke(
-						this,
-						subject);
-				case Commands.CHARACTER_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetChar()).invoke(this, subject);
-				case Commands.DOUBLE_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetDouble()).invoke(
-						this,
-						subject);
-				case Commands.FLOAT_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetFloat()).invoke(
-						this,
-						subject);
-				case Commands.INTEGER_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetInt()).invoke(this, subject);
-				case Commands.LONG_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetLong()).invoke(this, subject);
-				case Commands.SHORT_TYPE :
-					return ((IREMMethodProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getFieldGetShort()).invoke(
-						this,
-						subject);
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Set the value of this field in this subject to this value.
-	 */
-	public void set(IBeanProxy subject, IBeanProxy value) throws ThrowableProxy {
-		REMStandardBeanProxyConstants.getConstants(fFactory).getFieldSet().invoke(this, new IBeanProxy[] { subject, value });
-	}
-
-	/**
-	 * The type proxy is constant proxy out of the method factory.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMMethodProxyFactory) fFactory.getMethodProxyFactory()).fieldType;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFieldTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFieldTypeProxy.java
deleted file mode 100644
index e0862c2..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFieldTypeProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMFieldTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * BeanType Proxy for Method class.
- */
-
-final class REMFieldTypeProxy extends REMAbstractBeanTypeProxy {
-
-REMFieldTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy accessibleTypeProxy) {
-	super(aRegistry, new Integer(Commands.FIELD_CLASS), java.lang.reflect.Field.class.getName(), accessibleTypeProxy);
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the accessible object types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Specialized from REMAbstractBeanTypeProxy to ensure Constructor proxies are created correctly.
- */
-public IREMBeanProxy newBeanProxy(Integer objectID) {
-	return new REMFieldProxy(fRegistry, objectID);
-}
-
-/**
- * Note: Since new instances of Constructor are never done through a default ctor,
- * this function is not supported.
- */
-public IBeanProxy newInstance() { 
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Note: Since new instances of Constructor are never done through an initialization string,
- * this function is not supported.
- */
-public IBeanProxy newInstance(String initializationString) {
-	throw new UnsupportedOperationException();
-}		
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatClassBeanProxy.java
deleted file mode 100644
index f5957c4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatClassBeanProxy.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMFloatClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote proxy implementation of INumberBeanProxy for Float.class
- */
-class REMFloatClassBeanProxy extends REMNumberBeanProxy {
-
-REMFloatClassBeanProxy(REMProxyFactoryRegistry aRegistry, Float aFloat) {
-	super(aRegistry, aFloat);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).floatClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set((Float) numberValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatClassBeanTypeProxy.java
deleted file mode 100644
index b443b5c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatClassBeanTypeProxy.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMFloatClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypePRoxy for Float.class
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMFloatClassBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMFloatClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.FLOAT_CLASS), Float.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMFloatClassBeanProxy(aRegistry, new Float(0F));	
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createFloatBeanProxy(Float aFloat) {
-	return (aFloat.floatValue() != 0F) ?
-		new REMFloatClassBeanProxy(fRegistry, aFloat) : zeroProxy;
-}
-
-/**
- * Generic way to create an Float proxy, however, the Number must be a Float.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createFloatBeanProxy((Float) aNumber);
-}
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createFloatBeanProxy(new Float(value.aFloat));
-}	
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatTypeBeanProxy.java
deleted file mode 100644
index aea0e18..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatTypeBeanProxy.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMFloatTypeBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of INumberBeanProxy for the primitive "float".
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class REMFloatTypeBeanProxy extends REMConstantBeanProxy implements INumberBeanProxy {
-	private final float fFloat;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMFloatTypeBeanProxy(REMProxyFactoryRegistry aRegistry, float aFloat) {
-	super(aRegistry);
-	fFloat = aFloat;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMFloatTypeBeanProxy)
-		return fFloat == ((REMFloatTypeBeanProxy) anObject).floatValue();
-	if (anObject instanceof Double)
-		return fFloat == ((Float) anObject).floatValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMFloatTypeBeanProxy)
-		return fFloat == ((REMFloatTypeBeanProxy) aBeanProxy).floatValue();
-	return false;
-}
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return (byte) fFloat;
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fFloat;
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fFloat;
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return (int) fFloat;
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return (long) fFloat;
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return new Float(fFloat);
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return (short) fFloat;
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return String.valueOf(fFloat);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).floatType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fFloat);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatTypeBeanTypeProxy.java
deleted file mode 100644
index 3337ad5..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMFloatTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMFloatTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Float.TYPE.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMFloatTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMFloatTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.FLOAT_TYPE), Float.TYPE.getName());
-	
-	// Create the cached values
-	zeroProxy = new REMFloatTypeBeanProxy(aRegistry, 0F);		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createFloatBeanProxy(float aFloat) {
-	return (aFloat != 0F) ?
-		new REMFloatTypeBeanProxy(fRegistry, aFloat) : zeroProxy;
-}
-
-/**
- * newInstance method. float is a primitive, so the standard way won't work.
- * Return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createFloatBeanProxy(value.aFloat);
-}
-
-/**
- * Short cut for newInstance where the string follows the
- * specific pattern we expect. That way it won't be necessary to ship over to the vm 
- * to process it.
- *
- * The pattern it can accept is:
- * 	1) (float) validNumber - number can be any number because (float) explicitly casts it down.
- *	2) validNumber
- * It will use the decode function of float to determine the valid number.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	String trim = initializationString.trim();
-	if (trim.length() == 0)
-		return super.newInstance(initializationString);	
-	float aFloat;
-	if (trim.startsWith("(float)")) { //$NON-NLS-1$
-		Number v = parseString(trim.substring("(float)".length()).trim()); //$NON-NLS-1$
-		if (v != null)
-			aFloat = v.floatValue();
-		else
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-	} else {
-		try {
-			aFloat = Float.valueOf(initializationString).floatValue();	// See if valid float format.
-		} catch (NumberFormatException e) {
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-		}
-	}
-
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(aFloat);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInitErrorBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInitErrorBeanTypeProxy.java
deleted file mode 100644
index f638fbb..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInitErrorBeanTypeProxy.java
+++ /dev/null
@@ -1,469 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMInitErrorBeanTypeProxy.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:39:07 $ 
- */package org.eclipse.jem.internal.proxy.remote;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * A special bean type proxy. It is for those bean types that had an instantiation error while being initialized. It is so we have the message. All
- * other actions against it will fail.
- * 
- * @author richkulp
- */
-public class REMInitErrorBeanTypeProxy implements IREMBeanTypeProxy {
-
-	protected final String initializationError;
-
-	protected final REMProxyFactoryRegistry registry;
-
-	protected final String classname;
-
-	/**
-	 * Constructor for REMInitErrorBeanTypeProxy.
-	 */
-	public REMInitErrorBeanTypeProxy(REMProxyFactoryRegistry registry, String initializationError, String classname) {
-		super();
-		this.registry = registry;
-		this.initializationError = initializationError;
-		this.classname = classname;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanTypeProxy#newBeanProxy(java.lang.Integer)
-	 */
-	public IREMBeanProxy newBeanProxy(Integer anID) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanTypeProxy#newBeanTypeForClass(java.lang.Integer, java.lang.String, boolean)
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(java.lang.String[])
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IConstructorProxy[] getConstructors() {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(java.lang.String[])
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IConstructorProxy[] getDeclaredConstructors() {
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IFieldProxy[] getFields() {
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IFieldProxy[] getDeclaredFields() {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getFieldProxy(java.lang.String)
-	 */
-	public IFieldProxy getFieldProxy(String fieldName) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getDeclaredFieldProxy(java.lang.String)
-	 */
-	public IFieldProxy getDeclaredFieldProxy(String fieldName) {
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IMethodProxy[] getMethods() {
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IMethodProxy[] getDeclaredMethods() {
-		return null;
-	}
-
-	
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String)
-	 */
-	public IMethodProxy getMethodProxy(String methodName) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, java.lang.String[])
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, java.lang.String)
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String argumentClassName) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(java.lang.String, java.lang.String[])
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getNullConstructorProxy()
-	 */
-	public IConstructorProxy getNullConstructorProxy() {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#getProxyFactoryRegistry()
-	 */
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return registry;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getSuperBeanTypeProxy()
-	 */
-	public IBeanTypeProxy getSuperBeanTypeProxy() {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getTypeName()
-	 */
-	public String getTypeName() {
-		return classname;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getFormalTypeName()
-	 */
-	public String getFormalTypeName() {
-		return getTypeName();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isArray()
-	 */
-	public boolean isArray() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isInterface()
-	 */
-	public boolean isInterface() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isPrimitive()
-	 */
-	public boolean isPrimitive() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isKindOf(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy)
-	 */
-	public boolean isKindOf(IBeanTypeProxy aBeanProxyType) {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance()
-	 */
-	public IBeanProxy newInstance() throws ThrowableProxy {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance(java.lang.String)
-	 */
-	public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInitializationError()
-	 */
-	public String getInitializationError() {
-		return initializationError;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanProxy#getID()
-	 */
-	public Integer getID() {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanProxy#release()
-	 */
-	public void release() {
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanProxy#renderBean(org.eclipse.jem.internal.proxy.common.remote.Commands.ValueObject)
-	 */
-	public void renderBean(Commands.ValueObject renderInto) {
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#getTypeProxy()
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#toBeanString()
-	 */
-	public String toBeanString() {
-		return ""; //$NON-NLS-1$
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#isValid()
-	 */
-	public boolean isValid() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		return this == aBeanProxy; // This is place holder anyway. So only identical if same proxy.
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IInvokable getInvokable(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, java.lang.String)
-	 */
-	public IInvokable getInvokable(String methodName, String argumentClassName) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, java.lang.String[])
-	 */
-	public IInvokable getInvokable(String methodName, String[] argumentClassNames) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String)
-	 */
-	public IInvokable getInvokable(String methodName) {
-		return null;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameters) {
-		return null;	// Since this guy is invalid, we can't return a method.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes) {
-		return null;
-	}
-	
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName) {
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String)
-	 */
-	public IProxyField getFieldProxy(IExpression expression, String fieldName) {
-		return null;
-	}
-	
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerClassBeanProxy.java
deleted file mode 100644
index 6825c4f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerClassBeanProxy.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMIntegerClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Proxy for Integers. Since Integers were first implemented
- * in the VCE, and because they are often referenced, we've created
- * a subclass to handle them. That way we wouldn't need to change
- * everyone that was using the IIntegerProxy interface.
- * Creation date: (08/31/00 11:28:48 AM)
- * @author: Administrator
- */
-class REMIntegerClassBeanProxy extends REMNumberBeanProxy implements IIntegerBeanProxy {
-
-REMIntegerClassBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anInteger) {
-	super(aRegistry, anInteger);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).integerClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set((Integer) numberValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerClassBeanTypeProxy.java
deleted file mode 100644
index c3436fd..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerClassBeanTypeProxy.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMIntegerClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of INumberBeanProxy for Integer.class.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMIntegerClassBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final IIntegerBeanProxy zeroProxy;
-	private final IIntegerBeanProxy oneProxy;
-	private final IIntegerBeanProxy twoProxy;
-	private final IIntegerBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMIntegerClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.INTEGER_CLASS), Integer.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(0));	
-	oneProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(1));
-	twoProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(2));
-	threeProxy = new REMIntegerClassBeanProxy(aRegistry, new Integer(3));
-		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-IIntegerBeanProxy createIntegerBeanProxy(Integer anInteger) {
-	switch(anInteger.intValue()) {
-		case 0: return zeroProxy;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new REMIntegerClassBeanProxy(fRegistry, anInteger);
-	}
-}
-
-/**
- * Generic way to create an Integer proxy, however, the Number must be an Integer.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createIntegerBeanProxy((Integer) aNumber);
-}	
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createIntegerBeanProxy(new Integer(value.anInt));
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerTypeBeanProxy.java
deleted file mode 100644
index 4872783..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerTypeBeanProxy.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMIntegerTypeBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of IIntegerBeanProxy for the primitive "int".
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class REMIntegerTypeBeanProxy extends REMConstantBeanProxy implements IIntegerBeanProxy {
-	private final int fInt;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMIntegerTypeBeanProxy(REMProxyFactoryRegistry aRegistry, int anInt) {
-	super(aRegistry);
-	fInt = anInt;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMIntegerTypeBeanProxy)
-		return fInt == ((REMIntegerTypeBeanProxy) anObject).intValue();
-	if (anObject instanceof Integer)
-		return fInt == ((Integer) anObject).intValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMIntegerTypeBeanProxy)
-		return fInt == ((REMIntegerTypeBeanProxy) aBeanProxy).intValue();
-	return false;
-}
-
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return (byte) fInt;
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fInt;
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fInt;
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return fInt;
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return fInt;
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return new Integer(fInt);
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return (short) fInt;
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return String.valueOf(fInt);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).intType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fInt);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerTypeBeanTypeProxy.java
deleted file mode 100644
index ccc724a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMIntegerTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMIntegerTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Integer.TYPE.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMIntegerTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final IIntegerBeanProxy zeroProxy;
-	private final IIntegerBeanProxy oneProxy;
-	private final IIntegerBeanProxy twoProxy;
-	private final IIntegerBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMIntegerTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.INTEGER_TYPE), Integer.TYPE.getName());
-	
-	// Create the cached values
-	zeroProxy = new REMIntegerTypeBeanProxy(aRegistry, 0);	
-	oneProxy = new REMIntegerTypeBeanProxy(aRegistry, 1);
-	twoProxy = new REMIntegerTypeBeanProxy(aRegistry, 2);
-	threeProxy = new REMIntegerTypeBeanProxy(aRegistry, 3);
-		
-}
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- * Use the cache to see if the value is being held before creating a new one
- */
-IIntegerBeanProxy createIntegerBeanProxy(int anInt) {
-
-	switch(anInt) {
-		case 0: return zeroProxy;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new REMIntegerTypeBeanProxy(fRegistry, anInt);
-	}
-}
-
-/**
- * newInstance method. integer is a primitive, so the standard way won't work.
- * Return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createIntegerBeanProxy(value.anInt);
-}
-
-/**
- * Short cut for newInstance where the string follows the
- * specific pattern we expect. That way it won't be necessary to ship over to the vm 
- * to process it.
- *
- * The pattern it can accept is:
- * 	1) (int) validNumber - number can be any number because (byte) explicitly casts it down.
- *	2) validNumber
- * It will use the decode function of int to determine the valid number.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	String trim = initializationString.trim();
-	if (trim.length() == 0)
-		return super.newInstance(initializationString);	
-	int anInt;
-	if (trim.startsWith("(int)")) { //$NON-NLS-1$
-		Number v = parseString(trim.substring("(int)".length()).trim()); //$NON-NLS-1$
-		if (v != null)
-			anInt = v.intValue();
-		else
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-	} else {
-		try {
-			anInt = Integer.decode(trim).intValue();	// See if valid int format.
-		} catch (NumberFormatException e) {
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-		}
-	}
-
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(anInt);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInterfaceBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInterfaceBeanTypeProxy.java
deleted file mode 100644
index 34375b6..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInterfaceBeanTypeProxy.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMInterfaceBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Default beantype proxy for an interface.
- */
-
-public class REMInterfaceBeanTypeProxy extends REMAbstractBeanTypeProxy {
-	
-	protected REMInterfaceBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname) {
-		super(aRegistry, anID, aClassname, null);
-	}
-	
-	/** 
-	 * Interfaces are interfaces.
-	 */
-	public boolean isInterface() {
-		return true;
-	}
-	
-	/**
-	 * Create a new bean proxy with the specified id.
-	 *
-	 * For all of the interface types, this is an invalid operation. 
-	 */
-	public IREMBeanProxy newBeanProxy(Integer anID) {
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * For all of the interface types, you can't create a newBeanType for subclasses since
-	 * interface aren't subclassable, only extendable.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstact) {
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Note: Since new instances of interfaces can never be done,
-	 * this function is not supported.
-	 */
-	public IBeanProxy newInstance() { 
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * newInstance(initializationString) is valid because it can be used to create
-	 * an instance of an implementation of the interface.
-	 */
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInvokable.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInvokable.java
deleted file mode 100644
index 258ee8b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMInvokable.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMInvokable.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.IInvokable;
- 
-
-/**
- * Remote Invokable. This invokes on the remote vm, but it doesn't use a method proxy. Instead
- * it sends the information to get the method to the remote vm along with the parms. That way
- * it will do the lookup on the remote vm and we don't have the overhead of two calls, one to
- * get the methodproxy and the other to actually do the invoke. This should typically be used
- * only for infrequent calls so that cache of the method proxy is not needed.
- * 
- * @since 1.0.0
- */
-class REMInvokable implements IInvokable {
-
-	protected final IREMBeanTypeProxy beanType;	// Beantype to get method from.
-	protected final String methodName;	// Method name
-	protected final IBeanTypeProxy[] methodArgTypes;	// Argument types (or null if no arguments).
-	protected final REMProxyFactoryRegistry factory;	// Factory for this invokable
-	
-	
-	REMInvokable(IREMBeanTypeProxy beanType, String methodName, IBeanTypeProxy[] methodArgTypes) {
-		this.beanType = beanType;
-		this.methodName = methodName;
-		this.methodArgTypes = methodArgTypes;
-		this.factory = (REMProxyFactoryRegistry) beanType.getProxyFactoryRegistry();
-	}
-	
-	public IBeanProxy invoke(IBeanProxy subject) throws ThrowableProxy {
-		return invoke(subject, (IBeanProxy[]) null);
-	}
-
-	public IBeanProxy invoke(IBeanProxy subject, IBeanProxy[] parms) throws ThrowableProxy {
-		return invokeWithParms(subject, parms);
-	}
-
-	/**
-	 * The internal method that allows mixture of constants (e.g. String) with bean proxies.
-	 * A parm value can be a REMMethodProxy.ParmArray. This means this parm is an array that
-	 * needs to have a ValueRetriever created for it. This is used if the array has ID's in
-	 * it and is not an existing array on the server or all constant values.
-	 *
-	 * NOTE: It is assumed that all IBeanTypeProxies of the parms have already been retrieved.
-	 *       It should still work, but it could be asking for them in the middle of the request
-	 *       if they are not first gotton.
-	 *
-	 */
-	public IBeanProxy invokeWithParms(IBeanProxy subject, final Object[] parms) throws ThrowableProxy {
-		IREMConnection connect = factory.getFreeConnection();
-		REMStandardBeanProxyFactory proxyFactory = (REMStandardBeanProxyFactory) factory.getBeanProxyFactory();
-		proxyFactory.startTransaction(); // This is definately a transaction, so start it.
-		try {
-			// First need to send the method info.
-			Commands.ValueObject classValue = new Commands.ValueObject();
-			beanType.renderBean(classValue);
-			
-			Commands.ValueObject parmTypesValue = new Commands.ValueObject();
-			if (methodArgTypes != null) {
-				class Retriever implements Commands.ValueRetrieve {
-					int index = 0;
-					Object[] array;
-					Commands.ValueObject worker = new Commands.ValueObject();
-
-					public Retriever(Object[] anArray) {
-						array = anArray;
-					}
-
-					public Commands.ValueObject nextValue() {
-						Object parm = array[index++];
-						((IREMBeanTypeProxy) parm).renderBean(worker);
-						return worker;
-					}
-				};
-
-				parmTypesValue.setArrayIDS(new Retriever(methodArgTypes), methodArgTypes.length, Commands.CLASS_CLASS); // Create Class[].
-			}
-			
-			
-			// Now we start building the actual invocation.
-			
-			Commands.ValueObject subjectValue = new Commands.ValueObject();
-			if (subject != null)
-				 ((IREMBeanProxy) subject).renderBean(subjectValue);
-
-			Commands.ValueObject parmsValue = new Commands.ValueObject();
-
-			if (parms != null) {
-				// Have a local definition of the retriever so that the retriever can create
-				// another one of itself if necessary.
-				final IStandardBeanTypeProxyFactory typeFactory = factory.getBeanTypeProxyFactory();
-
-				class Retriever implements Commands.ValueRetrieve {
-					int index = 0;
-					Object[] array;
-					Commands.ValueObject worker = new Commands.ValueObject();
-
-					public Retriever(Object[] anArray) {
-						array = anArray;
-					}
-
-					public Commands.ValueObject nextValue() {
-						Object parm = array[index++];
-						if (parm != null)
-							if (parm instanceof IREMBeanProxy)
-								 ((IREMBeanProxy) parm).renderBean(worker);
-							else if (parm instanceof TransmitableArray) {
-								// It is another array, create a new retriever.
-								worker.setArrayIDS(
-									new Retriever(((TransmitableArray) parm).array),
-									((TransmitableArray) parm).array.length,
-									((TransmitableArray) parm).componentTypeID);
-							} else {
-								// It's an object. Need to get bean type so that we can send it.
-								IREMBeanProxy type = (IREMBeanProxy) typeFactory.getBeanTypeProxy(parm.getClass().getName());
-								if (type == null)
-									throw new IllegalArgumentException();
-								int classID = type.getID().intValue();
-								worker.setAsObject(parm, classID);
-							}
-						else
-							worker.set();
-						return worker; 
-					}
-				};
-
-				parmsValue.setArrayIDS(new Retriever(parms), parms.length, Commands.OBJECT_CLASS); // Create Object[].
-			}
-
-			Commands.ValueObject returnValue = new Commands.ValueObject();
-			try {
-				invoke(connect, proxyFactory, classValue, parmTypesValue, subjectValue, parmsValue, returnValue);
-				return proxyFactory.getBeanProxy(returnValue);
-			} catch (CommandException e) {
-				if (!e.isRecoverable()) {
-					// Close the connection and try again.
-					factory.closeConnection(connect);
-					connect = null;
-					connect = factory.getFreeConnection();
-					try {
-						invoke(connect, proxyFactory, classValue, parmTypesValue, subjectValue, parmsValue, returnValue);
-						return proxyFactory.getBeanProxy(returnValue);
-					} catch (CommandException eAgain) {
-						// Failed again. Just close and print trace.
-						factory.closeConnection(connect);
-						connect = null;
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
-						return null;
-					}
-				} else {
-					// A recoverable error, print trace and return
-					ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-					return null;
-				}
-			}
-		} finally {
-			proxyFactory.stopTransaction();
-			if (connect != null)
-				factory.returnConnection(connect);
-		}
-	}
-
-private void invoke(
-		IREMConnection connect,
-		REMStandardBeanProxyFactory proxyFactory,
-		Commands.ValueObject classTypeValue,
-		Commands.ValueObject parmTypesValue,
-		Commands.ValueObject subjectValue,
-		Commands.ValueObject parmsValue,
-		Commands.ValueObject returnValue)
-		throws ThrowableProxy, CommandException {
-		try {
-			connect.invokeMethod(classTypeValue, methodName, parmTypesValue, subjectValue, parmsValue, returnValue);
-		} catch (CommandErrorException e) {
-			proxyFactory.processErrorReturn(e);
-		}
-	}
-
-	public IBeanProxy invoke(IBeanProxy subject, IBeanProxy parm) throws ThrowableProxy {
-		return invoke(subject, new IBeanProxy[] { parm });
-	}
-
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject) {
-		try {
-			return invoke(subject);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			factory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy[] parms) {
-		try {
-			return invoke(subject, parms);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			factory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy parm) {
-		try {
-			return invoke(subject, parm);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			factory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongClassBeanProxy.java
deleted file mode 100644
index 1a8a2e4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongClassBeanProxy.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMLongClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Proxy for Long.class.
- */
-class REMLongClassBeanProxy extends REMNumberBeanProxy {
-
-REMLongClassBeanProxy(REMProxyFactoryRegistry aRegistry, Long aLong) {
-	super(aRegistry, aLong);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).longClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set((Long) numberValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongClassBeanTypeProxy.java
deleted file mode 100644
index 476a8d8..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongClassBeanTypeProxy.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMLongClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy Long.class.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMLongClassBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final INumberBeanProxy oneProxy;
-	private final INumberBeanProxy twoProxy;
-	private final INumberBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMLongClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.LONG_CLASS), Long.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMLongClassBeanProxy(aRegistry, new Long(0));	
-	oneProxy = new REMLongClassBeanProxy(aRegistry, new Long(1));
-	twoProxy = new REMLongClassBeanProxy(aRegistry, new Long(2));
-	threeProxy = new REMLongClassBeanProxy(aRegistry, new Long(3));		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createLongBeanProxy(Long aLong) {
-	if (aLong.longValue() >= 0 && aLong.longValue() < 4) {
-		// Switch statements don't work with longs.
-		switch(aLong.intValue()) {
-			case 0: return zeroProxy;
-			case 1: return oneProxy ;
-			case 2: return twoProxy ;
-			case 3: return threeProxy ;
-		}
-	} 
-	return new REMLongClassBeanProxy(fRegistry, aLong);
-}
-
-/**
- * Generic way to create a Long proxy, however, the Number must be a Long.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createLongBeanProxy((Long) aNumber);
-}	
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createLongBeanProxy(new Long(value.aLong));
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongTypeBeanProxy.java
deleted file mode 100644
index 172662a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongTypeBeanProxy.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMLongTypeBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of INumberBeanProxy for the primitive "long".
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class REMLongTypeBeanProxy extends REMConstantBeanProxy implements INumberBeanProxy {
-	private final long fLong;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMLongTypeBeanProxy(REMProxyFactoryRegistry aRegistry, long aLong) {
-	super(aRegistry);
-	fLong = aLong;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMLongTypeBeanProxy)
-		return fLong == ((REMLongTypeBeanProxy) anObject).longValue();
-	if (anObject instanceof Long)
-		return fLong == ((Long) anObject).longValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMLongTypeBeanProxy)
-		return fLong == ((REMLongTypeBeanProxy) aBeanProxy).longValue();
-	return false;
-}
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return (byte) fLong;
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fLong;
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fLong;
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return (int) fLong;
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return fLong;
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return new Long(fLong);
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return (short) fLong;
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return String.valueOf(fLong);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).longType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fLong);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongTypeBeanTypeProxy.java
deleted file mode 100644
index 5f2c6db..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMLongTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMLongTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Long.TYPE/
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMLongTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final INumberBeanProxy oneProxy;
-	private final INumberBeanProxy twoProxy;
-	private final INumberBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMLongTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.LONG_TYPE), Long.TYPE.getName());
-	
-	// Create the cached values
-	zeroProxy = new REMLongTypeBeanProxy(aRegistry, 0);	
-	oneProxy = new REMLongTypeBeanProxy(aRegistry, 1);
-	twoProxy = new REMLongTypeBeanProxy(aRegistry, 2);
-	threeProxy = new REMLongTypeBeanProxy(aRegistry, 3);		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createLongBeanProxy(long aLong) {
-	if (aLong >= 0 && aLong < 4) {
-		// Switch statements don't work with longs.
-		switch((int) aLong) {
-			case 0: return zeroProxy;
-			case 1: return oneProxy ;
-			case 2: return twoProxy ;
-			case 3: return threeProxy ;
-		}
-	} 
-	return new REMLongTypeBeanProxy(fRegistry, aLong);
-}
-
-/**
- * newInstance method. long is a primitive, so the standard way won't work.
- * Return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}	
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createLongBeanProxy(value.aLong);
-}
-
-/**
- * Short cut for newInstance where the string follows the
- * specific pattern we expect. That way it won't be necessary to ship over to the vm 
- * to process it.
- *
- * The pattern it can accept is:
- * 	1) (long) validNumber - number can be any number because (byte) explicitly casts it down.
- *	2) validNumber
- * It will use the decode function of long to determine the valid number.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	String trim = initializationString.trim();
-	if (trim.length() == 0)
-		return super.newInstance(initializationString);
-	long aLong;
-	if (trim.startsWith("(long)")) { //$NON-NLS-1$
-		Number v = parseString(trim.substring("(long)".length()).trim()); //$NON-NLS-1$
-		if (v != null)
-			aLong = v.longValue();
-		else
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-	} else {
-		if (trim.charAt(trim.length()-1) == 'L' || trim.charAt(trim.length()-1) == 'l')
-			trim = trim.substring(0, trim.length()-1);
-		try {
-			aLong = Long.decode(trim).longValue();	// See if valid long format.
-		} catch (NumberFormatException e) {
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-		}
-	}
-
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(aLong);
-}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMasterServerThread.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMasterServerThread.java
deleted file mode 100644
index 4ee60e3..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMasterServerThread.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMMasterServerThread.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.io.*;
-import java.net.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * Master Server thread for the Remote VMs.
- * 
- * It responds to the remote vm requests to this IDE.
- * 
- * It is package-protected because only ProxyRemotePluguin should access it.
- * @author richkulp
- */
-class REMMasterServerThread extends Thread {
-	
-	protected ServerSocket masterServerSocket;
-	protected REMRegistryController registryController;
-	protected boolean shuttingDown = false;
-	
-	// Kludge: Bug in Linux 1.3.xxx of JVM. Closing a socket while the socket is being read/accept will not interrupt the
-	// wait. Need to timeout to the socket read/accept before the socket close will be noticed. This has been fixed
-	// in Linux 1.4. So on Linux 1.3 need to put timeouts in on those sockets that can be separately closed while reading/accepting.
-	static boolean LINUX_1_3 = "linux".equalsIgnoreCase(System.getProperty("os.name")) && System.getProperty("java.version","").startsWith("1.3");	 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	
-	
-	public REMMasterServerThread(REMRegistryController registryController) {
-		super("Remote Proxy Master Server Thread");	//$NON-NLS-1$
-		this.registryController = registryController;
-		
-		try {
-			masterServerSocket = new ServerSocket(0, 50, InetAddress.getByName("localhost"));	// Any available port //$NON-NLS-1$
-			if (LINUX_1_3)
-				masterServerSocket.setSoTimeout(1000);	// Linux 1.3 bug, see comment on LINUX_1_3
-		} catch (SocketException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e));	// This is bad. Should be no exceptions creating a socket. //$NON-NLS-1$
-		} catch (IOException e) {				
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e));	// This is bad. Should be no exceptions creating a socket. //$NON-NLS-1$
-		}			
-	}
-
-	public ServerSocket getMasterSocket() {
-		return masterServerSocket;
-	}
-	
-	/**
-	 * @see java.lang.Thread#run()
-	 */
-	public void run() {
-		try {
-			while (masterServerSocket != null) {
-				Socket incoming = null;
-				try {
-					incoming = masterServerSocket.accept();
-				} catch (InterruptedIOException e) {
-					continue; // Timeout, try again
-				} catch (NullPointerException e) {
-					continue;	// In Linux 1.3 case masterServerSocket could of gone null between loop test and try block.
-				}
-				boolean close = false;	// process request will tell if socket should be closed. it may be passed onto callback thread instead.
-				try {
-					close = processRequest(incoming);
-				} finally {
-					if (close) {
-						try {
-						incoming.close();
-					} catch (IOException e) {
-					}
-				}
-}
-				incoming = null;
-			}
-		} catch (Exception e) {
-			if (!shuttingDown)
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-		
-		shutdown();	// Either a bad exception or we were closed. Either way is shutdown.
-	}
-	
-	/**
-	 * Use this to request a shutdown.
-	 */
-	public void requestShutdown() {		
-		if (masterServerSocket == null)
-			return;
-		// Closing the server socket should cause a break.
-		try {
-			shuttingDown = true;
-			masterServerSocket.close();
-		} catch (Exception e) {
-		}
-		return;
-	}	
-	
-	protected boolean processRequest(Socket remote) throws IOException {
-		DataInputStream	in = new DataInputStream(remote.getInputStream());
-		DataOutputStream out = new DataOutputStream(remote.getOutputStream());
-		boolean  close = true;	// flag indicating socket not given over to callback. Don't close the socket when done because callback has it.
-		try {
-			byte cmd = in.readByte();
-			switch (cmd) {
-				case Commands.ALIVE:
-					int registryID = in.readInt();
-					out.writeBoolean(registryController.getRegistry(new Integer(registryID)) != null);	// Return if registry still alive
-					out.flush();
-					break;
-					
-				case Commands.REMOTE_STARTED:
-					registryID = in.readInt();
-					int remoteServerPort = in.readInt();
-					REMProxyFactoryRegistry registry = registryController.getRegistry(new Integer(registryID));
-					if (registry != null) {
-						registry.setServerPort(remoteServerPort);
-						out.writeBoolean(true);
-					} else
-						out.writeBoolean(false);	// No registry
-					out.flush();
-					break;
-					
-				case Commands.ATTACH_CALLBACK:
-					registryID = in.readInt();
-					registry = registryController.getRegistry(new Integer(registryID));
-					if (registry != null) {
-						close = !((REMCallbackRegistry) registry.getCallbackRegistry()).createCallback(remote);	// close if failed, don't close if good.
-						out.writeBoolean(!close);	// if not close, then return it worked.
-					} else
-						out.writeBoolean(false);
-					out.flush();
-					break;
-			}
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e));	 //$NON-NLS-1$
-		} finally {
-			if (close) {
-				try {
-					in.close();
-				} catch (IOException e) {
-				}
-				try {
-					out.close();
-				} catch (IOException e) {
-				}
-			}
-		}
-		return close;
-	}
-	
-	private void shutdown() {
-		requestShutdown();
-		masterServerSocket = null;		
-	}		
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodProxy.java
deleted file mode 100644
index c6c674e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodProxy.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMMethodProxy.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote VM implementation of the MethodProxy
- */
-
-final class REMMethodProxy extends REMAccessibleObjectProxy implements IREMMethodProxy {
-
-	private IBeanTypeProxy fDeclaringType;
-	private String fMethodName;
-	private IBeanTypeProxy[] fParameterTypes;
-	private IBeanTypeProxy fReturnType;
-
-	REMMethodProxy(REMProxyFactoryRegistry aRegistry, Integer anID) {
-		super(aRegistry, anID);
-	}
-
-	public IBeanTypeProxy getClassType() {
-		if (fDeclaringType == null)
-			fDeclaringType =
-				(IBeanTypeProxy) REMStandardBeanProxyConstants
-					.getConstants(fFactory)
-					.getMethodDeclaringClassMessage()
-					.invokeCatchThrowableExceptions(
-					this);
-		return fDeclaringType;
-	}
-
-	public String getName() {
-		if (fMethodName == null) {
-			IStringBeanProxy proxy =
-				(IStringBeanProxy) REMStandardBeanProxyConstants
-					.getConstants(fFactory)
-					.getMethodMethodNameMessage()
-					.invokeCatchThrowableExceptions(
-					this);
-			if (proxy != null)
-				fMethodName = proxy.stringValue();
-			else
-				fMethodName = ""; //$NON-NLS-1$
-		}
-		return fMethodName;
-	}
-
-	public synchronized IBeanTypeProxy[] getParameterTypes() {
-		if (fParameterTypes == null) {
-			IArrayBeanProxy parmTypes = (IArrayBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory)
-					.getMethodParameterTypesMessage().invokeCatchThrowableExceptions(this);
-			if (parmTypes == null)
-				fParameterTypes = new IBeanTypeProxy[0]; // There was some error, only way null is returned
-			else {
-				int len = parmTypes.getLength();
-				fParameterTypes = new IBeanTypeProxy[len];
-				for (int i = 0; i < len; i++)
-					try {
-						fParameterTypes[i] = (IBeanTypeProxy) parmTypes.get(i);
-					} catch (ThrowableProxy e) {
-					}
-				fFactory.releaseProxy(parmTypes); // Don't need the array on the server anymore.
-			}
-		}
-
-		return fParameterTypes;
-	}
-
-	public IBeanTypeProxy getReturnType() {
-		if (fReturnType == null)
-			fReturnType =
-				(IBeanTypeProxy) REMStandardBeanProxyConstants
-					.getConstants(fFactory)
-					.getMethodReturnTypeMessage()
-					.invokeCatchThrowableExceptions(
-					this);
-		return fReturnType;
-	}
-
-	public IBeanProxy invoke(IBeanProxy subject) throws ThrowableProxy {
-		return invoke(subject, (IBeanProxy[]) null);
-	}
-
-	public IBeanProxy invoke(IBeanProxy subject, IBeanProxy[] parms) throws ThrowableProxy {
-		return invokeWithParms(subject, parms);
-	}
-
-	/**
-	 * The internal method that allows mixture of constants (e.g. String) with bean proxies.
-	 * A parm value can be a REMMethodProxy.ParmArray. This means this parm is an array that
-	 * needs to have a ValueRetriever created for it. This is used if the array has ID's in
-	 * it and is not an existing array on the server or all constant values.
-	 *
-	 * NOTE: It is assumed that all IBeanTypeProxies of the parms have already been retrieved.
-	 *       It should still work, but it could be asking for them in the middle of the request
-	 *       if they are not first gotton.
-	 *
-	 * NOTE: This is in IREMMethodProxy only so that other REM proxy implementations can access it.
-	 */
-
-	public IBeanProxy invokeWithParms(IBeanProxy subject, final Object[] parms) throws ThrowableProxy {
-		IREMConnection connect = fFactory.getFreeConnection();
-		REMStandardBeanProxyFactory proxyFactory = (REMStandardBeanProxyFactory) fFactory.getBeanProxyFactory();
-		proxyFactory.startTransaction(); // This is definately a transaction, so start it.
-		try {
-			Commands.ValueObject subjectValue = new Commands.ValueObject();
-			if (subject != null)
-				 ((IREMBeanProxy) subject).renderBean(subjectValue);
-
-			Commands.ValueObject parmsValue = new Commands.ValueObject();
-
-			class Retriever implements Commands.ValueRetrieve {
-				int index = 0;
-				Object[] array;
-				Commands.ValueObject worker = new Commands.ValueObject();
-				IStandardBeanTypeProxyFactory typeFactory = fFactory.getBeanTypeProxyFactory();
-
-				public Retriever(Object[] anArray) {
-					array = anArray;
-				}
-				
-				public void reset() {
-					index = 0;
-				}
-
-				public Commands.ValueObject nextValue() {
-					Object parm = array[index++];
-					if (parm != null)
-						if (parm instanceof IREMBeanProxy)
-							 ((IREMBeanProxy) parm).renderBean(worker);
-						else if (parm instanceof TransmitableArray) {
-							// It is another array, create a new retriever.
-							worker.setArrayIDS(
-								new Retriever(((TransmitableArray) parm).array),
-								((TransmitableArray) parm).array.length,
-								((TransmitableArray) parm).componentTypeID);
-						} else {
-							// It's an object. Need to get bean type so that we can send it.
-							IREMBeanProxy type = (IREMBeanProxy) typeFactory.getBeanTypeProxy(parm.getClass().getName());
-							if (type == null)
-								throw new IllegalArgumentException();
-							int classID = type.getID().intValue();
-							worker.setAsObject(parm, classID);
-						}
-					else
-						worker.set();
-					return worker; 
-				}
-			};
-			
-			Retriever retriever = null;
-
-			if (parms != null) {
-				// Have a local definition of the retriever so that the retriever can create
-				// another one of itself if necessary.
-				parmsValue.setArrayIDS(retriever = new Retriever(parms), parms.length, Commands.OBJECT_CLASS); // Create Object[].
-			}
-
-			Commands.ValueObject returnValue = new Commands.ValueObject();
-			try {
-				invoke(connect, proxyFactory, subjectValue, parmsValue, returnValue);
-				return proxyFactory.getBeanProxy(returnValue);
-			} catch (CommandException e) {
-				if (!e.isRecoverable()) {
-					// Close the connection and try again.
-					fFactory.closeConnection(connect);
-					connect = null;
-					connect = fFactory.getFreeConnection();
-					try {
-						if (retriever != null)
-							retriever.reset();
-						invoke(connect, proxyFactory, subjectValue, parmsValue, returnValue);
-						return proxyFactory.getBeanProxy(returnValue);
-					} catch (CommandException eAgain) {
-						// Failed again. Just close and print trace.
-						fFactory.closeConnection(connect);
-						connect = null;
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
-						return null;
-					}
-				} else {
-					// A recoverable error, print trace and return
-					ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-					return null;
-				}
-			}
-		} finally {
-			proxyFactory.stopTransaction();
-			if (connect != null)
-				fFactory.returnConnection(connect);
-		}
-	}
-
-private void invoke(
-		IREMConnection connect,
-		REMStandardBeanProxyFactory proxyFactory,
-		Commands.ValueObject subjectValue,
-		Commands.ValueObject parmsValue,
-		Commands.ValueObject returnValue)
-		throws ThrowableProxy, CommandException {
-		try {
-			connect.invokeMethod(getID().intValue(), subjectValue, parmsValue, returnValue);
-		} catch (CommandErrorException e) {
-			proxyFactory.processErrorReturn(e);
-		}
-	}
-
-	public IBeanProxy invoke(IBeanProxy subject, IBeanProxy parm) throws ThrowableProxy {
-		return invoke(subject, new IBeanProxy[] { parm });
-	}
-
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject) {
-		try {
-			return invoke(subject);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			fFactory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy[] parms) {
-		try {
-			return invoke(subject, parms);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			fFactory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy parm) {
-		try {
-			return invoke(subject, parm);
-		} catch (ThrowableProxy e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			fFactory.releaseProxy(e); // Since it's no longer needed, get rid of now instead of GC time.
-			return null;
-		}
-	}
-
-	/**
-	 * The type proxy is constant proxy out of the method factory.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((REMMethodProxyFactory) fFactory.getMethodProxyFactory()).methodType;
-	}
-
-	/**
-	 * The bean is being released, clear out the fields so they can be GC'd if necessary.
-	 * Usually only big objects and proxy fields need to be cleared.
-	 */
-	public void release() {
-		fDeclaringType = null;
-		fParameterTypes = null;
-		fReturnType = null;
-		super.release();
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodProxyFactory.java
deleted file mode 100644
index 11e9d00..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodProxyFactory.java
+++ /dev/null
@@ -1,305 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMMethodProxyFactory.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:39:06 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import java.lang.reflect.AccessibleObject;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.TransmitableArray;
-
-/**
- * Factory for creating method proxies. Creation date: (12/3/99 6:29:40 PM)
- * 
- * @author: Joe Winchester
- */
-public class REMMethodProxyFactory implements IMethodProxyFactory {
-
-	final protected REMProxyFactoryRegistry fFactoryRegistry;
-
-	// Cached copy of a few typical method type proxies.
-	IREMBeanTypeProxy accessibleType;
-
-	REMMethodTypeProxy methodType;
-
-	REMFieldTypeProxy fieldType;
-
-	REMConstructorTypeProxy ctorType;
-
-	REMMethodProxy getMethodProxy;
-
-	REMMethodProxyFactory(REMProxyFactoryRegistry aRegistry) {
-		fFactoryRegistry = aRegistry;
-		aRegistry.registerMethodProxyFactory(this);
-		REMStandardBeanTypeProxyFactory typeFactory = (REMStandardBeanTypeProxyFactory) aRegistry.getBeanTypeProxyFactory();
-
-		accessibleType = typeFactory.objectClass.newBeanTypeForClass(new Integer(Commands.ACCESSIBLEOBJECT_CLASS), AccessibleObject.class.getName(),
-				false);
-		methodType = new REMMethodTypeProxy(aRegistry, accessibleType);
-		fieldType = new REMFieldTypeProxy(aRegistry, accessibleType);
-		ctorType = new REMConstructorTypeProxy(aRegistry, accessibleType);
-		aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(accessibleType, true);
-		aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(methodType, true);
-		aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(fieldType, true);
-		aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(ctorType, true);
-
-		getMethodProxy = (REMMethodProxy) methodType.newBeanProxy(new Integer(Commands.GET_METHOD_ID));
-		((REMStandardBeanProxyFactory) aRegistry.getBeanProxyFactory()).registerProxy(getMethodProxy);
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getMethodProxy(java.lang.String, java.lang.String, java.lang.String[])
-	 */
-	public IMethodProxy getMethodProxy(String className, String methodName, String[] parameterTypes) {
-		IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-		IBeanTypeProxy clsProxy = typeFactory.getBeanTypeProxy(className);
-		if (clsProxy == null)
-			return null;
-		// This will redirect to the beantype, which will go through the method cache.
-		return clsProxy.getMethodProxy(methodName, parameterTypes);
-	}
-	
-	/**
-	 * A helper method to get the method proxy for the expression. This is used by registries and beantype proxies. It will go through
-	 * the method cache to make sure we get only one.
-	 * 
-	 * @param expression
-	 * @param aBeanTypeProxy
-	 * @param methodName
-	 * @param parmTypes
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, String methodName, IProxyBeanType[] parmTypes){
-		return ((REMStandardBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactory()).proxyConstants.getMethodProxy(expression, aBeanTypeProxy, methodName, parmTypes);
-	}
-	
-	/**
-	 * A helper method to get the field proxy for the expression. This is used by registries and beantype proxies. It will go through
-	 * the method cache to make sure we get only one.
-	 * @param expression
-	 * @param aBeanTypeProxy
-	 * @param fieldName
-	 * 
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyField getFieldProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, String fieldName){
-		return ((REMStandardBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactory()).proxyConstants.getFieldProxy(expression, aBeanTypeProxy, fieldName);
-	}
-	
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String)
-	 */
-	public IProxyField getFieldProxy(IExpression expression, String className, String fieldName) {
-		// We are getting the class resolved through the expression. Might as well because it probably will
-		// be needed again and this way when the expression is finished it will be resolved for later usage.
-		IStandardBeanTypeProxyFactory beanTypeProxyFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-		IProxyBeanType beanType = beanTypeProxyFactory.getBeanTypeProxy(expression, className);
-		return beanType.getFieldProxy(expression, fieldName);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String, java.lang.String[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String className, String methodName, String[] parameterTypes) {
-		// We are getting the class and parmtypes resolved through the expression. Might as well because they probably will
-		// be needed again and this way when the expression is finished they will be resolved for later usage.
-		IStandardBeanTypeProxyFactory beanTypeProxyFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-		IProxyBeanType beanType = beanTypeProxyFactory.getBeanTypeProxy(expression, className);
-		IProxyBeanType[] parmTypes = getParameterTypes(expression, parameterTypes, beanTypeProxyFactory);
-		return beanType.getMethodProxy(expression, methodName, parmTypes);
-	}
-	
-	/**
-	 * Helper method for BeanTypes and proxy Beantypes. So they don't need to have common code to convert string to proxy bean type.
-	 * @param expression
-	 * @param classType
-	 * @param methodName
-	 * @param parameterTypes
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType classType, String methodName, String[] parameterTypes) {
-		// We are getting the class and parmtypes resolved through the expression. Might as well because they probably will
-		// be needed again and this way when the expression is finished they will be resolved for later usage.
-		IStandardBeanTypeProxyFactory beanTypeProxyFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-		IProxyBeanType[] parmTypes = getParameterTypes(expression, parameterTypes, beanTypeProxyFactory);
-		return classType.getMethodProxy(expression, methodName, parmTypes);
-	}
-
-	/**
-	 * @param expression
-	 * @param parameterTypes
-	 * @param beanTypeProxyFactory
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IProxyBeanType[] getParameterTypes(IExpression expression, String[] parameterTypes, IStandardBeanTypeProxyFactory beanTypeProxyFactory) {
-		IProxyBeanType[] parmTypes;
-		if (parameterTypes == null || parameterTypes.length == 0)
-			parmTypes = null;
-		else {
-			parmTypes = new IProxyBeanType[parameterTypes.length];
-			for (int i = 0; i < parameterTypes.length; i++) {
-				parmTypes[i] = beanTypeProxyFactory.getBeanTypeProxy(expression, parameterTypes[i]);
-			}
-		}
-		return parmTypes;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getInvokable(java.lang.String, java.lang.String, java.lang.String[])
-	 */
-	public IInvokable getInvokable(String className, String methodName, String[] parameterTypes) {
-		IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-		IBeanTypeProxy clsProxy = typeFactory.getBeanTypeProxy(className);
-		if (clsProxy == null)
-			return null;
-		return clsProxy.getInvokable(methodName, parameterTypes);
-	}
-
-	/**
-	 * Get the method id from the remote system and create the method proxy.
-	 * 
-	 * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else.
-	 * 
-	 * @param beanType
-	 * @param methodName
-	 * @param parameterTypes
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public IInvokable getInvokable(IREMBeanTypeProxy beanType, String methodName, String[] parameterTypes) {
-		// First convert the parameter types into IBeanTypeProxy[].
-		IREMBeanTypeProxy[] types = null;
-		if (parameterTypes != null) {
-			IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-			types = new IREMBeanTypeProxy[parameterTypes.length];
-			for (int i = 0; i < parameterTypes.length; i++) {
-				IBeanTypeProxy type = types[i] = (IREMBeanTypeProxy) typeFactory.getBeanTypeProxy(parameterTypes[i]);
-				if (type == null)
-					return null; // One of the parm types doesn't exist.
-			}
-		}
-
-		return getInvokable(beanType, methodName, types);		
-	}
-	
-	/**
-	 * Get the method id from the remote system and create the method proxy.
-	 * This does not go through the method cache. It goes direct to the remote vm.
-	 * 
-	 * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else.
-	 */
-	public IMethodProxy getMethodProxy(IREMBeanTypeProxy beanType, String methodName, String[] parameterTypes) {
-		// First convert the parameter types into IBeanTypeProxy[].
-		IBeanTypeProxy[] types = null;
-		if (parameterTypes != null) {
-			IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory();
-			types = new IBeanTypeProxy[parameterTypes.length];
-			for (int i = 0; i < parameterTypes.length; i++) {
-				IBeanTypeProxy type = types[i] = typeFactory.getBeanTypeProxy(parameterTypes[i]);
-				if (type == null)
-					return null; // One of the parm types doesn't exist.
-			}
-		}
-
-		return getMethodProxy(beanType, methodName, types);
-	}
-
-	
-	/**
-	 * Get the invokable. 
-	 * 
-	 * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else.
-	 * @param beanType
-	 * @param methodName
-	 * @param parameterTypes
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public IInvokable getInvokable(IREMBeanTypeProxy beanType, String methodName, IBeanTypeProxy[] parameterTypes) {
-		return new REMInvokable(beanType, methodName, parameterTypes);
-	}
-	
-	/**
-	 * Get the method id from the remote system and create the method proxy.
-	 * <p>
-	 * This does not go through the method cache. It goes direct to the remote vm.
-	 * 
-	 * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else.
-	 */
-	public IMethodProxy getMethodProxy(IREMBeanTypeProxy beanType, String methodName, IBeanTypeProxy[] parameterTypes) {
-		// The parms to getMethod are:
-		// parm[0] = String - method name
-		// parm[1] = Class[] - Parameter Classes.
-		Object[] parms = new Object[] { methodName, parameterTypes != null ? (new TransmitableArray(Commands.CLASS_CLASS, parameterTypes)) : null};
-		IBeanProxy result = null;
-		try {
-			result = getMethodProxy.invokeWithParms(beanType, parms);
-			return (IMethodProxy) result;
-		} catch (ThrowableProxy e) {
-			fFactoryRegistry.releaseProxy(e); // Since it's not needed, get rid of now instead of GC time.
-			return null;
-		} catch (ClassCastException e) {
-			// Some trace msgs because we keep getting into a mode after awhile (though not reproducible) that returns non-method proxies and we need
-			// more info.
-			StringBuffer buf = new StringBuffer("Method requested is \"" + methodName + "("); //$NON-NLS-1$	//$NON-NLS-2$
-			for (int i = 0; i < parameterTypes.length; i++) {
-				if (i > 0)
-					buf.append(','); //$NON-NLS-1$
-				buf.append(parameterTypes[i].getTypeName());
-			}
-			buf.append(")\""); //$NON-NLS-1$
-			ProxyPlugin.getPlugin().getLogger().log(
-					new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, buf.toString(), null));
-			try {
-				if (result != null) {
-					ProxyPlugin.getPlugin().getLogger().log(
-							new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0,
-									"ClassCastException of result. Return type is \"" + result.getTypeProxy().getTypeName() + "\"\n" + //$NON-NLS-1$	//$NON-NLS-2$
-											"Return type bean type proxy class=\"" + result.getTypeProxy().getClass().getName() + "\"\n" + //$NON-NLS-1$	//$NON-NLS-2$
-											"GetMethodProxy valid=" + getMethodProxy.isValid() + "\n" + //$NON-NLS-1$	//$NON-NLS-2$
-											"GetMethodProxy real name is \"" + getMethodProxy.getName() + "\"\n", null)); //$NON-NLS-1$	//$NON-NLS-2$			
-				}
-			} catch (Exception e2) {
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e2)); //$NON-NLS-1$
-			}
-			throw e; // Rethrow it.
-		}
-	}
-
-	/*
-	 * Terminate the factory. Don't need to do anything because of the proxies being held onto are registered any will be cleaned up themselves.
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodTypeProxy.java
deleted file mode 100644
index 5a53f28..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMMethodTypeProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMMethodTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * BeanType Proxy for Method class.
- */
-
-final class REMMethodTypeProxy extends REMAbstractBeanTypeProxy {
-
-REMMethodTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy accessibleTypeProxy) {
-	super(aRegistry, new Integer(Commands.METHOD_CLASS), java.lang.reflect.Method.class.getName(), accessibleTypeProxy);
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the accessible object types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Specialized from REMAbstractBeanTypeProxy to ensure Constructor proxies are created correctly.
- */
-public IREMBeanProxy newBeanProxy(Integer objectID) {
-	return new REMMethodProxy(fRegistry, objectID);
-}
-
-/**
- * Note: Since new instances of Constructor are never done through a default ctor,
- * this function is not supported.
- */
-public IBeanProxy newInstance() { 
-	throw new UnsupportedOperationException();
-}
-
-/**
- * Note: Since new instances of Constructor are never done through an initialization string,
- * this function is not supported.
- */
-public IBeanProxy newInstance(String initializationString) {
-	throw new UnsupportedOperationException();
-}		
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMNumberBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMNumberBeanProxy.java
deleted file mode 100644
index 6d3a46d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMNumberBeanProxy.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMNumberBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Remote Implementation of INumberBeanProxy for any Number (i.e. the non-primitives)
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-abstract class REMNumberBeanProxy extends REMConstantBeanProxy implements INumberBeanProxy {
-	private final Number fNumberValue;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMNumberBeanProxy(REMProxyFactoryRegistry aRegistry, Number aNumber) {
-	super(aRegistry);
-	fNumberValue = aNumber;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMNumberBeanProxy)
-		return fNumberValue.equals(((REMNumberBeanProxy) anObject).numberValue());
-	if (anObject instanceof Number)
-		return fNumberValue.equals(anObject);
-	return false;
-}
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return fNumberValue.byteValue();
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fNumberValue.doubleValue();
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fNumberValue.floatValue();
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return fNumberValue.intValue();
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return fNumberValue.longValue();
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return fNumberValue;
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return fNumberValue.shortValue();
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return fNumberValue.toString();
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMPrimitiveBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMPrimitiveBeanTypeProxy.java
deleted file mode 100644
index 8c87889..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMPrimitiveBeanTypeProxy.java
+++ /dev/null
@@ -1,234 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMPrimitiveBeanTypeProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Primitive BeanType Proxies
- */
-public abstract class REMPrimitiveBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMConstantBeanTypeProxy  {
-	
-	protected REMPrimitiveBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname) {
-		super(aRegistry, anID, aClassname, null);
-	}
-	
-	/**
-	 * Return whether this is the primitive Byte.TYPE or Byte.class
-	 */
-	public boolean isPrimitive() {
-		return true;
-	}
-	
-	/**
-	 * Return the null ctor proxy for this method with these arguments.
-	 * For all of the primitive types, this is an invalid operation.	 
-	 */		
-	public IConstructorProxy getNullConstructorProxy() {	
-		throw new UnsupportedOperationException();
-	}
-		
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes) {	
-		throw new UnsupportedOperationException();
-	}	
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IConstructorProxy[] getConstructors() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes) {	
-		throw new UnsupportedOperationException();
-	}	
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IConstructorProxy[] getDeclaredConstructors() {
-		throw new UnsupportedOperationException();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IFieldProxy[] getFields() {
-		throw new UnsupportedOperationException();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 * 
-	 * For all of the primitive types, this is an invalid operation.
-	 */
-	public IFieldProxy[] getDeclaredFields() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the field for the target VM being the same as the REM
-	 * For all of the primitive types, this is an invalid operation.
-	 */	
-	public IFieldProxy getFieldProxy(String fieldName) {	
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the primitive types, this is an invalid operation.	 
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-		
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the primitive types, this is an invalid operation.	 
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the primitive types, this is an invalid operation.	 
-	 */	
-	public IMethodProxy getMethodProxy(String methodName, String argumentQualifiedTypeName) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments.
-	 * For all of the primitive types, this is an invalid operation.	 
-	 */		
-	public IMethodProxy getMethodProxy(String methodName) {	
-		throw new UnsupportedOperationException();
-	}
-	
-	
-	/**
-	 * Create a new bean proxy with the specified id.
-	 *
-	 * For all of the primitive types, this is an invalid operation. They are created
-	 * explicitly through the appropriate create method.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer anID) {
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * For all of the primitive types, they aren't classes, so you can't create a newBeanType 
-	 * for subclasses.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		throw new UnsupportedOperationException();
-	}
-	
-	/**
-	 * release - BeanType is about to be released.
-	 * primitives don't need to be released, they don't hold onto any ids or resources.
-	 */
-	public void release() {
-	}
-	
-	/**
-	 * Have a string that should represent a number.
-	 * See if it ends in a type letter, if so parse as such.
-	 * See if there is an 'E' in it, then parse as a double.
-	 * If neither condition, then try parse as long, if that 
-	 * fails try as double.
-	 */
-	protected static Number parseString(String v) {
-		if (v.length() == 0)
-			return null;
-		char last = v.charAt(v.length()-1);
-		try {
-			switch (last) {
-				case 'd':
-				case 'D':
-					return Double.valueOf(v);
-				case 'f':
-				case 'F':
-					return Float.valueOf(v);
-				case 'l':
-				case 'L':
-					return Long.decode(v.substring(0, v.length()-1));
-			}
-		} catch (NumberFormatException e) {
-			return null;
-		}
-		
-		try {
-			return Long.decode(v);
-		} catch (NumberFormatException e) {
-			try {
-				return Double.valueOf(v);
-			} catch (NumberFormatException e1) {
-				return null;
-			}
-		}
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMProxyConstants.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMProxyConstants.java
deleted file mode 100644
index 449d4fc..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMProxyConstants.java
+++ /dev/null
@@ -1,679 +0,0 @@
-/*******************************************************************************
- * Copyright (c)  2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMProxyConstants.java,v $
- *  $Revision: 1.6 $  $Date: 2005/05/18 23:11:26 $ 
- */
-package org.eclipse.jem.internal.proxy.remote;
-
-import java.util.*;
-import java.util.Map.Entry;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
-
-
-
-
-/**
- * MethodProxyConstants is a cache of IMethodProxies to avoid repeated lookup
- * and thereby avoid the relatively expensive java.lang.reflect calls to repeatedly
- * lookup method by name
- * 
- * @since 1.1.0
- */
-public class REMProxyConstants {
-
-	private Map methodsCache = new HashMap(80);
-	private Map invokablesCache = new HashMap(80);	
-	private Map fieldsCache = new HashMap(80);
-	
-	private REMProxyFactoryRegistry registry;
-	
-	public REMProxyConstants(REMProxyFactoryRegistry registry) {
-		this.registry = registry;
-	}
-	
-	/*
-	 * Used as the key to the methodCache and invokablesCache when there are parms.
-	 * It allows the parms to be either strings or IBeanTypeProxies without the
-	 * overhead of creating complicated strings.
-	 * 
-	 * It will compare method name and each individual parm name without fluffing
-	 * up a string and building it up.
-	 * 
-	 * For no parm methods, just the name of the method as a string will be the key.
-	 * 
-	 * @since 1.1.0
-	 */
-	private abstract static class MethodKey {
-		public String methodName;
-		public MethodKey(String methodName) {
-			this.methodName = methodName;
-		}
-				
-		protected abstract boolean compareParms(IProxyBeanType[] parms);
-		protected abstract boolean compareParms(String[] parms);
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Object#hashCode()
-		 */
-		public int hashCode() {
-			return methodName.hashCode();
-		}
-	}
-	
-	private static class MethodKeyStringParms extends MethodKey {
-		public String[] parmNames;
-		
-		public MethodKeyStringParms(String methodName, String[] parmNames) {
-			super(methodName);
-			this.parmNames = parmNames;
-		}
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Object#equals(java.lang.Object)
-		 */
-		public boolean equals(Object obj) {
-			if (this == obj)
-				return true;
-			try {
-				return ((MethodKey) obj).compareParms(parmNames);
-			} catch (ClassCastException e) {
-				return false;
-			}
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#hashCode()
-		 */
-		public int hashCode() {
-			int h = super.hashCode();
-			for (int i = 0; i < parmNames.length; i++) {
-				h += parmNames[i].hashCode();
-			}
-			return h;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-		 */
-		protected boolean compareParms(IProxyBeanType[] parms) {
-			if (parms.length != parmNames.length)
-				return false;
-			for (int i = 0; i < parms.length; i++) {
-				if (!parms[i].getTypeName().equals(parmNames[i]))
-					return false;
-			}
-			return true;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(java.lang.String[])
-		 */
-		protected boolean compareParms(String[] parms) {
-			return Arrays.equals(parms, parmNames);
-		}
-	}
-	
-	private static class MethodKeyProxyParms extends MethodKey {
-		public IProxyBeanType[] parmTypes;
-		
-		public MethodKeyProxyParms(String methodName, IProxyBeanType[] parmTypes) {
-			super(methodName);
-			this.parmTypes = parmTypes;
-		}
-		
-		public Object toMethodKeyStringParms() {
-			String[] parms = new String[parmTypes.length];
-			for (int i = 0; i < parmTypes.length; i++) {
-				parms[i] = parmTypes[i].getTypeName();
-			}
-			return new MethodKeyStringParms(methodName, parms);
-		}
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Object#equals(java.lang.Object)
-		 */
-		public boolean equals(Object obj) {
-			if (this == obj)
-				return true;
-			try {
-				return ((MethodKey) obj).compareParms(parmTypes);
-			} catch (ClassCastException e) {
-				return false;
-			}
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#hashCode()
-		 */
-		public int hashCode() {
-			int h = super.hashCode();
-			for (int i = 0; i < parmTypes.length; i++) {
-				h += parmTypes[i].getTypeName().hashCode();
-			}
-			return h;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-		 */
-		protected boolean compareParms(String[] parms) {
-			if (parms.length != parmTypes.length)
-				return false;
-			for (int i = 0; i < parms.length; i++) {
-				if (!parmTypes[i].getTypeName().equals(parms[i]))
-					return false;
-			}
-			return true;
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(java.lang.String[])
-		 */
-		protected boolean compareParms(IProxyBeanType[] parms) {
-			if (parms.length != parmTypes.length)
-				return false;
-			for (int i = 0; i < parms.length; i++) {
-				if (!parmTypes[i].getTypeName().equals(parms[i].getTypeName()))
-					return false;
-			}
-			return true;
-		}		
-	}
-		
-	static int REMMETHODCOUNT = 0;
-	static int UNIQUEMETHODCOUNT = 0;	
-	static int REMINVOKABLECOUNT = 0;
-	static int UNIQUEINVOKABLECOUNT = 0;
-	static int INVOKEINVOKECOUNT = 0;
-	static int METHODPROXYINVOKECOUNT = 0;
-	static int REMFIELDCOUNT = 0;
-	static int UNIQUEFIELDCOUNT = 0;
-	static int REMCONSTRUCTORCALLED = 0;
-	static HashMap METHODCOUNTMAP;
-	static HashMap FIELDCOUNTMAP;	 
-	static HashMap FIELDSETCOUNTMAP;
-	static boolean GATHER_COUNTS;
-	
-	/**
-	 * Set if counts should be gathered.
-	 * 
-	 * @param gatherCounts
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void setGatherCounts(boolean gatherCounts) {
-		if (gatherCounts != GATHER_COUNTS) {
-			reset();
-			if (gatherCounts) {
-				if (METHODCOUNTMAP == null) {
-					METHODCOUNTMAP = new HashMap();
-					FIELDCOUNTMAP = new HashMap();
-					FIELDSETCOUNTMAP = new HashMap();
-				}
-			}
-			GATHER_COUNTS = gatherCounts;
-		}
-	}
-	
-	
-	public static void reset(){
-		REMMETHODCOUNT = UNIQUEMETHODCOUNT = REMINVOKABLECOUNT = UNIQUEINVOKABLECOUNT = REMCONSTRUCTORCALLED = METHODPROXYINVOKECOUNT = INVOKEINVOKECOUNT = REMFIELDCOUNT = UNIQUEFIELDCOUNT = 0;
-		if (GATHER_COUNTS) {
-			METHODCOUNTMAP.clear();
-			FIELDCOUNTMAP.clear();
-			FIELDSETCOUNTMAP.clear();
-		}
-	}
-	
-	public static void println(){
-		
-		if (GATHER_COUNTS) {
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-			System.out.println("Method proxies invokes = " + METHODPROXYINVOKECOUNT); //$NON-NLS-1$
-			System.out.println("Invoke invokes = " + INVOKEINVOKECOUNT); //$NON-NLS-1$
-			System.out.println(".................................................."); //$NON-NLS-1$
-			System.out.println("Methods retrieved = " + REMMETHODCOUNT + "(" + UNIQUEMETHODCOUNT + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-			System.out.println("Invokes retrieved = " + REMINVOKABLECOUNT + "(" + UNIQUEINVOKABLECOUNT + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-			System.out.println("Fields retrieved = " + REMFIELDCOUNT + "(" + UNIQUEFIELDCOUNT + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-			System.out.println("Constructor calls = " + REMCONSTRUCTORCALLED); //$NON-NLS-1$
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-			System.out.println("-Count of methods invoked-------------------------"); //$NON-NLS-1$
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-
-			// Collate the methods called
-			Iterator entries = METHODCOUNTMAP.entrySet().iterator();
-			while (entries.hasNext()) {
-				Map.Entry entry = (Entry) entries.next();
-				REMMethodProxy methodProxy = (REMMethodProxy) entry.getKey();
-				System.out.println(methodProxy.getClassType().getTypeName() + "," + methodProxy.getName() + "," + entry.getValue()); //$NON-NLS-1$ //$NON-NLS-2$
-			}
-
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-			System.out.println("-Count of fields get called ----------------------"); //$NON-NLS-1$
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-
-			// Collate the fields accessed
-			entries = FIELDCOUNTMAP.entrySet().iterator();
-			while (entries.hasNext()) {
-				Map.Entry entry = (Entry) entries.next();
-				REMFieldProxy fieldProxy = (REMFieldProxy) entry.getKey();
-				System.out.println(fieldProxy.toBeanString() + "," + entry.getValue()); //$NON-NLS-1$
-			}
-
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-			System.out.println("-Count of fields set called ----------------------"); //$NON-NLS-1$
-			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
-
-			// Collate the fields set
-			entries = FIELDSETCOUNTMAP.entrySet().iterator();
-			while (entries.hasNext()) {
-				Map.Entry entry = (Entry) entries.next();
-				REMFieldProxy fieldProxy = (REMFieldProxy) entry.getKey();
-				System.out.println(fieldProxy.toBeanString() + "," + entry.getValue()); //$NON-NLS-1$
-			} 
-		}
-		
-	}
-	
-/**
- * @param aBeanTypeProxy = BeanTypeProxy for the method
- * @param methodName = methodName to be looked for
- * @param parmTypes = array of qualified type names for the method arguments, null if no methods
- */ 
-	public IMethodProxy getMethodProxy(IBeanTypeProxy aBeanTypeProxy, String methodName, String[] parmTypes){
-		if (!registry.isValid())
-			return null;
-
-		REMMETHODCOUNT++;
-		Map methods;
-		Object key;
-		synchronized (this) {
-			// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
-			methods = getMethods(aBeanTypeProxy);
-
-			// The syntax of the key is methodName(parmType1,parmType2)
-			if (parmTypes == null || parmTypes.length == 0) {
-				key = methodName;
-			} else {
-				key = new MethodKeyStringParms(methodName, parmTypes);
-			}
-
-			IMethodProxy result = (IMethodProxy) methods.get(key);
-			if (result != null)
-				return result;
-		}
-		
-		UNIQUEMETHODCOUNT++;
-		// Get the method proxy and cache this before returning it
-		// Get the method proxy and cache this before returning it
-		REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) registry.getMethodProxyFactory();
-		IMethodProxy result = proxyFactory.getMethodProxy((IREMBeanTypeProxy)aBeanTypeProxy,methodName,parmTypes);
-		synchronized (this) {
-			// Get it again to make sure it hasn't changed due to a race condition. We don't sync for the getMethodProxy because that goes to the remote vm and could deadlock.
-			IMethodProxy mValue = (IMethodProxy) methods.get(key);
-			if (mValue != null && mValue != result) {
-				registry.releaseProxy(result); // Don't need the result now, got it through a race condition.
-				return mValue; // We have a real value now.
-			}
-			methods.put(key, result);
-		}		
-		return result;				
-	}
-/**
- * @param aBeanTypeProxy
- * @return Map of cache'd methods
- */
-private Map getMethods(IProxyBeanType aBeanTypeProxy) {
-	Map methods = (Map) methodsCache.get(aBeanTypeProxy.getTypeName());
-	if(methods == null){
-		methods = new HashMap(20);
-		methodsCache.put(aBeanTypeProxy.getTypeName(),methods);
-	}
-	return methods;
-}
-/**
- * @param aBeanTypeProxy
- * @return Map of cache'd invokables
- */
-private Map getInvokables(IBeanTypeProxy aBeanTypeProxy) {
-	Map invokables = (Map) invokablesCache.get(aBeanTypeProxy);
-	if(invokables == null){
-		invokables = new HashMap(20);
-		invokablesCache.put(aBeanTypeProxy,invokables);
-	}
-	return invokables;
-}
-/**
- * @param aBeanTypeProxy
- * @return Map of cache'd fields
- */
-private Map getFields(IProxyBeanType aBeanTypeProxy) {
-	Map fields = (Map) fieldsCache.get(aBeanTypeProxy.getTypeName());
-	if(fields == null){
-		fields = new HashMap(20);
-		fieldsCache.put(aBeanTypeProxy.getTypeName(),fields);
-	}
-	return fields;
-}
-/**
- * @param aBeanTypeProxy = BeanTypeProxy for the method
- * @param methodName = methodName to be looked for
- * @param parmTypes = array of qualified type names for the method arguments, null if no arguments
- */ 
-	public IInvokable getInvokable(IBeanTypeProxy aBeanTypeProxy, String invokableName, String[] parmTypeNames){
-		
-		REMINVOKABLECOUNT++;
-		// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
-		Map invokables = getInvokables(aBeanTypeProxy);	
-		
-		Object key = null; 
-		if(parmTypeNames == null || parmTypeNames.length == 0){
-			key = invokableName;
-		} else {
-			key = new MethodKeyStringParms(invokableName, parmTypeNames);
-		}			
-		
-		IInvokable result = (IInvokable) invokables.get(key);
-		if(result != null) return result;
-		
-		UNIQUEINVOKABLECOUNT++;
-		// Get the method proxy and cache this before returning it
-		// Get the method proxy and cache this before returning it
-		REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) aBeanTypeProxy.getProxyFactoryRegistry().getMethodProxyFactory();
-		result = proxyFactory.getInvokable((IREMBeanTypeProxy)aBeanTypeProxy,invokableName,parmTypeNames);
-		invokables.put(key,result);		
-		return result;				
-				
-	}
-	/**
-	 * @param aBeanTypeProxy = BeanTypeProxy for the method
-	 * @param methodName = methodName to be looked for
-	 * @param parmTypes = array of IBeanTypeProxy types for the method arguments, null if no arguments
-	 */ 
-		public IInvokable getInvokable(IBeanTypeProxy aBeanTypeProxy, String invokableName, IBeanTypeProxy[] parmTypes){
-			
-			REMINVOKABLECOUNT++;
-			// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
-			Map invokables = getInvokables(aBeanTypeProxy);	
-			
-			Object key = null; 
-			if(parmTypes == null || parmTypes.length == 0){
-				key = invokableName;
-			} else {
-				key = new MethodKeyProxyParms(invokableName, parmTypes);
-			}			
-			
-			IInvokable result = (IInvokable) invokables.get(key);
-			if(result != null) return result;
-			
-			UNIQUEINVOKABLECOUNT++;
-			// Get the method proxy and cache this before returning it
-			// Get the method proxy and cache this before returning it
-			REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) aBeanTypeProxy.getProxyFactoryRegistry().getMethodProxyFactory();
-			result = proxyFactory.getInvokable((IREMBeanTypeProxy)aBeanTypeProxy,invokableName,parmTypes);
-			invokables.put(key,result);		
-			return result;				
-					
-		}	
-/**
- * @param aBeanTypeProxy = BeanTypeProxy for the method
- * @param methodName = methodName to be looked for
- * @param parmTypes = array of qualified type names for the method arguments, null if no methods
- */ 
-	public IMethodProxy getMethodProxy(IBeanTypeProxy aBeanTypeProxy, String methodName, IBeanTypeProxy[] parmTypes){
-		if (!registry.isValid())
-			return null;
-		
-		REMMETHODCOUNT++;		
-		// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
-		Map methods;
-		Object key;
-		synchronized (this) {
-			methods = getMethods(aBeanTypeProxy);
-
-			key = null;
-			if (parmTypes == null || parmTypes.length == 0) {
-				key = methodName;
-			} else {
-				key = new MethodKeyProxyParms(methodName, parmTypes);
-			}
-
-			IMethodProxy result = (IMethodProxy) methods.get(key);
-			if (result != null)
-				return result;
-		}
-		
-		UNIQUEMETHODCOUNT++;
-		// Get the method proxy and cache this before returning it
-		// Get the method proxy and cache this before returning it
-		REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) registry.getMethodProxyFactory();
-		IMethodProxy result = proxyFactory.getMethodProxy((IREMBeanTypeProxy)aBeanTypeProxy,methodName,parmTypes);
-		synchronized (this) {
-			// Get it again to make sure it hasn't changed due to a race condition. We don't sync for the getMethodProxy because that goes to the remote vm and could deadlock.
-			IMethodProxy mValue = (IMethodProxy) methods.get(key);
-			if (mValue != null && mValue != result) {
-				registry.releaseProxy(result); // Don't need result now, got it already through a race condition.
-				return mValue; // We have a real value now.
-			}
-			methods.put(key, result);
-		}		
-
-		return result;				
-	}
-
-	/**
-	 * Return the proxy method for the method through the expression. 
-	 * @param expression
-	 * @param aBeanTypeProxy
-	 * @param methodName
-	 * @param parmTypes
-	 * @return either the IMethodProxy if already resolved or an ExpressionProxy if not yet resolved.
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, String methodName, IProxyBeanType[] parmTypes){
-		if (!registry.isValid())
-			return null;
-		
-		REMMETHODCOUNT++;	
-		Map methods;
-		Map epMethods;
-		Object key;
-		boolean isKey;
-		synchronized (this) {
-			// The classCache map is keyed by the BeanTypeProxy name and holds a further map of cache'd methods
-			methods = getMethods(aBeanTypeProxy);
-
-			if (parmTypes == null || parmTypes.length == 0) {
-				key = methodName;
-				isKey = false;
-			} else {
-				key = new MethodKeyProxyParms(methodName, parmTypes);
-				isKey = true;
-			}
-
-			IProxyMethod result = (IProxyMethod) methods.get(key);
-			if (result != null)
-				return result;
-			
-			// See if stored in the expression.
-			epMethods = ((REMExpression) expression).getMethods(aBeanTypeProxy);
-			result = (IProxyMethod) epMethods.get(key);
-			if (result != null)
-				return result;
-		}
-		
-		UNIQUEMETHODCOUNT++;
-		// Get the method expression proxy and cache this before returning it
-		IProxyMethod result = ((Expression) expression).createMethodExpressionProxy(aBeanTypeProxy,methodName,parmTypes);
-		epMethods.put(key, result);
-		final Object epKey = key;
-		final Map rMethods = methods; 
-		final Map fepMethods = epMethods;
-		final boolean isKeyType = isKey;
-		((ExpressionProxy) result).addProxyListener(new ExpressionProxy.ProxyAdapter() {
-			public void proxyResolved(ProxyEvent event) {
-				synchronized (REMProxyConstants.this) {
-					if (rMethods.containsKey(epKey))
-						return;	// We already have a true method proxy in there. A race condition occurred.
-					
-					// Now put this resolved guy into the methods.
-					// We don't want the key to contain expression proxies in the final map, so if it is a key type
-					// we will turn it into a string type key.
-					Object key;
-					if (isKeyType) {
-						key = ((MethodKeyProxyParms) epKey).toMethodKeyStringParms();	// So that we don't put a ket that contains expression proxy parm types into the main map.
-					} else
-						key = epKey;
-					
-					rMethods.put(key, event.getProxy());
-				}
-			}
-			
-			public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
-				synchronized (REMProxyConstants.this) {
-					fepMethods.remove(epKey);
-				}
-				}
-			
-		});
-		return result;				
-	}
-
-	/**
-	 * @param proxy
-	 */
-	static void methodInvoked(REMMethodProxy proxy) {
-	
-		if (GATHER_COUNTS) {
-			Integer count = (Integer) METHODCOUNTMAP.get(proxy);
-			if (count == null) {
-				METHODCOUNTMAP.put(proxy, new Integer(1));
-			} else {
-				METHODCOUNTMAP.put(proxy, new Integer(count.intValue() + 1));
-			}
-		}
-	}
-
-	static void fieldGetInvoked(IBeanProxy proxy) {
-
-		if (GATHER_COUNTS) {
-			Integer count = (Integer) FIELDCOUNTMAP.get(proxy);
-			if (count == null) {
-				FIELDCOUNTMAP.put(proxy, new Integer(1));
-			} else {
-				FIELDCOUNTMAP.put(proxy, new Integer(count.intValue() + 1));
-			} 
-		}		
-	}
-
-	static void fieldSetInvoked(IBeanProxy proxy, IBeanProxy value) {
-
-		if (GATHER_COUNTS) {
-			Integer count = (Integer) FIELDSETCOUNTMAP.get(proxy);
-			if (count == null) {
-				FIELDSETCOUNTMAP.put(proxy, new Integer(1));
-			} else {
-				FIELDSETCOUNTMAP.put(proxy, new Integer(count.intValue() + 1));
-			} 
-		}				
-	}
-
-	/**
-	 * @param proxy for the BeanType of the field
-	 * @param fieldName of the field, e.g. (java.awt.Dimension, width) for the "width" field on Dimension
-	 * @return The field proxy that is cache'd for performance
-	 */
-	public IFieldProxy getFieldProxy(REMAbstractBeanTypeProxy aBeanTypeProxy, String fieldName) {
-		if (!registry.isValid())
-			return null;
-		
-		REMFIELDCOUNT++;
-		Map fields;
-		synchronized (this) {
-			// The field map is keyed by the BeanTypeProxy and holds a further map of cache'd fields
-			fields = getFields(aBeanTypeProxy);	
-				
-			// Lookup the cache'd Field proxy
-			IFieldProxy result = (IFieldProxy) fields.get(fieldName);
-			if (result != null)
-				return result;
-		}
-		
-		UNIQUEFIELDCOUNT++;
-		IFieldProxy result = (IFieldProxy) REMStandardBeanProxyConstants.getConstants(aBeanTypeProxy.getProxyFactoryRegistry()).getClassGetField().invokeCatchThrowableExceptions(
-				aBeanTypeProxy,
-				registry.getBeanProxyFactory().createBeanProxyWith(fieldName));	
-		synchronized (this) {
-			IFieldProxy fValue = (IFieldProxy) fields.get(fieldName);
-			if (fValue != null) {
-				registry.releaseProxy(result);	// Don't need it now. A race had put another one in.
-				return fValue;
-			}
-			fields.put(fieldName,result);
-		}
-		return result;				
-	}
-	
-	public IProxyField getFieldProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, final String fieldName){
-		if (!registry.isValid())
-			return null;
-		
-		REMFIELDCOUNT++;
-		Map fields;
-		Map epFields;
-		synchronized (this) {
-			// The classCache map is keyed by the BeanTypeProxy name and holds a further map of cache'd methods
-			fields = getFields(aBeanTypeProxy);	
-		
-			IProxyField result = (IProxyField) fields.get(fieldName);
-			if (result != null)
-				return result;
-			
-			// See if stored in the expression.
-			epFields = ((REMExpression) expression).getFields(aBeanTypeProxy);
-			result = (IProxyField) epFields.get(fieldName);
-			if (result != null)
-				return result;			
-		}
-		
-		UNIQUEFIELDCOUNT++;
-		// Get the field expression proxy and cache this before returning it
-		IProxyField result = ((REMExpression) expression).createFieldExpressionProxy(aBeanTypeProxy, fieldName);
-		epFields.put(fieldName, result);
-		final Map fpFields = fields;
-		final Map fepFields = epFields;
-		((ExpressionProxy) result).addProxyListener(new ExpressionProxy.ProxyAdapter() {
-
-			public void proxyResolved(ProxyEvent event) {
-				synchronized (REMProxyConstants.this) {
-					if (fpFields.containsKey(fieldName))
-						return;	// Already set to resolved value by someone else.
-					fpFields.put(fieldName, event.getProxy());
-				}
-			}
-			 public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
-				 synchronized (REMProxyConstants.this) {
-					 fepFields.remove(fieldName);
-				}
-			 }
-		});
-		
-		return result;				
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMProxyFactoryRegistry.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMProxyFactoryRegistry.java
deleted file mode 100644
index 1afa4d0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMProxyFactoryRegistry.java
+++ /dev/null
@@ -1,475 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMProxyFactoryRegistry.java,v $
- *  $Revision: 1.25 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import java.io.IOException;
-import java.net.Socket;
-import java.text.MessageFormat;
-import java.util.Iterator;
-import java.util.Stack;
-
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.jobs.IJobManager;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.debug.core.*;
-import org.eclipse.debug.core.model.IProcess;
-import org.eclipse.debug.core.model.IStreamsProxy;
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * This is the factory registry to use for Remote VM.
- * It adds to the standard registry, connection specific information.
- *
- * This will always hold onto one connection open until termination is requested.
- * That way while the IDE is up, the remove vm won't time out.
- */
-
-public class REMProxyFactoryRegistry extends BaseProxyFactoryRegistry {
-	
-	public static final String REMOTE_REGISTRY_TYPE_ID = "org.eclipse.jem.REMOTE";	//$NON-NLS-1$
-	
-	protected int fServerPort = 0;	// The server port to use when making connections.
-	protected REMCallbackRegistry fCallbackServer;	// The callback server thread for this remote vm.
-	protected Stack fConnectionPool = new Stack();	// Stack of free connections.
-	protected static int NUMBER_FREE_CONNECTIONS = 5;	// Number of free connections to keep open.
-	protected IProcess fProcess;	// The process that is the server. If null and fServerPort is not zero, 
-									// then this registry is in test mode
-									// and the server is in same the process.
-	protected String fName;
-	protected int fCallbackServerPort;
-	protected Integer fRegistryKey;
-	protected REMRegistryController fRegistryController;
-	
-	protected final static Object TERMINATE_JOB_FAMILY = new Object();
-	
-	// Package protected because only the ProxyVMStarter should set this flag. It would set it if
-	// working with a debugger because we don't how long it will be to respond to requests when 
-	// someone is working with a debugger.
-	boolean fNoTimeouts = false;
-	
-	// This is set via the static setGlobalNoTimeouts() method, or via debug options flag. It is here so that
-	// when debugging callbacks, but not debugging remote vm, that no timeouts for any registry will occur.
-	// Or it can be set through the debug .options flag.
-	static boolean fGlobalNoTimeouts = "true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName()+ProxyRemoteUtil.NO_TIMEOUTS)); //$NON-NLS-1$;
-	
-	/**
-	 * Typicall set through the "expression" evaluation of the debugger.
-	 * @param noTimeouts
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void setGlobalNoTimeouts(boolean noTimeouts) {
-		fGlobalNoTimeouts = noTimeouts;
-	}
-	
-	// An internal thread that locks and waits for the remote vm to register itself. 
-	private WaitForRegistrationThread waitRegistrationThread;
-	
-	private class WaitForRegistrationThread extends Thread {
-		public WaitForRegistrationThread() {
-			super("Wait for remote vm registration thread"); //$NON-NLS-1$
-		}
-		
-		/**
-		 * @see java.lang.Thread#run()
-		 */
-		public void run() {
-			// Wait for registration. Put it into a thread so this
-			// can occur while other stuff goes on. It locks the fConnectionPool
-			// until done so that the first request for a connection by anyone
-			// else will wait until this thread is finished. 
-			
-			synchronized(fConnectionPool) {
-				synchronized(REMProxyFactoryRegistry.this) {
-					// Notify the main thread that we have the 
-					// connection pool locked.
-					REMProxyFactoryRegistry.this.notifyAll();
-				}
-				synchronized (this) {
-					// sync on self so that it can be notified when finally receive the registration
-					long stopTime = System.currentTimeMillis()+60000;
-					while (waitRegistrationThread != null && (fNoTimeouts || System.currentTimeMillis() < stopTime)) {
-						try {
-							Thread.currentThread().wait(60000);
-						} catch (InterruptedException e) {
-						}
-					}
-				}
-			}
-			
-			waitRegistrationThread = null;	// No longer exists.				
-		}
-	}
-
-	
-	public REMProxyFactoryRegistry(REMRegistryController registryController, String name) {
-		super(REMOTE_REGISTRY_TYPE_ID);
-		fRegistryController = registryController;		
-		fRegistryKey = fRegistryController.registerRegistry(this);	// Register the registry with the plugin.		
-		fName = name;		
-		
-		// Get the waitRegistrationThread started before we actually launch remote vm so
-		// that it is waiting when the callback comes in.
-		synchronized (this) {
-			waitRegistrationThread = new WaitForRegistrationThread();
-			waitRegistrationThread.start();
-			
-			// Now we will wait until the registration callback has been done. The thread will
-			// signal us when that is done. This is so that we don't continue on and let
-			// a work connection be requested before we even got a chance to start waiting
-			// for the registration.
-			while(true) {
-				try {
-					wait();
-					break;
-				} catch (InterruptedException e) {
-				}
-			};		
-		}		
-	}
-	
-	public Integer getRegistryKey() {
-		return fRegistryKey;
-	}
-	
-	public void initializeRegistry(IProcess process) {
-		fProcess = process;
-		processListener = new IDebugEventSetListener() {
-			/**
-			 * @see org.eclipse.debug.core.IDebugEventSetListener#handleDebugEvents(DebugEvent[])
-			 */
-			public void handleDebugEvents(DebugEvent[] events) {
-				for (int i = 0; i < events.length; i++) {
-					DebugEvent e = events[i];
-					if (e.getSource() == fProcess && e.getKind() == DebugEvent.TERMINATE) {
-						// We terminating too soon. Pop up a msg.
-						IStreamsProxy stProxy = fProcess.getStreamsProxy();
-						java.io.StringWriter s = new java.io.StringWriter();
-						java.io.PrintWriter w = new java.io.PrintWriter(s);
-		
-						String msg = MessageFormat.format(ProxyRemoteMessages.Proxy_Terminated_too_soon_ERROR_, new Object[] {fName}); 
-						w.println(msg);						
-						w.println(ProxyRemoteMessages.VM_TERMINATED_INFO_); 
-						w.println(ProxyRemoteMessages.VM_TERMINATED_LINE1); 
-						w.println(stProxy.getErrorStreamMonitor().getContents());
-						w.println(ProxyRemoteMessages.VM_TERMINATED_LINE2); 
-						w.println(stProxy.getOutputStreamMonitor().getContents());
-						w.println(ProxyRemoteMessages.VM_TERMINATED_LINE3); 
-						w.close();
-		
-						DebugModeHelper dh = new DebugModeHelper();
-						dh.displayErrorMessage(ProxyRemoteMessages.Proxy_Error_Title, msg); 
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, s.toString(), null));
-						processListener = null;
-						DebugPlugin.getDefault().removeDebugEventListener(this);						
-						terminateRegistry();
-						break;
-					}
-				}
-			}
-		};
-		
-		DebugPlugin.getDefault().addDebugEventListener(processListener);
-	}
-	
-	private IDebugEventSetListener processListener = null;
-	
-	/**
-	 * Get the CallbackRegistry
-	 */
-	public ICallbackRegistry getCallbackRegistry() {
-		if (fCallbackServer == null)
-			fCallbackServer = new REMCallbackRegistry(fName, this);
-		return fCallbackServer;
-	}
-	
-	/**
-	 * This is called by the registry controller to tell
-	 * the registry to terminate with prejudice all 
-	 * pending TerminateJobs.
-	 * 
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void cancelAllTerminateJobs() {
-		IJobManager jobManager = Platform.getJobManager();
-		jobManager.cancel(TERMINATE_JOB_FAMILY);
-		try {
-			jobManager.join(TERMINATE_JOB_FAMILY, null);
-		} catch (OperationCanceledException e) {
-		} catch (InterruptedException e) {
-		}
-	}
-	
-	private static class TerminateProcess extends Job {
-		private IProcess process;
-		
-		public TerminateProcess(IProcess process) {
-			super(ProxyRemoteMessages.REMProxyFactoryRegistry_Job_TerminateProcess_Title);	 
-			this.process = process;
-		}
-		
-		public boolean belongsTo(Object family) {
-			return family == TERMINATE_JOB_FAMILY || super.belongsTo(family);
-		}
-		
-		
-		/* (non-Javadoc)
-		 * @see java.lang.Thread#run()
-		 */
-		public IStatus run(IProgressMonitor mon) {
-			try {
-				// There is no join on a process available, so we will have to
-				// busy wait. Give it 10 seconds in 1/10 second intervals.
-				for (int i=0; !process.isTerminated() && i<100; i++) {
-					try {
-						Thread.sleep(100);							
-					} catch (InterruptedException e) {
-					}
-				}
-				if (!process.isTerminated()) {
-					process.terminate();
-				} 
-			} catch (DebugException e) {
-			}
-			return Status.OK_STATUS;
-		}
-	}
-	
-	protected void registryTerminated(boolean wait) {
-		if (processListener != null) {
-			// Remove listener cause we are now going to terminate process and don't want premature terminate notice.
-			// Sometimes in shutdown we are called and the debug plugin may of already been shutdown. In that case the db
-			// will be null and there is nothing remove listener from.
-			DebugPlugin db = DebugPlugin.getDefault();
-			if (db != null)
-				db.removeDebugEventListener(processListener);
-			processListener = null;
-		}
-		
-		Job tjob = null;
-		if (fServerPort != 0) {
-			if (waitRegistrationThread != null) {
-				synchronized (waitRegistrationThread) {
-					// Still waiting. close it out.
-					WaitForRegistrationThread wThread = waitRegistrationThread;
-					waitRegistrationThread = null;
-					wThread.notifyAll();
-				}
-			}
-					
-			IREMConnection closeCon = null;	// The connection we will use to close the remote vm.
-			synchronized(fConnectionPool) {
-				// Now we walk through all of the free connections and close them properly.
-				Iterator itr = fConnectionPool.iterator();
-				if (itr.hasNext())
-					closeCon = (IREMConnection) itr.next();
-				while (itr.hasNext()) {
-					IREMConnection con = (IREMConnection) itr.next();
-					con.close();
-				}
-			}
-				
-			// Now we terminate the server.
-			if (closeCon == null)
-				try {
-					closeCon = getFreeConnection();	// There weren't any free connections, so get a new one so that we can close it.
-				} catch (IllegalStateException e) {
-					// Do nothing, don't want to stop termination just because we can't get a connection.
-				}
-			if (closeCon != null) {
-				closeCon.terminateServer();	// We got a connection to terminate (process may of terminated early, so we would not have a conn then).
-			}
-			fConnectionPool.clear();
-			fServerPort = 0;
-			
-			if (fProcess != null && !fRegistryController.inShutDown()) {
-				tjob = new TerminateProcess(fProcess);
-				tjob.setSystem(true);
-				tjob.schedule();
-				fProcess = null;
-			}
-		}
-	
-		if (fCallbackServer != null) {
-			fCallbackServer.requestShutdown();
-			fCallbackServer = null;				
-		}
-		
-		fConnectionPool.clear();
-		fRegistryController.deregisterRegistry(fRegistryKey);	// De-register this registry.
-		
-		if (wait && tjob != null) {
-			try {
-				tjob.join();
-			} catch (InterruptedException e) {
-				// It timed out, so we'll just go on.
-			}
-		}
-	}
-			
-	/**
-	 * Return the server port number.
-	 */
-	public int getServerPort() {
-		return fServerPort;
-	}
-	
-	/*
-	 * set the server port.
-	 */
-	void setServerPort(int serverport) {
-		fServerPort = serverport;
-		if (waitRegistrationThread != null) {
-				synchronized (waitRegistrationThread) {
-					// Close it out, we are now registered
-					WaitForRegistrationThread wThread = waitRegistrationThread;
-					waitRegistrationThread = null;
-					wThread.notifyAll();
-				}
-		}
-	}
-	
-	/**
-	 * Get a free connection
-	 * @return
-	 * @throws IllegalStateException - Thrown if a connection cannot be created.
-	 * 
-	 * @since 1.0.0
-	 */
-	public IREMConnection getFreeConnection() throws IllegalStateException {
-		Thread thread = Thread.currentThread();
-		if (thread instanceof REMCallbackThread) {
-			// The current thread is a call back thread, so just reuse the connection.
-			// But this thread could actually be trying to access another registry.
-			// So if this thread is for this registry, use it, if not for this registry, create a new connection.
-			// But if for this registry AND is already in a transaction, we need a fresh connection.
-			REMCallbackThread callbackThread = (REMCallbackThread) thread;
-			if (callbackThread.registry == this && !callbackThread.inTransaction()) {
-				// This way any calls out to the remote vm will be on same thread as callback caller
-				// on remote vm because that thread is waiting on this connection for commands.
-				IREMConnection c = (callbackThread).getConnection();
-				if (c.isConnected())
-					return c;
-				else
-					throw new IllegalStateException(ProxyRemoteMessages.REMProxyFactoryRegistry_CallbackConnectionNotWorking_EXC_); 
-			}
-		}
-		synchronized(fConnectionPool) {
-			if (!fConnectionPool.isEmpty())
-				return (IREMConnection) fConnectionPool.pop();
-			// else we need to allocate one.			
-			return createConnection();
-		}
-	}
-	
-
-	/**
-	 * Make a new connection.
-	 * @return
-	 * @throws IllegalStateException - Thrown if connection cannot be created.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected IREMConnection createConnection() throws IllegalStateException {
-		// If we have a server port, then the server is probably open. If we don't then there is no server.
-		if (fServerPort != 0) {
-			// We are putting it off into a thread because there are no timeout capabilities on getting a socket.
-			// So we need to allow for that.
-			final Socket[] scArray = new Socket[1];
-			final boolean[] waiting = new boolean[] {true};
-			Thread doIt = new Thread(new Runnable() {
-				public void run() {
-					try {
-						Socket sc = new Socket("localhost", fServerPort); //$NON-NLS-1$
-						synchronized (this) {
-							if (waiting[0])
-								scArray[0] = sc;
-							else
-								sc.close();	// We are no longer waiting on this thread so close the socket since no one will use it.
-						}
-					} catch (IOException e) {
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-					}
-				}
-			});
-			
-			doIt.start();
-			while (true) {
-				try {
-					doIt.join(!fNoTimeouts ? 60000 : 0);
-					synchronized (doIt) {
-						waiting[0] = false;	// To let it know we are no longer waiting
-					}
-					break;
-				} catch (InterruptedException e) {
-				}
-			}
-			
-			if (scArray[0] == null)  {
-				// Log where we are at so we can know where it was we down.
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", new IllegalStateException(ProxyRemoteMessages.REMProxyFactoryRegistry_ConnectionCreationFailed_INFO_)));	
-				throw new IllegalStateException(ProxyRemoteMessages.REMProxyFactoryRegistry_CouldNotCreateSocketConnectionToRemoteVM_EXC_);	// Couldn't get one, probably server is down. //$NON-NLS-1$
-			}
-
-			REMConnection connection = new REMConnection(scArray[0], fNoTimeouts);
-			if (connection.isConnected())
-				return connection;
-				
-			// Failed, close the socket. 
-			try {
-				scArray[0].close();
-			} catch (IOException e) {
-			}
-		} else
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "No Server to retrieve a connection.", null));	///$NON-NLS-1$
-		
-		throw new IllegalStateException(ProxyRemoteMessages.REMProxyFactoryRegistry_CouldNotCreateSocketConnectionToRemoteVM_EXC_); 
-	}
-		 
-	/**
-	 * Free the connection
-	 */
-	public void returnConnection(IREMConnection connection) {
-		if (connection.isConnected()) {
-			Thread thread = Thread.currentThread();
-			if (!(thread instanceof REMCallbackThread) || ((REMCallbackThread) thread).getConnection() != connection) {
-				// We are not a callback thread, or we are but the connection is not for the thread, then the connection
-				// can be returned.
-				synchronized (fConnectionPool) {
-					if (fConnectionPool.size() < NUMBER_FREE_CONNECTIONS)
-						fConnectionPool.push(connection);
-					else
-						connection.close();	// We don't need to maintain more than five free connections.
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Release this connection. This means close it out.
-	 */
-	public void closeConnection(IREMConnection connection) {
-		connection.close();
-	}
-	
-	
-	public int connectionCount() {
-		synchronized (fConnectionPool) {
-			return fConnectionPool.size();
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMRegistryController.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMRegistryController.java
deleted file mode 100644
index 6880a2a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMRegistryController.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMRegistryController.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.jobs.Job;
-
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
-
-/**
- * This class is a controller for all of the registries.
- * @author richkulp
- */
-public class REMRegistryController {
-	
-	private Map fActiveRegistries = new HashMap();	// Access to this must be sync(REMRegistryController)
-	private static final long CLEANUP_INTERVAL = 60000l;	// The interval between clean up job execution.
-	
-	protected boolean inShutdown;	// Are we in shutdown mode. Terminate registries runs differently in shutdown mode.
-	
-	// Thread to clean up GC'd proxies. Runs as a daemon at the lowest priority
-	private Job processQueueJob= new Job(ProxyRemoteMessages.CleanupJob_title) { 
-		public IStatus run(IProgressMonitor m) {
-				REMProxyFactoryRegistry[] registries = null;
-				synchronized (REMRegistryController.this) {
-					// This list may be updated by others, so we need to make a copy
-					// or else we could get a failure.
-					registries = 
-						(REMProxyFactoryRegistry[]) fActiveRegistries.values().toArray(
-							new REMProxyFactoryRegistry[fActiveRegistries.size()]);
-				}
-				for (int i = 0; i < registries.length; i++) {
-					try {
-						((REMStandardBeanProxyFactory) registries[i].getBeanProxyFactory()).processQueue();					
-					} catch (RuntimeException e) {
-						// When debugging, getBeanProxyFactory can throw exception because it hasn't been initialized
-						// yet when the thread wakes up, though the registry has been registered. It has to do with it 
-						// can take significant time for the user to start up the debugger, and during that time this
-						// thread could kick in.
-					}
-				}
-			synchronized(this) {
-				if (!m.isCanceled())
-					this.schedule(CLEANUP_INTERVAL);	// Schedule to start again in one minute.
-			}
-			return Status.OK_STATUS;
-		}
-
-	}; //$NON-NLS-1$	
-	
-	public REMRegistryController() {
-
-		ProxyPlugin.getPlugin().addProxyShutdownListener(new ProxyPlugin.IProxyPluginShutdownListener() {
-			/*
-			 * (non-Javadoc)
-			 * 
-			 * @see org.eclipse.jem.internal.proxy.core.ProxyPlugin.IProxyPluginShutdownListener#shutdown()
-			 */
-			public void shutdown() {
-				REMRegistryController.this.shutdown();
-			}
-		});
-
-		masterThread = new REMMasterServerThread(this);
-		masterThread.start();
-
-		processQueueJob.setSystem(true);	// So that it won't show processing in process view. Not of interest to general users.
-		processQueueJob.setPriority(Job.SHORT);
-		processQueueJob.schedule(CLEANUP_INTERVAL);
-
-	}
-	
-	/**
-	 * Answer whether we are shutting down or not.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean inShutDown() {
-		return inShutdown;
-	}
-	
-	/*
-	 * Add registry to list of active. Return a unique number to be the key.
-	 * Package-protected so that only locals can access it.
-	 */
-	synchronized Integer registerRegistry(REMProxyFactoryRegistry registry) {
-			
-		Integer hashcode = new Integer(registry.hashCode());		
-		while (true) {
-			REMProxyFactoryRegistry existing = (REMProxyFactoryRegistry) fActiveRegistries.get(hashcode);
-			if (existing == null)
-				break;	// Not yet registered, use use the hashcode
-			else if (existing != registry)
-				hashcode = new Integer(hashcode.intValue()+1);						
-			else
-				return hashcode;	// Same guy, use the hashcode.
-		}
-		
-		fActiveRegistries.put(hashcode, registry);
-		return hashcode;
-	}
-	
-	/*
-	 * deregister the registry.
-	 */
-	synchronized void deregisterRegistry(Integer key) {
-		fActiveRegistries.remove(key);
-	}
-	
-	/*
-	 * Return the registry for the given key
-	 */
-	synchronized REMProxyFactoryRegistry getRegistry(Integer key) {
-		return (REMProxyFactoryRegistry) fActiveRegistries.get(key);
-	}
-	
-	/**
-	 * Master server thread. Handles keep-alive requests and register remote server threads.
-	 * It will be created when needed.
-	 */
-	protected REMMasterServerThread masterThread;
-
-	/*
-	 * Shuts down this plug-in and discards all plug-in state.
-	 *
-	 * In this case, terminate all of the active registries so that they can be shutdown.
-	 * Don't want them hanging around after termination of the desktop.
-	 */
-	void shutdown() {
-		
-		synchronized(processQueueJob) {
-			processQueueJob.cancel();
-		}
-			
-		REMProxyFactoryRegistry[] registries = null;
-		synchronized (this) {
-			// This list will be updated in the terminateRegistry, so we need to make a copy
-			// or else we get a failure.
-			registries = 
-				(REMProxyFactoryRegistry[]) fActiveRegistries.values().toArray(
-					new REMProxyFactoryRegistry[fActiveRegistries.size()]);
-		}
-		
-		inShutdown = true;	// We are now in shutdown mode.
-		// In shutdown mode the registries will not create the job that waits for the process
-		// to terminate, and if it doesn't in 1.5 secs it does a force.
-		// Instead what we will do is shutdown all of the registries. If they don't
-		// shutdown on their own then they stay out there. But they do have an
-		// internal timer that checks every five minutes to see if the host is 
-		// still there, and if it isn't they will shut themselves down. They
-		// would have to be really hosed if the suicide timer wasn't working.
-		
-		for (int i = 0; i < registries.length; i++)
-			registries[i].terminateRegistry();
-			
-		if (masterThread != null) {
-			try {
-				masterThread.requestShutdown();
-				masterThread.join(20000);	// Wait 20 seconds for everything to go down.
-				masterThread = null;				
-			} catch (InterruptedException e) {
-			}
-		}
-		
-		try {
-			processQueueJob.join();
-		} catch(InterruptedException e) {
-		}
-		
-		REMProxyFactoryRegistry.cancelAllTerminateJobs();
-	}
-	
-	/**
-	 * Return the master socket port number.
-	 */
-	public int getMasterSocketPort() {
-		return masterThread != null ? masterThread.getMasterSocket().getLocalPort() : -1;
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortClassBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortClassBeanProxy.java
deleted file mode 100644
index b395fed..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortClassBeanProxy.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMShortClassBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Proxy for Short.class.
- */
-class REMShortClassBeanProxy extends REMNumberBeanProxy {
-
-REMShortClassBeanProxy(REMProxyFactoryRegistry aRegistry, Short aShort) {
-	super(aRegistry, aShort);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).shortClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set((Short) numberValue());
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortClassBeanTypeProxy.java
deleted file mode 100644
index 8a4a7fe..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortClassBeanTypeProxy.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMShortClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Short.class.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMShortClassBeanTypeProxy extends REMAbstractNumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final INumberBeanProxy oneProxy;
-	private final INumberBeanProxy twoProxy;
-	private final INumberBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMShortClassBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy numberType) {
-	super(aRegistry, new Integer(Commands.SHORT_CLASS), Short.class.getName(), numberType);
-	
-	// Create the cached values
-	zeroProxy = new REMShortClassBeanProxy(aRegistry, new Short((short)0));	
-	oneProxy = new REMShortClassBeanProxy(aRegistry, new Short((short)1));
-	twoProxy = new REMShortClassBeanProxy(aRegistry, new Short((short)2));
-	threeProxy = new REMShortClassBeanProxy(aRegistry, new Short((short)3));		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createShortBeanProxy(Short aShort) {
-	switch(aShort.shortValue()) {
-		case 0: return zeroProxy;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new REMShortClassBeanProxy(fRegistry, aShort);
-	}
-}
-
-/**
- * Generic way to create a Short proxy, however, the Number must be a Short.
- */
-protected INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	return createShortBeanProxy((Short) aNumber);
-}	
-
-/**
- * newInstance method. Number's don't have a default ctor, so the standard way won't work.
- * Return the zero proxy for this case.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createShortBeanProxy(new Short(value.aShort));
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortTypeBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortTypeBeanProxy.java
deleted file mode 100644
index 43c09ae..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortTypeBeanProxy.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMShortTypeBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Remote Implementation of INumberBeanProxy for the primitive "short".
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class REMShortTypeBeanProxy extends REMConstantBeanProxy implements INumberBeanProxy {
-	private final short fShort;
-
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-REMShortTypeBeanProxy(REMProxyFactoryRegistry aRegistry, short aShort) {
-	super(aRegistry);
-	fShort = aShort;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof REMShortTypeBeanProxy)
-		return fShort == ((REMShortTypeBeanProxy) anObject).shortValue();
-	if (anObject instanceof Short)
-		return fShort == ((Short) anObject).shortValue();
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
- */
-public boolean sameAs(IBeanProxy aBeanProxy) {
-	if (this == aBeanProxy)
-		return true;	// Identity
-	if (aBeanProxy instanceof REMShortTypeBeanProxy)
-		return fShort == ((REMShortTypeBeanProxy) aBeanProxy).shortValue();
-	return false;
-}
-
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return (byte) fShort;
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fShort;
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fShort;
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return fShort;
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return fShort;
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return new Short(fShort);
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return fShort;
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return String.valueOf(fShort);
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).shortType;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fShort);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortTypeBeanTypeProxy.java
deleted file mode 100644
index d9ba82c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMShortTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMShortTypeBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * Remote Implementation of IBeanTypeProxy for Short.TYPE.
- * Creation date: (2/6/00 9:01:40 AM)
- * @author: Joe Winchester
- */
-final class REMShortTypeBeanTypeProxy extends REMPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final INumberBeanProxy zeroProxy;
-	private final INumberBeanProxy oneProxy;
-	private final INumberBeanProxy twoProxy;
-	private final INumberBeanProxy threeProxy;
-/**
- * REMIntegerBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMShortTypeBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.SHORT_TYPE), Short.TYPE.getName());
-	
-	// Create the cached values
-	zeroProxy = new REMShortTypeBeanProxy(aRegistry, (short) 0);	
-	oneProxy = new REMShortTypeBeanProxy(aRegistry, (short) 1);
-	twoProxy = new REMShortTypeBeanProxy(aRegistry, (short) 2);
-	threeProxy = new REMShortTypeBeanProxy(aRegistry, (short) 3);		
-}
-
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createShortBeanProxy(short aShort) {
-	switch(aShort) {
-		case 0: return zeroProxy;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new REMShortTypeBeanProxy(fRegistry, aShort);
-	}
-}
-
-/**
- * newInstance method. short is a primitive, so the standard way won't work.
- * Return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return zeroProxy;
-}	
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createShortBeanProxy(value.aShort);
-}
-
-/**
- * Short cut for newInstance where the string follows the
- * specific pattern we expect. That way it won't be necessary to ship over to the vm 
- * to process it.
- *
- * The pattern it can accept is:
- * 	1) (short) validNumber - number can be any number because (byte) explicitly casts it down.
- *	2) validNumber
- * It will use the decode function of short to determine the valid number.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	String trim = initializationString.trim();
-	if (trim.length() == 0)
-		return super.newInstance(initializationString);	
-	short aShort;
-	if (trim.startsWith("(short)")) { //$NON-NLS-1$
-		Number v = parseString(trim.substring("(short)".length()).trim()); //$NON-NLS-1$
-		if (v != null)
-			aShort = v.shortValue();
-		else
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-	} else {
-		try {
-			aShort = Short.decode(trim).shortValue();	// See if valid short format.
-		} catch (NumberFormatException e) {
-			return super.newInstance(initializationString);	// Can't decode it, let full parser handle it.
-		}
-	}
-
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(aShort);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanProxyConstants.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanProxyConstants.java
deleted file mode 100644
index 3ab997d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanProxyConstants.java
+++ /dev/null
@@ -1,508 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMStandardBeanProxyConstants.java,v $
- *  $Revision: 1.9 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.IMethodProxy;
-import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry;
-/**
- * REM Standard Proxy constants.
- *
- * Use the static accessor method (getConstants()) to get the appropriate 
- * constants instance for the registry. This is done so that until the
- * the constants are needed, they aren't registered.
- *
- * There are some standard utility functions too.
- *
- * This is final because this can't be extended. This specific one
- * will be registered with the factory for this key. Any extensions
- * must be done in their own constants and registry key.
- *
- * Creation date: (4/7/00 4:47:48 PM)
- * @author: Administrator
- */
-public final class REMStandardBeanProxyConstants {
-	public static final Object REGISTRY_KEY = new Object();
-		
-	private final ProxyFactoryRegistry fRegistry;
-	
-	private IMethodProxy fClassNewInstance;
-	private IMethodProxy fClassGetField;
-	private IMethodProxy fClassGetDeclaredField;
-	private IMethodProxy fClassGetDeclaredFields;	
-	private IMethodProxy fClassGetFields;	
-	private IMethodProxy fClassGetConstructor;
-	private IMethodProxy fClassGetConstructors;
-	private IMethodProxy fClassGetDeclaredConstructor;
-	private IMethodProxy fClassGetDeclaredConstructors;
-	private IMethodProxy fClassGetMethods;
-	private IMethodProxy fClassGetDeclaredMethods;
-	private IMethodProxy fClassGetDeclaredMethod;
-	
-	private IMethodProxy fMethodHelperFindCompatibleConstructor;
-	private IMethodProxy fMethodHelperFindCompatibleMethod;
-	
-	private IMethodProxy fClassIsAssignableFrom;
-	
-	private IMethodProxy fObjectToString;
-	private IMethodProxy fObjectEquals;
-	
-	private IMethodProxy fThrowableLocalizedMessage;
-	private IMethodProxy fThrowableMessage;
-	
-	private IMethodProxy fMethodDeclaringClassMessage;
-	private IMethodProxy fMethodMethodNameMessage;
-	private IMethodProxy fMethodParameterTypesMessage;
-	private IMethodProxy fMethodReturnTypeMessage;
-	
-	private IMethodProxy fAccessibleIsAccessible;
-	private IMethodProxy fAccessibleSetAccessible;
-	
-	private IMethodProxy fFieldGet;
-	private IMethodProxy fFieldGetType;
-	private IMethodProxy fFieldGetByte;
-	private IMethodProxy fFieldGetBoolean;
-	private IMethodProxy fFieldGetChar;
-	private IMethodProxy fFieldGetDouble;
-	private IMethodProxy fFieldGetFloat;
-	private IMethodProxy fFieldGetInt;
-	private IMethodProxy fFieldGetShort;
-	private IMethodProxy fFieldGetLong;	
-	private IMethodProxy fFieldSet;
-	
-	private IMethodProxy fConstructorNewInstance;	
-	private IMethodProxy fConstructorParameterTypesMessage;
-	
-	private IMethodProxy fArrayNewInstanceOneDimension;
-	private IMethodProxy fArrayNewInstanceMultiDimensions;
-	private IMethodProxy fArrayGetLength;
-	private IMethodProxy fArrayGet;
-	private IMethodProxy fArrayGetByte;
-	private IMethodProxy fArrayGetBoolean;
-	private IMethodProxy fArrayGetChar;
-	private IMethodProxy fArrayGetDouble;
-	private IMethodProxy fArrayGetFloat;
-	private IMethodProxy fArrayGetInt;
-	private IMethodProxy fArrayGetShort;
-	private IMethodProxy fArrayGetLong;	
-	private IMethodProxy fArraySet;	
-	
-	private IMethodProxy fArrayHelperGet;
-	private IMethodProxy fArrayHelperGetByte;
-	private IMethodProxy fArrayHelperGetBoolean;
-	private IMethodProxy fArrayHelperGetChar;
-	private IMethodProxy fArrayHelperGetDouble;
-	private IMethodProxy fArrayHelperGetFloat;
-	private IMethodProxy fArrayHelperGetInt;
-	private IMethodProxy fArrayHelperGetShort;
-	private IMethodProxy fArrayHelperGetLong;	
-	private IMethodProxy fArrayHelperSet;			
-	
-/**
- * Get the constants instance for the specified registry.
- */
-public static REMStandardBeanProxyConstants getConstants(ProxyFactoryRegistry registry) {
-	REMStandardBeanProxyConstants constants = (REMStandardBeanProxyConstants) registry.getConstants(REGISTRY_KEY);
-	if (constants == null)
-		registry.registerConstants(REGISTRY_KEY, constants = new REMStandardBeanProxyConstants(registry));	
-	return constants;
-}
-
-
-private REMStandardBeanProxyConstants(ProxyFactoryRegistry registry) {
-	super();
-	fRegistry = registry;
-}
-
-public IMethodProxy getClassNewInstance() {
-	// We actually need a special new instance because we want to be able to access outside of security. For our purposes security doesn't matter for construction.
-	if (fClassNewInstance == null)
-		fClassNewInstance = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ClassHelper", "newInstance", new String[] {"java.lang.Class"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fClassNewInstance;
-}
-
-public IMethodProxy getClassGetField() {
-	if (fClassGetField == null)
-		fClassGetField = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getField", new String[] {"java.lang.String"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fClassGetField;
-}
-
-public IMethodProxy getClassConstructor() {
-	if (fClassGetConstructor == null)
-		fClassGetConstructor = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getConstructor", new String[] {"[Ljava.lang.Class;"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fClassGetConstructor;
-}
-
-public IMethodProxy getClassConstructors() {
-	if (fClassGetConstructors == null)
-		fClassGetConstructors = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getConstructors", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fClassGetConstructors;
-}
-
-public IMethodProxy getDeclaredClassConstructor() {
-	if (fClassGetDeclaredConstructor == null)
-		fClassGetDeclaredConstructor = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getDeclaredConstructor", new String[] {"[Ljava.lang.Class;"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fClassGetDeclaredConstructor;
-}
-
-public IMethodProxy getDeclaredClassConstructors() {
-	if (fClassGetDeclaredConstructors == null)
-		fClassGetDeclaredConstructors = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getDeclaredConstructors", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fClassGetDeclaredConstructors;
-}
-
-public IMethodProxy getClassIsAssignableFrom() {
-	if (fClassIsAssignableFrom == null)
-		fClassIsAssignableFrom = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "isAssignableFrom", new String[] {"java.lang.Class"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fClassIsAssignableFrom;
-}
-
-public IMethodProxy getObjectToString() {
-	if (fObjectToString == null)
-		fObjectToString = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Object", "toString", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fObjectToString;
-}
-
-public IMethodProxy getObjectEquals() {
-	if (fObjectEquals == null)
-		fObjectEquals = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Object", "equals", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fObjectEquals;
-}
-public IMethodProxy getThrowableLocalizedMessage() {
-	if (fThrowableLocalizedMessage == null)
-		fThrowableLocalizedMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Throwable", "getLocalizedMessage", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fThrowableLocalizedMessage;
-}
-
-public IMethodProxy getThrowableMessage() {
-	if (fThrowableMessage == null)
-		fThrowableMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Throwable", "getMessage", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fThrowableMessage;
-}
-
-public IMethodProxy getMethodDeclaringClassMessage() {
-	if (fMethodDeclaringClassMessage == null)
-		fMethodDeclaringClassMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Method", "getDeclaringClass", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fMethodDeclaringClassMessage;
-}
-
-public IMethodProxy getMethodMethodNameMessage() {
-	if (fMethodMethodNameMessage == null)
-		fMethodMethodNameMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Method", "getName", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fMethodMethodNameMessage;
-}	
-
-public IMethodProxy getMethodParameterTypesMessage() {
-	if (fMethodParameterTypesMessage == null)
-		fMethodParameterTypesMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Method", "getParameterTypes", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fMethodParameterTypesMessage;
-}
-
-public IMethodProxy getMethodReturnTypeMessage() {
-	if (fMethodReturnTypeMessage == null)
-		fMethodReturnTypeMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Method", "getReturnType", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fMethodReturnTypeMessage;
-}
-
-public IMethodProxy getAccessibleIsAccessible() {
-	if (fAccessibleIsAccessible == null)
-		fAccessibleIsAccessible = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.AccessibleObject", "isAccessible", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fAccessibleIsAccessible;
-}
-
-public IMethodProxy getAccessibleSetAccessible() {
-	if (fAccessibleSetAccessible == null)
-		fAccessibleSetAccessible = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.AccessibleObject", "setAccessible", new String[] {"boolean"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fAccessibleSetAccessible;
-}
-
-public IMethodProxy getFieldGetType() {
-	if (fFieldGetType == null)
-		fFieldGetType = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getType", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fFieldGetType;
-}
-
-public IMethodProxy getFieldGet() {
-	if (fFieldGet == null)
-		fFieldGet = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "get", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGet;
-}
-
-public IMethodProxy getFieldGetByte() {
-	if (fFieldGetByte == null)
-		fFieldGetByte = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getByte", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetByte;
-}
-
-public IMethodProxy getFieldGetBoolean() {
-	if (fFieldGetBoolean == null)
-		fFieldGetBoolean = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getBoolean", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetBoolean;
-}
-
-public IMethodProxy getFieldGetChar() {
-	if (fFieldGetChar == null)
-		fFieldGetChar = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getChar", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetChar;
-}
-
-public IMethodProxy getFieldGetDouble() {
-	if (fFieldGetDouble == null)
-		fFieldGetDouble = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getDouble", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetDouble;
-}
-
-public IMethodProxy getFieldGetFloat() {
-	if (fFieldGetFloat == null)
-		fFieldGetFloat = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getFloat", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetFloat;
-}
-
-public IMethodProxy getFieldGetInt() {
-	if (fFieldGetInt == null)
-		fFieldGetInt = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getInt", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetInt;
-}
-
-public IMethodProxy getFieldGetLong() {
-	if (fFieldGetLong == null)
-		fFieldGetLong = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getLong", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetLong;
-}
-
-public IMethodProxy getFieldGetShort() {
-	if (fFieldGetShort == null)
-		fFieldGetShort = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "getShort", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fFieldGetShort;
-}
-
-public IMethodProxy getFieldSet() {
-	if (fFieldSet == null)
-		fFieldSet = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Field", "set", new String[] {"java.lang.Object", "java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fFieldSet;
-}
-
-public IMethodProxy getConstructorNewInstance() {
-	if (fConstructorNewInstance == null)
-		fConstructorNewInstance = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Constructor", "newInstance", new String[] {"[Ljava.lang.Object;"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fConstructorNewInstance;
-}
-
-public IMethodProxy getConstructorParameterTypesMessage() {
-	if (fConstructorParameterTypesMessage == null)
-		fConstructorParameterTypesMessage = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Constructor", "getParameterTypes", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fConstructorParameterTypesMessage;
-}
-
-public IMethodProxy getArrayNewInstanceOneDimension() {
-	if (fArrayNewInstanceOneDimension == null)
-		fArrayNewInstanceOneDimension = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "newInstance", new String[] {"java.lang.Class", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayNewInstanceOneDimension;
-}
-
-public IMethodProxy getArrayNewInstanceMultiDimension() {
-	if (fArrayNewInstanceMultiDimensions == null)
-		fArrayNewInstanceMultiDimensions = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "newInstance", new String[] {"java.lang.Class", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayNewInstanceMultiDimensions;
-}
-
-public IMethodProxy getArrayGetLength() {
-	if (fArrayGetLength == null)
-		fArrayGetLength = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getLength", new String[] {"java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fArrayGetLength;
-}
-
-public IMethodProxy getArrayGet() {
-	if (fArrayGet == null)
-		fArrayGet = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "get", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGet;
-}
-
-public IMethodProxy getArrayGetByte() {
-	if (fArrayGetByte == null)
-		fArrayGetByte = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getByte", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetByte;
-}
-
-public IMethodProxy getArrayGetBoolean() {
-	if (fArrayGetBoolean == null)
-		fArrayGetBoolean = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getBoolean", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetBoolean;
-}
-
-public IMethodProxy getArrayGetChar() {
-	if (fArrayGetChar == null)
-		fArrayGetChar = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getChar", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetChar;
-}
-
-public IMethodProxy getArrayGetDouble() {
-	if (fArrayGetDouble == null)
-		fArrayGetDouble = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getDouble", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetDouble;
-}
-
-public IMethodProxy getArrayGetFloat() {
-	if (fArrayGetFloat == null)
-		fArrayGetFloat = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getFloat", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetFloat;
-}
-
-public IMethodProxy getArrayGetInt() {
-	if (fArrayGetInt == null)
-		fArrayGetInt = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getInt", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetInt;
-}
-
-public IMethodProxy getArrayGetLong() {
-	if (fArrayGetLong == null)
-		fArrayGetLong = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getLong", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetLong;
-}
-
-public IMethodProxy getArrayGetShort() {
-	if (fArrayGetShort == null)
-		fArrayGetShort = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "getShort", new String[] {"java.lang.Object", "int"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayGetShort;
-}
-
-public IMethodProxy getArraySet() {
-	if (fArraySet == null)
-		fArraySet = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.reflect.Array", "set", new String[] {"java.lang.Object", "int", "java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	return fArraySet;
-}
-
-public IMethodProxy getArrayHelperGet() {
-	if (fArrayHelperGet == null)
-		fArrayHelperGet = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "get", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGet;
-}
-
-public IMethodProxy getArrayHelperGetByte() {
-	if (fArrayHelperGetByte == null)
-		fArrayHelperGetByte = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getByte", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetByte;
-}
-
-public IMethodProxy getArrayHelperGetBoolean() {
-	if (fArrayHelperGetBoolean == null)
-		fArrayHelperGetBoolean = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getBoolean", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetBoolean;
-}
-
-public IMethodProxy getArrayHelperGetChar() {
-	if (fArrayHelperGetChar == null)
-		fArrayHelperGetChar = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getChar", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetChar;
-}
-
-public IMethodProxy getArrayHelperGetDouble() {
-	if (fArrayHelperGetDouble == null)
-		fArrayHelperGetDouble = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getDouble", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetDouble;
-}
-
-public IMethodProxy getArrayHelperGetFloat() {
-	if (fArrayHelperGetFloat == null)
-		fArrayHelperGetFloat = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getFloat", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetFloat;
-}
-
-public IMethodProxy getArrayHelperGetInt() {
-	if (fArrayHelperGetInt == null)
-		fArrayHelperGetInt = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getInt", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetInt;
-}
-
-public IMethodProxy getArrayHelperGetLong() {
-	if (fArrayHelperGetLong == null)
-		fArrayHelperGetLong = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getLong", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetLong;
-}
-
-public IMethodProxy getArrayHelperGetShort() {
-	if (fArrayHelperGetShort == null)
-		fArrayHelperGetShort = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "getShort", new String[] {"java.lang.Object", "[I"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fArrayHelperGetShort;
-}
-
-public IMethodProxy getArrayHelperSet() {
-	if (fArrayHelperSet == null)
-		fArrayHelperSet = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.ArrayHelper", "set", new String[] {"java.lang.Object", "[I", "java.lang.Object"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	return fArrayHelperSet;
-}
-
-
-public IMethodProxy getClassGetDeclaredField() {
-
-	if (fClassGetDeclaredField == null)
-			fClassGetDeclaredField = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getDeclaredField", new String[] {"java.lang.String"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-	return fClassGetDeclaredField;
-}
-
-public IMethodProxy getClassGetDeclaredFields() {
-
-	if (fClassGetDeclaredFields == null)
-			fClassGetDeclaredFields = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getDeclaredFields", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fClassGetDeclaredFields;
-}
-public IMethodProxy getClassGetFields() {
-
-	if (fClassGetFields == null)
-			fClassGetFields = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getFields", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fClassGetFields;
-}
-
-
-/**
- * @return
- * 
- * @since 1.1.0
- */
-public IMethodProxy getClassMethods() {
-	if (fClassGetMethods == null)
-		fClassGetMethods = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getMethods", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fClassGetMethods;
-}
-
-/**
- * @return
- * 
- * @since 1.1.0
- */
-public IMethodProxy getClassDeclaredMethods() {
-	if (fClassGetDeclaredMethods == null)
-		fClassGetDeclaredMethods = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getDeclaredMethods", null); //$NON-NLS-1$ //$NON-NLS-2$
-	return fClassGetDeclaredMethods;
-}
-
-public IMethodProxy getClassDeclaredMethod() {
-	if (fClassGetDeclaredMethod == null)
-		fClassGetDeclaredMethod = fRegistry.getMethodProxyFactory().getMethodProxy("java.lang.Class", "getDeclaredMethod", new String[] {"java.lang.String", "[Ljava.lang.Class;"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fClassGetDeclaredMethod;
-}
-
-public IMethodProxy getFindCompatibleConstructorMethod() {
-	if (fMethodHelperFindCompatibleConstructor == null)
-		fMethodHelperFindCompatibleConstructor = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.common.MethodHelper", "findCompatibleConstructor", new String[] {"java.lang.Class", "[Ljava.lang.Class;"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-	return fMethodHelperFindCompatibleConstructor;
-}
-
-public IMethodProxy getFindCompatibleMethodMethod() {
-	if (fMethodHelperFindCompatibleMethod == null)
-		fMethodHelperFindCompatibleMethod = fRegistry.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.common.MethodHelper", "findCompatibleMethod", new String[] {"java.lang.Class", "java.lang.String", "[Ljava.lang.Class;"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	return fMethodHelperFindCompatibleMethod;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanProxyFactory.java
deleted file mode 100644
index ba2e374..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanProxyFactory.java
+++ /dev/null
@@ -1,854 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMStandardBeanProxyFactory.java,v $
- *  $Revision: 1.16 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import java.text.MessageFormat;
-import java.util.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.CommandErrorException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * The Remote VM Standard Bean Proxy Factory.
- * Creation date: (12/3/99 12:01:45 PM)
- * @author: Joe Winchester
- */
-public final class REMStandardBeanProxyFactory implements IStandardBeanProxyFactory {
-	protected final REMProxyFactoryRegistry fRegistry;
-	protected final REMStandardBeanTypeProxyFactory fBeanTypeProxyFactory;	// Convenience field.
-	protected final IREMBeanProxy vmServerProxy;
-
-	
-	// We need a map for mapping object id's to the proxy. The entry will actually be
-	// a REMStandardBeanProxyFactory.WeakProxyReference. This is so that the
-	// proxy will not be held tightly by this map and can be GC'd if not referenced.
-	// Periodically, the reference queue will be processed to remove any of the
-	// entries that have been GC'd and the server will be told that it can release
-	// the ID on its side.
-	//
-	// This map will be used as synchronize object also for access to it.
-	//
-	// There will be a low priority job that will occasionally process the GC'd objects
-	// and remove them from the queue and the remote vm. It will not remove during lockedTransactions.
-	//
-	// NOTE: Certain proxies never get added to the map. They are the
-	// standard types/class (i.e. null, byte, int, long, short, double, float, byte, string). These
-	// always have the value saved in the proxy so that it can be retrieved without going back
-	// to the server. 
-	private final HashMap fIDToProxiesMap = new HashMap(1000);	// Map ID's to proxies. The proxies have their id's so we don't need a reverse map
-	private int transactionLockCount = 0;	// Count of transactions that have locked access. It is changed under sync control of fIDToProxies map.
-	
-	/**
-	 * The Weak reference used for the id to proxies map for the proxy
-	 * so that we can clean it up when the proxy has been garbage collected.
-	 *
-	 * It is important that all changes to the ProxyRef are done through sync on fIDToProxiesMap.
-	 */
-	private static class ProxyRef extends java.lang.ref.WeakReference {
-		private Integer id;	// We need the id because this reference will be on the value side
-					// and not the key side of the map, so we need to know the key
-					// so that the object can be removed from the map.
-					//
-					// If the ID is null, then this means this entry has been processed
-					// in some way and should not be released or removed from the table.
-		private int useCnt = 1;	// Usage/Ref count. Needed so that we don't get rid of too soon. Since we don't
-					// create a ProxyRef without a usage, we start it off with one. It will be incremented
-					// then on retrievals when needed by users outside of the remote factories themselves.
-					// It won't be physically released until either GC got rid of it, or it goes to 0 or less
-					// on a release request.
-					
-		public ProxyRef(Integer anID, Object proxy, java.lang.ref.ReferenceQueue q) {
-			super(proxy, q);
-			id = anID;
-		}
-		
-		public Integer getID() {
-			return id;
-		}
-		
-		public void clear() {
-			super.clear();
-			id = null;
-		}
-		
-		public synchronized int useCnt() {
-			return useCnt;
-		}
-		
-		public synchronized void incrUseCnt() {
-			useCnt++;
-		}
-		
-		public synchronized int decrUseCnt() {
-			if (--useCnt < 0)
-				useCnt = 0;
-			return useCnt;
-		}
-	}
-	
-	/* Reference queue for cleared Proxies */
-	private java.lang.ref.ReferenceQueue queue = new java.lang.ref.ReferenceQueue();	
-	
-	/**
-	 * Process the entries on the id to proxies map that have been garbage collected.
-	 * It is package-protected because only REMRegistryController should call it.
-	 */
-	void processQueue() {
-		ProxyRef pr;	
-		while (true) {
-			if (Thread.interrupted())
-				return;	// Maybe going down.	(This actually a kludge because the thread happens to be the master thread from the registry controller).
-				
-			synchronized (fIDToProxiesMap) {
-				if (queue == null || transactionLockCount > 0)
-					break;	// Either no queue (we are cleaning up) or in a transaction, stop processing and retry on next time slice.
-				if ((pr = (ProxyRef) queue.poll()) != null) {				
-					if (pr.getID() != null) {
-						// It hasn't been processed by some other means.				
-						fIDToProxiesMap.remove(pr.getID());						
-						releaseID(pr.getID().intValue());
-					}
-				} else
-					break;	// There are no more waiting, so leave.
-			}
-		}
-	}
-	
-	
-/**
- * REMBeanProxyFactory constructor comment.
- *
- * Note: It assumes the beantype factory has already been registered.
- */
-REMStandardBeanProxyFactory(REMProxyFactoryRegistry aRegistry) {
-	fRegistry = aRegistry;
-	aRegistry.registerBeanProxyFactory(this);
-	fBeanTypeProxyFactory = (REMStandardBeanTypeProxyFactory) aRegistry.getBeanTypeProxyFactory();
-	fBeanTypeProxyFactory.initialize(this);	// Now we're ready for the beantype factory to be initialized.
-	
-	IREMBeanTypeProxy serverType = fBeanTypeProxyFactory.objectClass.newBeanTypeForClass(new Integer(Commands.REMOTEVMSERVER_CLASS), "org.eclipse.jem.internal.proxy.vm.remote.RemoteVMServerThread", false); //$NON-NLS-1$
-	fBeanTypeProxyFactory.registerBeanTypeProxy(serverType, true);
-	vmServerProxy = serverType.newBeanProxy(new Integer(Commands.REMOTESERVER_ID));
-	registerProxy(vmServerProxy);
-}
-
-
-/**
- * Register a collection of Proxies
- */
-public void registerProxies(Collection proxies) {
-	synchronized(fIDToProxiesMap) {
-		Iterator itr = proxies.iterator();
-		while (itr.hasNext()) {
-			IREMBeanProxy proxy = (IREMBeanProxy) itr.next();
-			if (proxy instanceof IBeanTypeProxy || !(proxy.getTypeProxy() instanceof IREMConstantBeanTypeProxy)) {
-				ProxyRef oldRef = (ProxyRef) fIDToProxiesMap.put(proxy.getID(), new ProxyRef(proxy.getID(), proxy, queue));
-				if (oldRef != null) {
-					// We've replaced it with a new one, so we will clear out the ref so that it won't later try to remove itself
-					oldRef.clear();
-				}
-			}
-		}		
-	}
-}
-
-/**
- * Register a single proxy
- */
-public void registerProxy(IREMBeanProxy proxy) {
-	if (proxy instanceof IBeanTypeProxy || !(proxy.getTypeProxy() instanceof IREMConstantBeanTypeProxy))
-		synchronized(fIDToProxiesMap) {
-			ProxyRef oldRef = (ProxyRef) fIDToProxiesMap.put(proxy.getID(), new ProxyRef(proxy.getID(), proxy, queue));
-			if (oldRef != null) {
-				// We've replaced it with a new one, so we will clear out the ref so that it won't later try to remove itself
-				oldRef.clear();
-			}							
-		}
-}
-
-/**
- * Release a proxy because no longer needed.
- */
-public void releaseProxy(IBeanProxy proxy) {
-	if (!proxy.isValid())
-		return;
-	if (proxy instanceof IBeanTypeProxy && !fBeanTypeProxyFactory.releaseProxy((IBeanTypeProxy) proxy))
-		return;	// BeanType and type factory won't allow release of it.
-	Integer id = ((IREMBeanProxy) proxy).getID();
-	synchronized(fIDToProxiesMap) {			
-		// Synced in here so that we will remove it before some one else from a different thread may try
-		// to access it again.
-		if (id.intValue() != Commands.NOT_AN_ID) {
-			ProxyRef ref = (ProxyRef) fIDToProxiesMap.get(id);
-			if (ref == null || ref.decrUseCnt() <= 0) {
-				// No usage, so do actual release.
-				fIDToProxiesMap.remove(id);
-				((IREMBeanProxy) proxy).release();
-				if (ref != null)
-					ref.enqueue();	// Queue it up so that on next release cycle it will go away.
-			} 
-		} else {
-			((IREMBeanProxy) proxy).release();			
-		}
-	}
-}
-
-/**
- * Release a specific ID. This is used in case an ID has been sent
- * but we couldn't proxy it. In that case we only have an ID. It is
- * also used when a proxy has been released explicitly or through GC.
- * In that case it has already been de-registered.
- */
-private void releaseID(int anID) {
-	try {
-		IREMConnection connect = fRegistry.getFreeConnection();
-		try {
-			connect.releaseID(anID);
-		} finally {
-			fRegistry.returnConnection(connect);
-		}
-	} catch (IllegalStateException e) {
-		// Couldn't get connection, don't bother with a release.
-	}
-}
-
-/**
- * For the Remote Factory we will create an REMBeanProxy using the null constructor
- * Package protected so only REMBeanTypeProxies can create instances.
- */
- 
-IBeanProxy createBeanProxy(IREMBeanTypeProxy aTypeProxy) throws ThrowableProxy {
-	return REMStandardBeanProxyConstants.getConstants(fRegistry).getClassNewInstance().invoke(null, aTypeProxy);
-}
-
-/**
- * For the Remote Factory we will create a REMBeanProxy using the initializationString.
- * Package protected so only REMBeanTypeProxies can create instances. 
- */
-IBeanProxy createBeanProxy(IREMBeanTypeProxy aTypeProxy, String initializationString)
-	throws ThrowableProxy, CommandException, ClassCastException, InstantiationException, IllegalStateException {
-	IREMConnection connect = fRegistry.getFreeConnection();
-	startTransaction();
-	// Starting a transaction, we will be getting id's back and need to get data in a separate step, so we need to group it in a transaction.
-	try {
-		Commands.ValueObject newInstanceData = null;
-		try {
-			newInstanceData = getNewInstanceData(aTypeProxy, initializationString, connect);
-		} catch (CommandErrorException e) {
-			switch (e.getErrorCode()) {
-				case Commands.CLASS_CAST_EXCEPTION:
-					// The result was not of the correct type.
-					throw new ClassCastException(
-						MessageFormat.format(ProxyRemoteMessages.Classcast_EXC_, new Object[] {extractFirstLine(initializationString), aTypeProxy.getTypeName()})); 
-				case Commands.CANNOT_EVALUATE_STRING:
-					// Want to log the exception that caused it to not evaluate.
-					// Don't need to log this side, just log the RemoteVM side of the trace.
-					java.io.StringWriter s = new java.io.StringWriter();
-					java.io.PrintWriter w = new java.io.PrintWriter(s);
-					((ThrowableProxy) e.getErrorObject()).printProxyStackTrace(w);
-					ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, s.toString(), null));
-					throw new InstantiationException(
-						MessageFormat.format(ProxyRemoteMessages.Instantiate_EXC_, new Object[] {extractFirstLine(initializationString)})); 
-				default:
-					throw e; //$NON-NLS-1$
-			}
-		} catch (CommandException e) {
-			if (e.isRecoverable()) {
-				ProxyPlugin.getPlugin().getLogger().log( 
-					new Status(
-						IStatus.WARNING,
-						ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
-						0,
-						"", //$NON-NLS-1$
-						e));
-			} else {
-				// It failed in the command, try again.
-				fRegistry.closeConnection(connect);
-				connect = null;
-				connect = fRegistry.getFreeConnection();
-				try {
-					newInstanceData = getNewInstanceData(aTypeProxy, initializationString, connect);
-				} catch (CommandException eAgain) {
-					// It failed again. Close this connection and don't let it be returned.
-					fRegistry.closeConnection(connect);
-					connect = null; // This is so that it won't be returned.
-				}
-			}
-		} finally {
-			if (connect != null)
-				fRegistry.returnConnection(connect);
-		}
-
-		if (newInstanceData != null)
-			return getBeanProxy(newInstanceData); // Turn it into a proxy
-	} finally {
-		stopTransaction();	// Now we can release the transaction.
-	}
-
-return null;
-}
-
-private String extractFirstLine(String initString) {
-	// Need to extract the first line for the messageFormat not to barf.
-	int cr = initString.indexOf('\r');
-	int lf = initString.indexOf('\n');	
-	if (cr != -1 || lf != -1) {
-		if (cr == -1 || (lf != -1 && lf < cr))
-			return initString.substring(0, lf);
-		else
-			return initString.substring(0, cr);
-	} else
-		return initString;
-}
-	
-	
-/**
- * actually create it using a passed in connection. This allows retry capability.
- *
- * This will send the request over to the connection.
- *
- * If we get an OBJECT back, then the beantypeproxy that the classID in the
- * value points to must be of type IREMConstantBeanTypeProxy so that we can
- * send this new object to the correct beantype to create the correct proxy.
- *
- * If we get an OBJECT_ID back, then the beantypeproxy that the classID in
- * the value points to must be able to handle creating a proxy of that type. 
- */
-private Commands.ValueObject getNewInstanceData(IREMBeanTypeProxy aTypeProxy, String initializationString, IREMConnection connect) throws ThrowableProxy, CommandException {	
-	try {
-		Commands.ValueObject newInstanceData = new Commands.ValueObject();
-		connect.getNewInstance(aTypeProxy.getID().intValue(), initializationString, newInstanceData);
-		return newInstanceData;
-	} catch (CommandErrorException e) {
-		// TBD - Needs to handle error of not evaluatable and send over to the compilor.
-		processErrorReturn(e);	// Process this
-	}
-	return null;
-}
-
-/**
- * actually create it using a passed in connection. This allows retry capability.
- */
-private void getObjectInstanceData(IREMConnection connect, int objectID, Commands.ValueObject valueReturn) throws ThrowableProxy, CommandException {	
-	try {
-		connect.getObjectData(objectID, valueReturn);
-	} catch (CommandErrorException e) {
-		processErrorReturn(e);	// Process this
-	}
-}
-
-/**
- * Get a bean proxy from the value object passed in. If not yet created, create one.
- * NOTE: NULL type actually returns a true null. This is so that if people are casting
- * the returned proxy to a specific type (e.g IIntegerBeanProxy), then they won't get
- * a ClassCastException, they will get a null. This is easier for them to handle.
- * 
- * NOTE: This is public ONLY so that extension factories can create correct types of
- * proxies in consistent manner from a value object. 
- * 
- * It is important that this is called
- * from within a transaction only because otherwise the value could have invalid data
- * by the time we try to get the data out of it.
- */
-public IBeanProxy getBeanProxy(Commands.ValueObject value) throws ThrowableProxy, CommandException {
-	switch (value.type) {
-		// Null result.
-		case (byte) Commands.VOID_TYPE:
-			return null;
-		// A constant object was received.
-		case Commands.OBJECT:
-			IREMConstantBeanTypeProxy constantBeanType = null;
-			try {
-				constantBeanType = (IREMConstantBeanTypeProxy) getBeanType(value.classID);
-				if (constantBeanType == null)
-					return null;	// Cannot find the type to create it.
-			} catch (ClassCastException e) {
-				// It wasn't a constant type, so we can't create it. Return null.
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-				return null;
-			}
-			
-			return constantBeanType.newBeanProxy(value);
-		
-		// An existing object_id was returned, the object should exist. If it doesn't
-		// then submit the info command to try to recreate it correctly.
-		case Commands.OBJECT_ID:
-			Integer objectID = new Integer(value.objectID);
-			IBeanProxy proxy = retrieveProxy(objectID, true);
-			if (proxy != null)
-				return proxy;
-
-			// Not found, need to try to recreate it.
-			IREMConnection connect = fRegistry.getFreeConnection();
-			try {
-				getObjectInstanceData(connect, value.objectID, value); // Go and get the data
-			} catch (CommandErrorException e) {
-				if (e.isRecoverable()) {
-					ProxyPlugin.getPlugin().getLogger().log(
-						new Status(
-							IStatus.WARNING,
-							ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
-							0,
-							"", //$NON-NLS-1$
-							e));
-					return null;
-				} else {
-					// Try one more time.
-					fRegistry.closeConnection(connect);
-					connect = null;
-					connect = fRegistry.getFreeConnection();
-					try {
-						getObjectInstanceData(connect, value.objectID, value); // Go and get the data
-					} catch (CommandErrorException eAgain) {
-						fRegistry.closeConnection(connect);
-						connect = null;
-						throw eAgain;
-					}
-				}
-			} finally {
-				if (connect != null)
-					fRegistry.returnConnection(connect);
-			}
-
-			return getBeanProxy(value); // Now process it to create the new data.
-			
-		// An new object id. Need to get the class type and let it create it.
-		case Commands.NEW_OBJECT_ID:
-			try {
-				IREMBeanTypeProxy newBeanType = getBeanType(value.classID);
-				IREMBeanProxy newProxy = newBeanType.newBeanProxy(new Integer(value.objectID));
-				if (newProxy != null)
-					registerProxy(newProxy);
-				return newProxy;
-			} catch (CommandException e) {
-				// The server has created a new object, but we couldn't create/register a proxy for it.
-				// We need to release it so that the server can get rid of it. Otherwise it would hang
-				// around over there forever.
-				releaseID(value.objectID);
-				throw e;				
-			} catch (RuntimeException e) {
-				// The server has created a new object, but we couldn't create/register a proxy for it.
-				// We need to release it so that the server can get rid of it. Otherwise it would hang
-				// around over there forever.
-				releaseID(value.objectID);
-				throw e;
-			}			
-			
-		// An exception was thrown, create the ThrowableProxy and then throw it.
-		case Commands.THROW:
-			IREMBeanProxy newThrowProxy	= null;
-			try {
-				IREMBeanTypeProxy newThrowType = newThrowType = getBeanType(value.classID);
-				newThrowProxy = newThrowType.newBeanProxy(new Integer(value.objectID));
-				if (newThrowProxy != null)
-					registerProxy(newThrowProxy);
-			} catch (CommandException e) {
-				// The server has created a new object, but we couldn't create/register a proxy for it.
-				// We need to release it so that the server can get rid of it. Otherwise it would hang
-				// around over there forever.
-				releaseID(value.objectID);
-				throw e;				
-			} catch (RuntimeException e) {
-				// The server has created a new object, but we couldn't create/register a proxy for it.
-				// We need to release it so that the server can get rid of it. Otherwise it would hang
-				// around over there forever.
-				releaseID(value.objectID);
-				throw e;
-			}				
-			// It really should be a throwable, but if not, just return it.
-			if (newThrowProxy instanceof ThrowableProxy)
-				throw (ThrowableProxy) newThrowProxy;
-			else
-				return newThrowProxy;		
-		
-		// It is one of the standard kinds, which are Constant types
-		default:
-			IREMConstantBeanTypeProxy standardBeanType = null;
-			try {
-				standardBeanType = (IREMConstantBeanTypeProxy) getBeanType(value.type);
-				if (standardBeanType == null)
-					return null;	// Cannot find the type to create it.
-			} catch (ClassCastException e) {
-				// It wasn't a standard type, so we can't create it. Return null.
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-				return null;
-			}
-			return standardBeanType.newBeanProxy(value);
-	}						
-}
-
-/**
- * Process the error exception. Get the data from it and turn it into proxy data.
- * If it is a THROW, then it will throw the Throwable instead. 
- *
- * NOTE: It is public ONLY so that extension factories can process errors in
- * an consistent manner. 
- * 
- * It is important that this be called only within a transaction.
- */
-public void processErrorReturn(CommandErrorException e) throws CommandException, ThrowableProxy {
-	int code = e.getErrorCode();
-	Object data = null;
-	if (code == Commands.THROWABLE_SENT)
-		data = getBeanProxy(e.getValue());	// It is Throw sent, so let the throw from getBeanProxy continue on out. (But as a safety, we still try to get the data.
-	else {
-		try {
-			data = getBeanProxy(e.getValue());
-		} catch (ThrowableProxy t) {
-			// But we want to keep throwables in this case. They are just data for the command error.
-			data = t;
-		}
-	}
-	throw new CommandErrorException(MessageFormat.format(ProxyRemoteMessages.RemoteCmd_EXC_, new Object[] {new Integer(code)}), code, e.getValue(), data);	// Create a new one and throw it containing the proxied data. //$NON-NLS-1$
-}
-	 
-
-/**
- * Get a beantype where the id passed in is the classID of the beantype.
- * If not found, then go get it loaded. If it can't be found, then we will
- * release the id because it means we have an id from the server, but we
- * can't create a proxy for it, so don't keep the server holding it.
- * NOTE: This is public ONLY so that extension factories can create correct types
- * in a consistent manner from the id.
- * 
- * It is important that this be called only from within a transaction. 
- */
-public IREMBeanTypeProxy getBeanType(int id) throws CommandException {
-	IREMBeanTypeProxy beanType = null;
-	try {
-		Integer classID = new Integer(id);
-		beanType = (IREMBeanTypeProxy) retrieveProxy(classID, false);
-		if (beanType == null)
-			beanType = fBeanTypeProxyFactory.createBeanTypeProxy(classID);	// We don't have it, need to go to the factory so that it can go query what it needs
-		if (beanType == null)
-			return null;	// Cannot find the type to create it.
-	} catch (ClassCastException e) {
-		// It wasn't a bean type, so we can't create it. Return null.
-		ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-	} finally {
-		if (beanType == null)
-			releaseID(id);	// Couldn't create a proxy, so release the id.
-	}
-	return beanType;
-}
-
-
-/**
- * Return a proxy wrapping the primitive integer
- */
-public IIntegerBeanProxy createBeanProxyWith(int aPrimitiveInteger) {
-
-	return fBeanTypeProxyFactory.intType.createIntegerBeanProxy(aPrimitiveInteger);
-}
-
-/**
- * Return a proxy wrapping the primitive byte
- */
-public INumberBeanProxy createBeanProxyWith(byte aPrimitiveByte) {
-
-	return fBeanTypeProxyFactory.byteType.createByteBeanProxy(aPrimitiveByte);
-}
-
-/**
- * Return a proxy wrapping the primitive char
- */
-public ICharacterBeanProxy createBeanProxyWith(char aPrimitiveChar) {
-
-	return fBeanTypeProxyFactory.charType.createCharacterBeanProxy(aPrimitiveChar);
-}
-
-/**
- * Return a proxy wrapping the primitive short
- */
-public INumberBeanProxy createBeanProxyWith(short aPrimitiveShort) {
-
-	return fBeanTypeProxyFactory.shortType.createShortBeanProxy(aPrimitiveShort);
-}
-
-/**
- * Return a proxy wrapping the primitive long
- */
-public INumberBeanProxy createBeanProxyWith(long aPrimitiveLong) {
-
-	return fBeanTypeProxyFactory.longType.createLongBeanProxy(aPrimitiveLong);
-}
-/**
- * Return a proxy wrapping the primitive double
- */
-public INumberBeanProxy createBeanProxyWith(double aPrimitiveDouble) {
-
-	return fBeanTypeProxyFactory.doubleType.createDoubleBeanProxy(aPrimitiveDouble);
-}
-/**
- * Return a proxy wrapping the primitive float
- */
-public INumberBeanProxy createBeanProxyWith(float aPrimitiveFloat) {
-
-	return fBeanTypeProxyFactory.floatType.createFloatBeanProxy(aPrimitiveFloat);
-}
-
-/**
- * createBeanProxyWith method comment.
- */
-public IBooleanBeanProxy createBeanProxyWith(Boolean aBoolean) {
-	return fBeanTypeProxyFactory.booleanClass.createBooleanBeanProxy(aBoolean);
-}
-/**
- * Return a proxy that wraps the Integer argument
- */
-public IIntegerBeanProxy createBeanProxyWith(Integer anInteger) {
-
-	return fBeanTypeProxyFactory.integerClass.createIntegerBeanProxy(anInteger);
-}
-/**
- * createBeanProxyWith method comment.
- */
-public INumberBeanProxy createBeanProxyWith(Number aNumber) {
-	REMAbstractNumberBeanTypeProxy type = (REMAbstractNumberBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(aNumber.getClass().getName());
-	return type.createNumberBeanProxy(aNumber);
-}
-/**
- * Return a proxy for the argument
- */
-public IStringBeanProxy createBeanProxyWith(String aString) {
-
-	return fBeanTypeProxyFactory.stringClass.createStringBeanProxy(aString);
-
-}
-/**
- * Return a proxy for the argument
- */
-public ICharacterBeanProxy createBeanProxyWith(Character aCharacter) {
-
-	return fBeanTypeProxyFactory.characterClass.createCharacterBeanProxy(aCharacter);
-
-}
-/**
- * createBeanProxyWith method comment.
- */
-public IBooleanBeanProxy createBeanProxyWith(boolean aPrimitiveBoolean) {
-	return fBeanTypeProxyFactory.booleanType.createBooleanBeanProxy(aPrimitiveBoolean);
-}
-
-/**
- * Create an array bean proxy.
- *
- *   - (int, new int[2] {3, 4}) will create:
- *      int [3] [4]
- *
- *   - (int[], new int[1] {1})
- *      int [1]
- *
- *   - (int[], new int[2] {2,3})
- *      int [2] [3]
- * 
- *
- *   - (int[], null) or (int[], new int[0]) or (int, null) or (int, new int[0])
- *      int [0]...
- *     or
- *     (int[][]..., null) or (int[][]..., new int[0])
- *      int[0][]...
- *     This is because an array instance with no specified dimensions is not valid. 
- *
- *   - (int[][], new int[1] {3})
- *      int[3][]
- */
-public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int[] dimensions) throws ThrowableProxy {
-	if (type.isArray())
-		return ((REMArrayBeanTypeProxy) type).createBeanProxyWith(dimensions);	// Already an array type, just pass it on.
-	else {
-		// It is not an array type, so we need to get an array of this type and dimensions.
-		REMArrayBeanTypeProxy arrayType = (REMArrayBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(type.getTypeName(), dimensions.length);
-		return arrayType.createBeanProxyWith(dimensions);
-	}
-}
-/**
- * Create a one-dimensional array. 
- * The result will be the same as calling 
- *   createBeanProxyWith(IBeanTypeProxy type, new int[1] {x})
- * where 'x' is the value passed in as the dimension.
- */
-public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int dimension) throws ThrowableProxy {
-	return createBeanProxyWith(type, new int[] {dimension});
-}
-
-/**
- * Retrieve the proxy from the mapping table. Handle already GC'd.
- * If this returns null, it is important that the caller tries to recreate
- * it since the id is still valid on the server.
- */
-private IBeanProxy retrieveProxy(Integer objectID, boolean incrementUseCnt) {
-	synchronized (fIDToProxiesMap) {
-		ProxyRef ref = (ProxyRef) fIDToProxiesMap.get(objectID);
-		if (ref != null) {
-			Object bp = ref.get();			
-			if (ref.isEnqueued() || bp == null) {
-				// It's waiting to be removed, or has been removed. i.e. GC'd, so just remove it from the map, next processQueue will remove it from the queue.
-				fIDToProxiesMap.remove(objectID);
-				ref.clear();		// This is so that when the processQueue see's it, 
-							// it won't send a release request to the server 
-							// since it will be recreated when this method returns.
-				return null;
-			} else {
-				if (incrementUseCnt)
-					ref.incrUseCnt();
-				return (IBeanProxy) bp;
-			}	
-		} else
-			return null;
-	}
-}
-
-/**
- * Start Transaction: During the time between start/stop transaction,
- * proxies will not be cleaned up. This prevents the case of a two step
- * transaction where the returned ID from the remote vm is for a proxy
- * that is about to be cleaned up, and then having that proxy disappear
- * when going for the data for it.
- * 
- * Note: It is IMPERITIVE that the start/stop is used in the following way:
- *     factory.startTransaction();
- *     try {
- *         do your stuff...
- *     } finally {
- *         factory.stopTransaction();
- *     }
- * 
- * This way it can never accidently leave it in a locked state.
- */
-public	void startTransaction()  {
-	synchronized (fIDToProxiesMap) {
-		transactionLockCount++;
-	}
-}
-
-public boolean inTransaction() {
-	synchronized (fIDToProxiesMap) {
-		return transactionLockCount != 0;
-	}
-}
-
-/**
- * Stop Transaction: During the time between start/stop transaction,
- * proxies will not be cleaned up. This prevents the case of a two step
- * transaction where the returned ID from the remote vm is for a proxy
- * that is about to be cleaned up, and then having that proxy disappear
- * when going for the data for it.
- * 
- * Note: It is IMPERITIVE that the start/stop is used in the following way:
- *     factory.startTransaction();
- *     try {
- *         do your stuff...
- *     } finally {
- *         factory.stopTransaction();
- *     }
- * 
- * This way it can never accidently leave it in a locked state.
- */
-public	void stopTransaction()  {
-	synchronized (fIDToProxiesMap) {
-		if (--transactionLockCount < 0)
-			transactionLockCount = 0;	// Shouldn't occur, but just in case.
-	}
-}
-
-/**
- * Terminate the factory. If this is being terminated, then the server is being terminated too.
- * So just go through all of the proxies and release them, but don't send any notification to
- * the server since the server is subsequently just going to throw them away when it terminates.
- * <p>
- * This can't run async, so wait is a suggestion here.
- */
-public void terminateFactory(boolean wait) {
-	synchronized (fIDToProxiesMap) {
-		Iterator itr = fIDToProxiesMap.values().iterator();
-		while (itr.hasNext()) {
-			ProxyRef ref = (ProxyRef) itr.next();
-			if (ref != null) {
-				Object bp = ref.get();
-				// If not cleaned up and not enqueued, release it.
-				if (bp != null && !ref.isEnqueued())
-					((IREMBeanProxy) bp).release();
-			}
-		}
-		
-		fIDToProxiesMap.clear();
-		queue = null;	// Don't bother processing the queue, don't need to now.
-	}
-}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createExpression()
-	 */
-	public IExpression createExpression() {
-		return new REMExpression(this.fRegistry);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createBeanProxyFrom(java.lang.String)
-	 */
-	public IBeanProxy createBeanProxyFrom(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-		try {
-			return createBeanProxy(fBeanTypeProxyFactory.voidType, initializationString);
-		} catch (CommandException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$		}
-		}
-		return null;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#convertToPrimitiveBeanProxy(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public IBeanProxy convertToPrimitiveBeanProxy(IBeanProxy nonPrimitiveProxy) {
-		if (nonPrimitiveProxy == null)
-			return null;
-		if (!nonPrimitiveProxy.isValid())
-			return nonPrimitiveProxy;
-		IREMBeanTypeProxy type = (IREMBeanTypeProxy) nonPrimitiveProxy.getTypeProxy();
-		// Step into the internals. The ID is a constant int, so we can use a switch stmt.
-		switch (type.getID().intValue()) {
-			case Commands.BOOLEAN_CLASS:
-				return this.createBeanProxyWith(((IBooleanBeanProxy) nonPrimitiveProxy).booleanValue());
-			case Commands.BYTE_CLASS:
-				return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).byteValue());
-			case Commands.CHARACTER_CLASS:
-				return this.createBeanProxyWith(((ICharacterBeanProxy) nonPrimitiveProxy).charValue());
-			case Commands.DOUBLE_CLASS:
-				return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).doubleValue());
-			case Commands.FLOAT_CLASS:
-				return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).floatValue());
-			case Commands.INTEGER_CLASS:
-				return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).intValue());
-			case Commands.LONG_CLASS:
-				return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).longValue());
-			case Commands.SHORT_CLASS:
-				return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).shortValue());
-			default:
-				return nonPrimitiveProxy;
-		}
-	}
-
-
-	public IBeanProxy getIVMServerProxy() {
-		return vmServerProxy;
-	}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanTypeProxyFactory.java
deleted file mode 100644
index d62586d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStandardBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,690 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-
-/*
- *  $RCSfile: REMStandardBeanTypeProxyFactory.java,v $
- *  $Revision: 1.16 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.text.MessageFormat;
-import java.util.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.MapTypes;
-import org.eclipse.jem.internal.proxy.common.remote.CommandErrorException;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * We are a beanTypeProxyFactory for creating REMBeanTypeProxy objects Primitive types as well as common types like String are cached for speed of
- * lookup. We are the standard one that the VCE uses. Creation date: (12/3/99 2:32:48 PM)
- * 
- * @author: Joe Winchester
- */
-public final class REMStandardBeanTypeProxyFactory implements IStandardBeanTypeProxyFactory {
-
-	protected final REMProxyFactoryRegistry fFactoryRegistry;
-
-	protected REMStandardBeanProxyFactory fBeanFactory;
-
-	// Hashtable to cache proxies for classes so they are found on second and subsequent lookups
-	protected Map fBeanProxies = new HashMap(1000);
-
-	// A Cache of bean type proxies that should not ever be released. These are the standard ones
-	// that we create here. They are never released because they wouldn't be correctly re-created
-	// if they were. Also they are standard ones with standard ID's that don't change so they
-	// don't need to be re-created later.
-	protected Set fPermanentProxies = new HashSet(30);
-
-	// Cache of requested but not found bean types. If not maintaining the list, this variable will be null.
-	// The values are strings (classnames in JNI format).
-	protected Set fNotFoundTypes = null;
-
-	// Cached copy of a few typical bean type proxies.
-	REMBeanTypeProxy objectClass;
-
-	REMClassBeanTypeProxy classClass;
-
-	REMVoidBeanTypeProxy voidType;
-
-	REMBooleanTypeBeanTypeProxy booleanType;
-
-	REMBooleanClassBeanTypeProxy booleanClass;
-
-	REMIntegerTypeBeanTypeProxy intType;
-
-	REMIntegerClassBeanTypeProxy integerClass;
-
-	REMByteTypeBeanTypeProxy byteType;
-
-	REMByteClassBeanTypeProxy byteClass;
-
-	REMShortClassBeanTypeProxy shortClass;
-
-	REMShortTypeBeanTypeProxy shortType;
-
-	REMLongClassBeanTypeProxy longClass;
-
-	REMLongTypeBeanTypeProxy longType;
-
-	REMDoubleClassBeanTypeProxy doubleClass;
-
-	REMDoubleTypeBeanTypeProxy doubleType;
-
-	REMFloatClassBeanTypeProxy floatClass;
-
-	REMFloatTypeBeanTypeProxy floatType;
-
-	REMBigDecimalBeanTypeProxy bigDecimalClass;
-
-	REMBigIntegerBeanTypeProxy bigIntegerClass;
-
-	REMCharacterTypeBeanTypeProxy charType;
-
-	REMCharacterClassBeanTypeProxy characterClass;
-
-	REMStringBeanTypeProxy stringClass;
-
-	/**
-	 * Available to all REM beantypes.
-	 */
-	public REMProxyConstants proxyConstants;
-
-	/**
-	 * IDEBeanTypeProxyFactory constructor comment.
-	 */
-	REMStandardBeanTypeProxyFactory(REMProxyFactoryRegistry aRegistry) {
-		fFactoryRegistry = aRegistry;
-		aRegistry.registerBeanTypeProxyFactory(this);
-
-		proxyConstants = new REMProxyConstants(aRegistry);
-
-		// Now initialize the cache.
-		objectClass = new REMBeanTypeProxy(fFactoryRegistry, new Integer(Commands.OBJECT_CLASS), Object.class.getName(), null);
-		classClass = new REMClassBeanTypeProxy(fFactoryRegistry, objectClass);
-		voidType = new REMVoidBeanTypeProxy(fFactoryRegistry);
-		booleanType = new REMBooleanTypeBeanTypeProxy(fFactoryRegistry);
-		booleanClass = new REMBooleanClassBeanTypeProxy(fFactoryRegistry, objectClass);
-		IBeanTypeProxy numberClass = objectClass.newBeanTypeForClass(new Integer(Commands.NUMBER_CLASS), Number.class.getName(), true);
-		intType = new REMIntegerTypeBeanTypeProxy(fFactoryRegistry);
-		integerClass = new REMIntegerClassBeanTypeProxy(fFactoryRegistry, numberClass);
-		byteType = new REMByteTypeBeanTypeProxy(fFactoryRegistry);
-		byteClass = new REMByteClassBeanTypeProxy(fFactoryRegistry, numberClass);
-		shortType = new REMShortTypeBeanTypeProxy(fFactoryRegistry);
-		shortClass = new REMShortClassBeanTypeProxy(fFactoryRegistry, numberClass);
-		longType = new REMLongTypeBeanTypeProxy(fFactoryRegistry);
-		longClass = new REMLongClassBeanTypeProxy(fFactoryRegistry, numberClass);
-		doubleType = new REMDoubleTypeBeanTypeProxy(fFactoryRegistry);
-		doubleClass = new REMDoubleClassBeanTypeProxy(fFactoryRegistry, numberClass);
-		floatType = new REMFloatTypeBeanTypeProxy(fFactoryRegistry);
-		floatClass = new REMFloatClassBeanTypeProxy(fFactoryRegistry, numberClass);
-		bigDecimalClass = new REMBigDecimalBeanTypeProxy(fFactoryRegistry, numberClass);
-		bigIntegerClass = new REMBigIntegerBeanTypeProxy(fFactoryRegistry, numberClass);
-		charType = new REMCharacterTypeBeanTypeProxy(fFactoryRegistry);
-		characterClass = new REMCharacterClassBeanTypeProxy(fFactoryRegistry, objectClass);
-		stringClass = new REMStringBeanTypeProxy(fFactoryRegistry, objectClass);
-		IBeanTypeProxy throwableClass = new REMThrowableBeanTypeProxy(fFactoryRegistry, new Integer(Commands.THROWABLE_CLASS), Throwable.class
-				.getName(), objectClass);
-		IBeanTypeProxy threadClass = objectClass.newBeanTypeForClass(new Integer(Commands.THREAD_CLASS), Thread.class.getName(), false);
-		IBeanTypeProxy expressionProcessorControllerClass = objectClass.newBeanTypeForClass(new Integer(Commands.EXPRESSIONPROCESSERCONTROLLER_CLASS), "org.eclipse.jem.internal.proxy.vm.remote.ExpressionProcesserController", false); //$NON-NLS-1$
-
-		// Initialize the hashtable with the primitives, their lang equivalents, and also common classes like String
-
-		// Primitives
-		fBeanProxies.put(voidType.getTypeName(), voidType);
-		fBeanProxies.put(intType.getTypeName(), intType);
-		fBeanProxies.put(booleanType.getTypeName(), booleanType);
-		fBeanProxies.put(charType.getTypeName(), charType);
-		fBeanProxies.put(byteType.getTypeName(), byteType);
-		fBeanProxies.put(shortType.getTypeName(), shortType);
-		fBeanProxies.put(longType.getTypeName(), longType);
-		fBeanProxies.put(floatType.getTypeName(), floatType);
-		fBeanProxies.put(doubleType.getTypeName(), doubleType);
-
-		// java.lang primitive peers
-		// Note that special classes are used for some of these which allow the IDE to get the
-		// lang objects from the objects that are holding proxies
-		fBeanProxies.put(integerClass.getTypeName(), integerClass);
-		fBeanProxies.put(booleanClass.getTypeName(), booleanClass);
-		fBeanProxies.put(characterClass.getTypeName(), characterClass);
-		fBeanProxies.put(byteClass.getTypeName(), byteClass);
-		fBeanProxies.put(shortClass.getTypeName(), shortClass);
-		fBeanProxies.put(longClass.getTypeName(), longClass);
-		fBeanProxies.put(floatClass.getTypeName(), floatClass);
-		fBeanProxies.put(doubleClass.getTypeName(), doubleClass);
-		fBeanProxies.put(bigDecimalClass.getTypeName(), bigDecimalClass);
-		fBeanProxies.put(bigIntegerClass.getTypeName(), bigIntegerClass);
-		fBeanProxies.put(stringClass.getTypeName(), stringClass);
-		fBeanProxies.put(throwableClass.getTypeName(), throwableClass);
-		fBeanProxies.put(objectClass.getTypeName(), objectClass);
-		fBeanProxies.put(classClass.getTypeName(), classClass);
-		fBeanProxies.put(numberClass.getTypeName(), numberClass);
-		fBeanProxies.put(threadClass.getTypeName(), threadClass);
-		fBeanProxies.put(expressionProcessorControllerClass.getTypeName(), expressionProcessorControllerClass);
-
-		// Mark these as permanent.
-		fPermanentProxies.addAll(fBeanProxies.values());
-	}
-
-	/**
-	 * Initialize AFTER BeanProxyFactory has been created. This is REQUIRED! NOTE: It is package protected so that only REMStandardBeanProxyFactory
-	 * can call it when ready.
-	 */
-	synchronized void initialize(REMStandardBeanProxyFactory proxyFactory) {
-		fBeanFactory = proxyFactory;
-		fBeanFactory.registerProxies(fBeanProxies.values());
-	}
-
-	/*
-	 * This is called when we know we don't have the class registered, so we need to create the proxy. We have a connection passed in and will reuse
-	 * it as necessary
-	 * 
-	 * It is important that this be called only from within a transaction.
-	 */
-	private synchronized IREMBeanTypeProxy createBeanTypeProxy(String typeName, IREMConnection connection) throws CommandException {
-
-		// We don't have the beantype proxy, so create it.
-		IREMBeanTypeProxy beanTypeProxy = null;
-		Commands.GetClassReturn ret = null;
-		try {
-			ret = getClassReturn(connection, typeName);
-		} catch (ThrowableProxy ep) {
-			// Print out the trace and return proxy with init error.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", ep)); //$NON-NLS-1$
-			IREMBeanTypeProxy proxy = new REMInitErrorBeanTypeProxy(fFactoryRegistry, MessageFormat.format(ProxyRemoteMessages.ExceptionErrorMsg_EXC_, new Object[] { ep.getTypeProxy().getTypeName(), ep.getProxyLocalizedMessage()}), typeName); //$NON-NLS-1$
-			registerBeanTypeProxy(proxy, false);
-			return proxy;
-		}
-		if (ret == null) {
-			if (fNotFoundTypes != null)
-				fNotFoundTypes.add(typeName);
-			return null; // The class doesn't even exist on the server.
-		}
-
-		if (typeName.charAt(0) != '[') {
-			// It is not an array.
-			IREMBeanTypeProxy superTypeProxy = null;
-			if (!ret.isInterface && ret.superClassname.length() != 0) {
-				// Get the beantype proxy of the superclass.
-				superTypeProxy = getBeanTypeProxy(ret.superClassname, connection);
-			}
-
-			// First check with the factory for the package of the class.
-			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
-			// the package ended and the class started. This check is here in case the
-			// extension factory can handle this class but needs the id from the server to
-			// create it.
-			int packageIndex = typeName.lastIndexOf('.');
-			if (packageIndex != -1) {
-				String packageName = typeName.substring(0, packageIndex);
-				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
-				if (packageFactory != null) {
-					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName, new Integer(ret.classID), superTypeProxy);
-					if (beanTypeProxy != null) {
-						registerBeanTypeProxy(beanTypeProxy, false);
-						return beanTypeProxy;
-					}
-				}
-			}
-
-			if (ret.isInterface) {
-				// Interface never have a super type, so we will create a specific type.
-				beanTypeProxy = new REMInterfaceBeanTypeProxy(fFactoryRegistry, new Integer(ret.classID), typeName);
-			} else {
-				// Ask the supertype
-				// to create a beantype proxy of the same beantype proxy class.
-				// This is so that any subclasses will get the same beantype proxy class
-				// for it if it is special.
-				if (superTypeProxy != null)
-					beanTypeProxy = superTypeProxy.newBeanTypeForClass(new Integer(ret.classID), typeName, ret.isAbstract);
-			}
-		} else
-			beanTypeProxy = new REMArrayBeanTypeProxy(fFactoryRegistry, new Integer(ret.classID), typeName, objectClass);
-
-		// Cache the instance so we can re-use it again
-		if (beanTypeProxy != null)
-			registerBeanTypeProxy(beanTypeProxy, false);
-		return beanTypeProxy;
-	}
-
-	/**
-	 * Using the helper class to find a class by name, then create the proxy.
-	 */
-	public IBeanTypeProxy getBeanTypeProxy(String typeName) {
-		try {
-			return getBeanTypeProxy(MapTypes.getJNIFormatName(typeName), (IREMConnection) null);
-		} catch (CommandException e) {
-			// Try once more (we won't have received recoverable exceptions here, they were already caught and handled)
-			try {
-				return getBeanTypeProxy(typeName, (IREMConnection) null);
-			} catch (CommandException eAgain) {
-				// Failed again.
-				ProxyPlugin.getPlugin().getLogger().log(
-						new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
-			}
-		}
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IExpression,
-	 *      java.lang.String)
-	 */
-	public synchronized IProxyBeanType getBeanTypeProxy(IExpression expression, String typeName) {
-		typeName = MapTypes.getJNIFormatName(typeName);
-		// See whether we already have the proxy for the argument name
-		IProxyBeanType beanTypeProxy = (IProxyBeanType) fBeanProxies.get(typeName);
-		if (beanTypeProxy != null)
-			return beanTypeProxy;
-		
-		// Now see if an expression proxy cached.
-		beanTypeProxy = ((REMExpression) expression).getBeanType(typeName);
-		if (beanTypeProxy != null)
-			return beanTypeProxy;		
-
-		// If not an array, then see if the package extension mechanism can find it.
-		// Do this here so that if it is found in the package extension we won't necessarily create an
-		// extra connection when not needed.
-		if (typeName.charAt(0) != '[') {
-			// It is not an array
-			// First check with the factory for the package of the class.
-			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
-			// the package ended and the class started.
-			int packageIndex = typeName.lastIndexOf('.');
-			if (packageIndex != -1) {
-				String packageName = typeName.substring(0, packageIndex);
-				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
-				if (packageFactory != null) {
-					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName, expression);
-					if (beanTypeProxy != null) {
-						registerBeanTypeProxy(beanTypeProxy, false);
-						return beanTypeProxy;
-					}
-				}
-			}
-		}
-
-		// Need to create the expression proxy for it.
-		beanTypeProxy = ((Expression) expression).createBeanTypeExpressionProxy(typeName);
-		registerBeanTypeProxy(beanTypeProxy, false);
-		return beanTypeProxy;
-
-	}
-
-	/**
-	 * One that internally allows that we already have a connection to work with. If the connection is null, then one will be created.
-	 * 
-	 * It is important that if the connection is not null, then we are in a transaction.
-	 */
-	private synchronized IREMBeanTypeProxy getBeanTypeProxy(String typeName, IREMConnection inConnect) throws CommandException {
-
-		// See whether we already have the proxy for the argument name
-		IProxyBeanType beanTypeProxy = (IProxyBeanType) fBeanProxies.get(typeName);
-		// See if there and resolved, if so, return it. If not resolved, that means we need it NOW
-		// so we must go for it. When finally resolved the original ExpressionProxy will be deregistered and
-		// the resolved beantypeproxy will be in its place.
-		if (beanTypeProxy != null && beanTypeProxy.isBeanProxy()) { return (IREMBeanTypeProxy) beanTypeProxy; }
-
-		// If not an array, then see if the package extension mechanism can find it.
-		// Do this here so that if it is found in the package extension we won't necessarily create an
-		// extra connection when not needed.
-		if (typeName.charAt(0) != '[') {
-			// It is not an array
-			// First check with the factory for the package of the class.
-			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
-			// the package ended and the class started.
-			int packageIndex = typeName.lastIndexOf('.');
-			if (packageIndex != -1) {
-				String packageName = typeName.substring(0, packageIndex);
-				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
-				if (packageFactory != null) {
-					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName);
-					if (beanTypeProxy != null) {
-						registerBeanTypeProxy((IREMBeanTypeProxy) beanTypeProxy, false);
-						return (IREMBeanTypeProxy) beanTypeProxy;
-					}
-				}
-			}
-		}
-
-		IREMConnection connect = inConnect != null ? inConnect : fFactoryRegistry.getFreeConnection();
-		if (inConnect == null)
-			fBeanFactory.startTransaction(); // Start a transation.
-		try {
-			return createBeanTypeProxy(typeName, connect);
-		} catch (CommandException e) {
-			if (inConnect == null) {
-				// Need to close the connection, not return it.
-				fFactoryRegistry.closeConnection(connect);
-				connect = null; // So that it won't be returned.
-			}
-			throw e; // Pass it on up
-		} finally {
-			if (inConnect == null)
-				fBeanFactory.stopTransaction();
-			if (inConnect == null && connect != null)
-				fFactoryRegistry.returnConnection(connect);
-		}
-	}
-
-	/*
-	 * It is important this be called only from within a transaction.
-	 */
-	private Commands.GetClassReturn getClassReturn(IREMConnection connection, String className) throws CommandException, ThrowableProxy {
-		try {
-			return connection.getClass(className);
-		} catch (CommandErrorException e) {
-			fBeanFactory.processErrorReturn(e); // Let proxy factory handle the error return
-		}
-		return null;
-	}
-
-	/**
-	 * Return an Array type proxy for the given class name of the specified dimensions. This is a helper method. The same result can be gotton from
-	 * getBeanTypeProxy. e.g. getBeanTypeProxy("java.lang.Object", 3) is the same as: getBeanTypeProxy("[[[Ljava.lang.Object;")
-	 * 
-	 * They both result in a type of: Object [][][]
-	 * 
-	 * or getBeanTypeProxy("[Ljava.langObject;", 3) becomes Object [][][][]
-	 */
-	public IBeanTypeProxy getBeanTypeProxy(String componentClassName, int dimensions) {
-		return getBeanTypeProxy(getArrayClassName(componentClassName, dimensions));
-	}
-
-	/**
-	 * @param componentClassName
-	 * @param dimensions
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	private String getArrayClassName(String componentClassName, int dimensions) {
-		String jniComponentClassName = MapTypes.getJNIFormatName(componentClassName);
-		String compType = jniComponentClassName;
-		if (jniComponentClassName.charAt(0) != '[') {
-			// We're not already an array, so create correct template.
-			compType = (String) MapTypes.MAP_TYPENAME_TO_SHORTSIG.get(jniComponentClassName);
-			if (compType == null) {
-				// It is a class, and not a type.
-				compType = "L" + jniComponentClassName + ";"; //$NON-NLS-1$ //$NON-NLS-2$
-			}
-		}
-
-		// Now create it with the appropriate number of '[' in front.
-		StringBuffer buffer = new StringBuffer(dimensions + compType.length());
-		for (int i = 0; i < dimensions; i++)
-			buffer.append('[');
-		buffer.append(compType);
-		return buffer.toString();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IExpression,
-	 *      java.lang.String, int)
-	 */
-	public IProxyBeanType getBeanTypeProxy(IExpression expression, String componentClassName, int dimensions) {
-		return getBeanTypeProxy(expression, getArrayClassName(componentClassName, dimensions));
-	}
-
-	/**
-	 * Get the bean type proxy from a class id. This means that a new class id was sent back from the server that we don't have yet. We need to go ask
-	 * the server for information on this type so that we can create it.
-	 * 
-	 * NOTE: This is package protected so that only the standard bean proxy factory can call it.
-	 * 
-	 * It is important that this has been called within a transaction.
-	 */
-	IREMBeanTypeProxy createBeanTypeProxy(Integer classID) {
-		IREMConnection connect = fFactoryRegistry.getFreeConnection();
-		try {
-			return createBeanTypeProxy(classID, connect);
-		} catch (CommandException e) {
-			if (e.isRecoverable()) {
-				// It is recoverable, print message, keep connection live and return it.
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			} else {
-				// Try again, close connection, get a new one.
-				fFactoryRegistry.closeConnection(connect);
-				connect = null;
-				connect = fFactoryRegistry.getFreeConnection();
-				try {
-					return createBeanTypeProxy(classID, connect);
-				} catch (CommandException eAgain) {
-					// Failed again. Close connection, don't return it.
-					ProxyPlugin.getPlugin().getLogger().log(
-							new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
-					fFactoryRegistry.closeConnection(connect);
-					connect = null;
-				}
-			}
-		} finally {
-			if (connect != null)
-				fFactoryRegistry.returnConnection(connect);
-		}
-		return null;
-	}
-
-	/*
-	 * One that internally allows that we already have a connection to work with. If the connection is null, then one will be created.
-	 * 
-	 * It is important this be called only from within a transaction.
-	 */
-	private synchronized IREMBeanTypeProxy createBeanTypeProxy(Integer classID, IREMConnection connect) throws CommandException {
-		// We don't have the beantype proxy, so create it.
-		IREMBeanTypeProxy beanTypeProxy = null;
-
-		Commands.GetClassIDReturn ret = null;
-		try {
-			ret = getClassIDReturn(connect, classID);
-		} catch (ThrowableProxy ep) {
-			// Just print out the trace and return proxy not found.
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", ep)); //$NON-NLS-1$
-			return null;
-		}
-
-		// If the signature is that of a class.
-		if (ret.className.charAt(0) != '[') {
-			// It is not an array.
-			IREMBeanTypeProxy superTypeProxy = null;
-			if (!ret.isInterface && ret.superClassname.length() != 0) {
-				// Get the beantype proxy of the superclass.
-				superTypeProxy = getBeanTypeProxy(ret.superClassname, connect);
-			}
-
-			// First check with the factory for the package of the class.
-			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
-			// the package ended and the class started.
-			int packageIndex = ret.className.lastIndexOf('.');
-			if (packageIndex != -1) {
-				String packageName = ret.className.substring(0, packageIndex);
-				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
-				if (packageFactory != null) {
-					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(ret.className, classID, superTypeProxy);
-					if (beanTypeProxy != null) {
-						registerBeanTypeProxy(beanTypeProxy, false);
-						return beanTypeProxy;
-					}
-				}
-			}
-
-			if (ret.isInterface) {
-				// Interface never have a super type, so we will let the object class do it for us.
-				beanTypeProxy = new REMInterfaceBeanTypeProxy(fFactoryRegistry, classID, ret.className);
-			} else {
-				// Ask the beantype proxy of the superclass
-				// to create a beantype proxy of the same beantype proxy class.
-				// This is so that any subclasses will get the same beantype proxy class
-				// for it if it is special.
-				if (superTypeProxy != null)
-					beanTypeProxy = superTypeProxy.newBeanTypeForClass(classID, ret.className, ret.isAbstract);
-			}
-
-			// Cache the instance so we can re-use it again
-			if (beanTypeProxy != null)
-				registerBeanTypeProxy(beanTypeProxy, false);
-			return beanTypeProxy;
-		} else {
-			// It is an array.
-			beanTypeProxy = new REMArrayBeanTypeProxy(fFactoryRegistry, classID, ret.className, objectClass);
-			registerBeanTypeProxy(beanTypeProxy, false);
-			return beanTypeProxy;
-		}
-	}
-
-	/*
-	 * It is important that this be called only from within a transaction.
-	 */
-	private Commands.GetClassIDReturn getClassIDReturn(IREMConnection connection, Integer classID) throws CommandException, ThrowableProxy {
-		try {
-			return connection.getClassFromID(classID.intValue());
-		} catch (CommandErrorException e) {
-			fBeanFactory.processErrorReturn(e); // Let proxy factory handle the error return
-		}
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registerBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy,
-	 *      boolean)
-	 */
-	public synchronized void registerBeanTypeProxy(IBeanTypeProxy aBeanTypeProxy, boolean permanent) {
-		fBeanProxies.put(aBeanTypeProxy.getTypeName(), aBeanTypeProxy);
-		fBeanFactory.registerProxy((IREMBeanProxy) aBeanTypeProxy);
-		if (permanent)
-			fPermanentProxies.add(aBeanTypeProxy);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registerBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType,
-	 *      boolean)
-	 */
-	public void registerBeanTypeProxy(IProxyBeanType aProxyBeanType, final boolean permanent) {
-		if (aProxyBeanType.isBeanProxy())
-			registerBeanTypeProxy((IBeanTypeProxy) aProxyBeanType, permanent); // A regular kind, do regular registration.
-		else {
-			ExpressionProxy beanExpressionProxy = ((ExpressionProxy) aProxyBeanType);
-			final String typeName = aProxyBeanType.getTypeName();
-			((REMExpression) beanExpressionProxy.getExpression()).addBeanType(typeName, aProxyBeanType);
-			beanExpressionProxy.addProxyListener(new ExpressionProxy.ProxyAdapter() {
-
-				public void proxyResolved(ProxyEvent event) {
-					String typeName = ((IProxyBeanType) event.getSource()).getTypeName();
-					synchronized (REMStandardBeanTypeProxyFactory.this) {
-						if (!fBeanProxies.containsKey(typeName)) {
-							// It hasn't been resolved through some other means. So this is good. Actually this should never
-							// occur because upon resolution we've already registered the bean type proxy through the
-							// normal mechanisms. But to be safe, we'll do it here.
-							fBeanProxies.put(typeName, event.getProxy());
-							if (permanent)
-								fPermanentProxies.add(event.getProxy());
-						}
-					}
-				}
-				
-				public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
-					((REMExpression) ((ExpressionProxy) event.getSource()).getExpression()).removeBeanType(typeName);
-				}
-			});
-		}
-
-	}
-
-	/**
-	 * A beantype proxy is asked to be released. We can only release ones that were not in the permanent set that we initialized with. Those in the
-	 * permanent set can't be changed so we can't release them.
-	 * 
-	 * Answer whether it can be released from the server too.
-	 * 
-	 * NOTE: Package protected since only REMStandardBeanProxyFactory should call it.
-	 */
-	boolean releaseProxy(IBeanTypeProxy proxy) {
-		/**
-		 * Currently we won't allow any bean type proxies to be released. We don't have a good strategy for handling that there may be hard refs from
-		 * subtypes. One thought is that beanproxies table should store SoftReferences so that only when space is needed, that any beantype that
-		 * doesn't have a subtype (since subtypes hold a strong ref) or, is in the permanent table (since that is hardref) could be GC'd. Then what
-		 * would happen is on releaseProxy we don't actually release, we change it to a WeakRef so that it would definitely be released on a GC. These
-		 * are complicated arch. and we're not sure if it should be allowed or not. So for now, we don't allow them to be released. if
-		 * (!fPermanentProxies.contains(proxy)) { // We can release it. It is not one of the permanent ones. synchronized(this) {
-		 * fBeanProxies.remove(proxy.getTypeName()); return true; } }
-		 */
-		return false;
-	}
-
-	/*
-	 * Terminate this factory. Since all of the proxies are registered in the proxy factory, there is no need to release them here. There is no need
-	 * to clear out any fields since this factory will not be held onto by anything and so it will be GC'd.
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeRegistered(String)
-	 */
-	public synchronized boolean isBeanTypeRegistered(String className) {
-		return fBeanProxies.containsKey(MapTypes.getJNIFormatName(className));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registeredTypes()
-	 */
-	public Set registeredTypes() {
-		return fBeanProxies.keySet();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeNotFound(String)
-	 */
-	public synchronized boolean isBeanTypeNotFound(String className) {
-		return fNotFoundTypes != null && fNotFoundTypes.contains(MapTypes.getJNIFormatName(className));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isMaintainNotFoundTypes()
-	 */
-	public synchronized boolean isMaintainNotFoundTypes() {
-		return fNotFoundTypes != null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#setMaintainNotFoundTypes(boolean)
-	 */
-	public synchronized void setMaintainNotFoundTypes(boolean maintain) {
-		if (maintain) {
-			if (fNotFoundTypes == null)
-				fNotFoundTypes = new HashSet();
-		} else
-			fNotFoundTypes = null;
-	}
-
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStringBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStringBeanProxy.java
deleted file mode 100644
index eeba715..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStringBeanProxy.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMStringBeanProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-
-/**
- * Remote VM Implementation of IStringBeanProxy
- * Creation date: (2/6/00 9:02:42 AM)
- * @author: Joe Winchester
- */
-final class REMStringBeanProxy extends REMConstantBeanProxy implements IStringBeanProxy {
-	private final String fString;
-
-/**
- * Store the bean in the string field to save re-casting each time it is asked for.
- * It is package protected because they are created
- * in a special way and no one else should create them.
- */
-REMStringBeanProxy(REMProxyFactoryRegistry aRegistry, String value) {
-	super(aRegistry);
-	fString = value;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof IStringBeanProxy)
-		return fString.equals(((IStringBeanProxy) anObject).stringValue());
-	else
-		return fString.equals(anObject);
-}
-/**
- * Return the cache'd string that is a java.lang.String that the IDE can use
- */
-public String stringValue() {
-	return fString;
-}
-
-/**
- * Return the toString value from the bean.
- */
-public String toBeanString() {
-	return fString.toString();
-}
-
-/**
- * Get the beantype
- */
-public IBeanTypeProxy getTypeProxy() {
-	return ((REMStandardBeanTypeProxyFactory) fFactory.getBeanTypeProxyFactory()).stringClass;
-}
-
-/**
- * Render the bean into value object.
- */
-public void renderBean(Commands.ValueObject value) {
-	value.set(fString);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStringBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStringBeanTypeProxy.java
deleted file mode 100644
index 8a9f0be..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMStringBeanTypeProxy.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMStringBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Remote Implementation of the BeanType proxy for java.lang.String
- * Creation date: (2/6/00 9:01:23 AM)
- * @author: Joe Winchester
- */
-final class REMStringBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMConstantBeanTypeProxy {
-	// Cache a proxy to an empty string for speed
-	protected final IStringBeanProxy emptyStringProxy;
-/**
- * IDEStringBeanTypeProxy constructor comment.
- * @param aClass java.lang.Class
- */
-REMStringBeanTypeProxy(REMProxyFactoryRegistry aRegistry, IBeanTypeProxy objectTypeProxy) {
-	super(aRegistry, new Integer(Commands.STRING_CLASS), String.class.getName(), objectTypeProxy);
-
-	// Cache a proxy to an empty string for speed
-	emptyStringProxy = new REMStringBeanProxy(aRegistry, "");	//$NON-NLS-1$
-}
-/**
- * Helper to create string beans
- * Package protected because no-one else outside the package should use this, they
- * must go through the API where you look up a factory first.
- */
-IStringBeanProxy createStringBeanProxy(String aString){
-	if ( aString.equals("") ) {//$NON-NLS-1$
-		return emptyStringProxy;
-	} else {
-		return new REMStringBeanProxy(fRegistry, aString);
-	}
-}
-
-/**
- * Create a new bean proxy with the specified id.
- *
- * For all of the primitive wrapper types, this is an invalid operation. They are created
- * explicitly through the appropriate create method.
- */
-public IREMBeanProxy newBeanProxy(Integer anID) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For all of the primitive wrapper types, they are final classes, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newInstance method. String has a default ctor, but it results in the emptyStringProxy,
- * so return the zeroProxy for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return emptyStringProxy;
-}
-
-/**
- * newInstance method comment. Put a short cut in for strings so we don't need to go to the remote
- * vm just to create a string.
- */
-public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException {
-	if (initializationString.length() <= 1)
-		return super.newInstance(initializationString);	// Not large enough for two quotes, so let default handle it.
-	// Need a quick check that it is only one quoted string. Anything else needs to be passed on up.
-	String s = initializationString.trim();
-	int sl = s.length()-1;	
-	if (s.charAt(0) != '"' || s.charAt(sl) != '"')
-		return super.newInstance(initializationString);	// No leading and trailing quote.
-
-	StringBuffer sb = new StringBuffer(sl);
-	boolean escape = false;		
-	for (int i=1; i<sl; i++) {
-		char c = s.charAt(i);
-		if (c == '\\') {
-			escape = true;
-			continue;
-		}
-		if (!escape && c == '"')
-			return super.newInstance(initializationString);	// Had a quote in the middle without an escape. This means an expression, send on up.
-		escape = false;
-		sb.append(c);
-	}
-	
-	return getProxyFactoryRegistry().getBeanProxyFactory().createBeanProxyWith(sb.toString());
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return createStringBeanProxy((String) value.anObject);
-}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMThrowableBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMThrowableBeanProxy.java
deleted file mode 100644
index 6a21ffd..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMThrowableBeanProxy.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMThrowableBeanProxy.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-/**
- * Exception Proxy for exception on Remote.
- * NOTE: This one is unusual in that it doesn't inherit from
- *       IDEBeanProxy because it needs to be an exception, and
- *       exceptions are not an interface.
- */
-public class REMThrowableBeanProxy extends ThrowableProxy implements IREMBeanProxy {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = 2076777336810215206L;
-	private Integer fID;
-	protected final REMProxyFactoryRegistry fFactory;
-	private IBeanTypeProxy fTypeProxy;
-
-	/**
-	 * Set the bean we are proxying.  We are a proxy for a bean running on the remote VM. 
-	 */
-	protected REMThrowableBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType){
-		fFactory = aRegistry;
-		fID = anID;
-		fTypeProxy = aType;
-	}
-	
-	/**
-	 * equals: Equal if:
-	 *         1) This proxy == (identity) to the other object
-	 *         2) Else if other is an IBeanProxy and not a constant one, then if
-	 *            equals on the server.
-	 *         3) If this is a constant proxy and the other is too or is a constant
-	 *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
-	 */
-	public boolean equals(Object anObject) {
-		if (super.equals(anObject))
-			return true;	// Identity
-		if (anObject instanceof IBeanProxy && !(anObject instanceof IREMConstantBeanProxy) && fFactory.isValid() && ((IBeanProxy) anObject).getProxyFactoryRegistry() == fFactory)
-			try {
-				// The other is a bean proxy and is not a constant one, let the server do the check.
-				return ((IBooleanBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getObjectEquals().invoke(this, (IBeanProxy) anObject)).booleanValue();
-			} catch (ThrowableProxy e) {
-			}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		return this == aBeanProxy;	// We can be assured in Remote Proxy that identity of proxy and identity of object are the same.
-	}
-	
-	
-	/**
-	 * Get ID. An internal method to be used only within the ProxyFactory family.
-	 */
-	public Integer getID() {
-		return fID;
-	}
-	
-	/**
-	 * isValid - has this bean been released.
-	 */
-	public boolean isValid() {
-		return fID != null;
-	}
-	
-	/**
-	 * release - The bean is being released.
-	 */
-	public void release() {
-		fID = null;
-		fTypeProxy = null;
-	} 
-		
-	/**
-	 * Return the registry this proxy was created with.
-	 */
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fFactory;
-	}
-	
-	/**
-	 * Return the proxied class of the bean
-	 * Creation date: (12/3/99 11:37:01 AM)
-	 * @author: Joe Winchester
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return fTypeProxy;
-	}
-	
-	/**
-	 * Return the toString of the actual bean on the remote side.
-	 */
-	public String toBeanString() {
-		IStringBeanProxy string = (IStringBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getObjectToString().invokeCatchThrowableExceptions(this);
-		return (string != null) ? string.stringValue() : null;
-	}
-	
-	public String getProxyLocalizedMessage() {
-		IStringBeanProxy msg = (IStringBeanProxy) REMStandardBeanProxyConstants.getConstants(fFactory).getThrowableLocalizedMessage().invokeCatchThrowableExceptions(this);
-		return msg != null ? msg.stringValue() : null;
-	}
-	
-	public String getProxyMessage() {
-		IStringBeanProxy msg = (IStringBeanProxy)  REMStandardBeanProxyConstants.getConstants(fFactory).getThrowableMessage().invokeCatchThrowableExceptions(this);
-		return msg != null ? msg.stringValue() : null;
-	}
-	
-	/**
-	 * Temporary way to get the string value of the stacktrace.
-	 */
-	private String getProxyStackTrace() {
-		IMethodProxy tempGetStackTrace = fFactory.getMethodProxyFactory().getMethodProxy("org.eclipse.jem.internal.proxy.vm.remote.StackTraceUtility", "printStackTrace", new String[] {"java.lang.Throwable"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-		IStringBeanProxy trace = (IStringBeanProxy) tempGetStackTrace.invokeCatchThrowableExceptions(null, this);
-		return trace != null ? trace.stringValue() : ""; //$NON-NLS-1$
-	}
-		
-	public void printProxyStackTrace(java.io.PrintWriter writer) {
-		String trace = getProxyStackTrace();
-		synchronized(writer) {
-			writer.print(trace);
-		}
-	}
-	
-	public void printProxyStackTrace(java.io.PrintStream stream) {
-		String trace = getProxyStackTrace();
-		synchronized(stream) {
-			stream.print(trace);
-		}
-
-	}
-	
-	public void printProxyStackTrace() {
-		String trace = getProxyStackTrace();
-		synchronized(System.err) {
-			System.err.print(trace);
-		}
-	}
-
-
-	/**
-	 * Below are the actual printStackTrace. They are set up to first call
-	 * the proxy trace so that it can show where it occurred on the server,
-	 * and then it will do a super to show where it occurred on this side.
-	 */
-	public void printStackTrace() { 
-		synchronized (System.err) {
-			System.err.println(ProxyRemoteMessages.REMOTE_VM_TRACE_INFO_); 
-			printProxyStackTrace();
-			System.err.println(ProxyRemoteMessages.REMOTE_VM_LOCAL_TRACE_INFO_); 
-			super.printStackTrace();
-		}
-	}
-
-	public void printStackTrace(java.io.PrintWriter s) { 
-		synchronized (s) {
-			s.println(ProxyRemoteMessages.REMOTE_VM_TRACE_INFO_); 
-			printProxyStackTrace(s);
-			s.println(ProxyRemoteMessages.REMOTE_VM_LOCAL_TRACE_INFO_); 
-			super.printStackTrace(s);
-		}
-	}
-
-	public void printStackTrace(java.io.PrintStream s) { 
-		synchronized (s) {
-			s.println(ProxyRemoteMessages.REMOTE_VM_TRACE_INFO_); 
-			printProxyStackTrace(s);
-			s.println(ProxyRemoteMessages.REMOTE_VM_LOCAL_TRACE_INFO_); 
-			super.printStackTrace(s);
-		}
-	}
-
-	/**
-	 * Render the bean into value object.
-	 */
-	public void renderBean(Commands.ValueObject value) {
-		value.setObjectID(getID().intValue());
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMThrowableBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMThrowableBeanTypeProxy.java
deleted file mode 100644
index 0dc9f29..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMThrowableBeanTypeProxy.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMThrowableBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * The Remote implementation of a Throwable bean type.
- */
-public class REMThrowableBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMSpecialBeanTypeProxy {
-	
-	protected REMThrowableBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-		super(aRegistry, anID, aClassname, aSuperType);
-	}	
-	
-	/**
-	 * Helper to create a bean proxy
-	 * Package protected because everyone should go through the factory API
-	 * that is defined as part of IBeanProxyFactory
-	 */
-	REMThrowableBeanProxy createThrowableBeanProxy(Integer objectID) {
-		return new REMThrowableBeanProxy(fRegistry, objectID, this);
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * NOTE: All subclasses must override this to return the correct type of BeanTypeProxy.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return newBeanTypeForClass(anID, aClassname, anAbstract, this);
-	}
-
-	/**
-	 * The special method to handle subclassing from an abstract).
-	 */		
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract, IBeanTypeProxy superType) {
-		// We can never have an interface of type Throwable since that doesn't exist.
-		if (!anAbstract)
-			return new REMThrowableBeanTypeProxy(fRegistry, anID, aClassname, superType);
-		else
-			return new REMAnAbstractBeanTypeProxy(fRegistry, anID, aClassname, superType, this);
-	}
-	
-	/**
-	 * Specialized from REMAbstractBeanTypeProxy to ensure ExceptionBeanProxies are created correctly.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer objectID) {
-		return createThrowableBeanProxy(objectID);
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMVoidBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMVoidBeanTypeProxy.java
deleted file mode 100644
index 4b0f272..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/REMVoidBeanTypeProxy.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote;
-/*
- *  $RCSfile: REMVoidBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-/**
- * BeanTypeProxy for representing the "void" type value, and a value of this type is "null".
- * Creation date: (2/11/00 2:26:47 PM)
- * @author: Richard Lee Kulp
- */
-final class REMVoidBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMConstantBeanTypeProxy {
-
-	
-protected REMVoidBeanTypeProxy(REMProxyFactoryRegistry aRegistry) {
-	super(aRegistry, new Integer(Commands.VOID_TYPE), Void.TYPE.getName(), null);
-}
-
-/**
- * Return the supertype for us
- * null/void has no superclass.
- * This is required as part of the interface
- */
-public IBeanTypeProxy getSuperBeanTypeProxy() {
-	return null;
-}
-
-/**
- * Create a new bean proxy with the specified id.
- *
- * For void, this is an invalid operation. They are created
- * explicitly through the appropriate create method.
- */
-public IREMBeanProxy newBeanProxy(Integer anID) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
- * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
- * This is because subclasses, unless explicitly overridden, should use the same kind
- * of beantype proxy. This way if anything special is needed for a specific type, then
- * that can be done.
- *
- * For void is a final class, so you can't create a newBeanType 
- * for subclasses.
- */
-public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-	throw new UnsupportedOperationException();
-}
-
-/**
- * newInstance method. void represents "null",
- * so return the null for this case because that is the default value.
- */
-public IBeanProxy newInstance() {
-	return null;
-}
-
-/**
- * Create a new bean proxy the ValueObject passed in.
- * We will assume the object is correct type.
- */
-public IBeanProxy newBeanProxy(Commands.ValueObject value) {
-	return newInstance();
-}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMDimensionBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMDimensionBeanProxy.java
deleted file mode 100644
index 8d1fdf1..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMDimensionBeanProxy.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMDimensionBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.remote.*;
-import org.eclipse.jem.internal.proxy.awt.*;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * The REM Bean Proxy for java.awt.Dimension.
- */
-public class REMDimensionBeanProxy extends REMBeanProxy implements IDimensionBeanProxy {
-	
-	protected REMDimensionBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType) {	
-		super(aRegistry, anID, aType);
-	}
-	
-	public int getHeight() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getDimensionHeightFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public int getWidth() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getDimensionWidthFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public void setHeight(int height) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getDimensionHeightFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(height));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setWidth(int width) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getDimensionWidthFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(width));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setSize(int width, int height) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getDimensionSetSizeHWProxy().invokeCatchThrowableExceptions(this, new IBeanProxy[] {fFactory.getBeanProxyFactory().createBeanProxyWith(width), fFactory.getBeanProxyFactory().createBeanProxyWith(height)});
-	}
-	
-	public void setSize(IDimensionBeanProxy fromDimensionProxy) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getDimensionSetSizeDProxy().invokeCatchThrowableExceptions(this, fromDimensionProxy);
-	}	
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMDimensionBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMDimensionBeanTypeProxy.java
deleted file mode 100644
index 6064424..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMDimensionBeanTypeProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMDimensionBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.remote.*;
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-/**
- * Beantype proxy for java.awt.Dimension
- */
-public class REMDimensionBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMSpecialBeanTypeProxy {
-	
-	protected REMDimensionBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-		super(aRegistry, anID, aClassname, aSuperType);
-	}
-		
-	/**
-	 * Helper to create a bean proxy
-	 * Package protected because everyone should go through the factory API
-	 * that is defined as part of IBeanProxyFactory
-	 */
-	REMDimensionBeanProxy createDimensionBeanProxy(Integer objectID) {
-		return new REMDimensionBeanProxy(fRegistry, objectID, this);
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * NOTE: All subclasses must override this to return the correct type of BeanTypeProxy.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return newBeanTypeForClass(anID, aClassname, anAbstract, this);
-	}
-
-	/**
-	 * The special method to handle subclassing from an abstract).
-	 */		
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract, IBeanTypeProxy superType) {
-		if (!anAbstract)
-			return new REMDimensionBeanTypeProxy(fRegistry, anID, aClassname, superType);
-		else
-			return new REMAnAbstractBeanTypeProxy(fRegistry, anID, aClassname, superType, this);
-	}
-	
-	/**
-	 * Specialized from REMAbstractBeanTypeProxy to ensure ExceptionBeanProxies are created correctly.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer objectID) {
-		return createDimensionBeanProxy(objectID);
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMPointBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMPointBeanProxy.java
deleted file mode 100644
index a3877f5..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMPointBeanProxy.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMPointBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.remote.*;
-import org.eclipse.jem.internal.proxy.awt.*;
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * The REM Bean Proxy for java.awt.Point.
- */
-public class REMPointBeanProxy extends REMBeanProxy implements IPointBeanProxy {
-	
-	protected REMPointBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType) {	
-		super(aRegistry, anID, aType);
-	}
-	
-	public int getX() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getPointXFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public int getY() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getPointYFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public void setX(int x) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getPointXFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(x));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setY(int y) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getPointYFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(y));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setLocation(int x, int y) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getPointSetLocationXYProxy().invokeCatchThrowableExceptions(this, new IBeanProxy[] {fFactory.getBeanProxyFactory().createBeanProxyWith(x), fFactory.getBeanProxyFactory().createBeanProxyWith(y)});
-	}
-	
-	public void setLocation(IPointBeanProxy fromPointProxy) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getPointSetLocationPProxy().invokeCatchThrowableExceptions(this, fromPointProxy);
-	}	
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMPointBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMPointBeanTypeProxy.java
deleted file mode 100644
index 8ee458e..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMPointBeanTypeProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMPointBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.remote.*;
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-/**
- * Beantype proxy for java.awt.Dimension
- */
-public class REMPointBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMSpecialBeanTypeProxy {
-	
-	protected REMPointBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-		super(aRegistry, anID, aClassname, aSuperType);
-	}
-		
-	/**
-	 * Helper to create a bean proxy
-	 * Package protected because everyone should go through the factory API
-	 * that is defined as part of IBeanProxyFactory
-	 */
-	REMPointBeanProxy createPointBeanProxy(Integer objectID) {
-		return new REMPointBeanProxy(fRegistry, objectID, this);
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * NOTE: All subclasses must override this to return the correct type of BeanTypeProxy.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return newBeanTypeForClass(anID, aClassname, anAbstract, this);
-	}
-
-	/**
-	 * The special method to handle subclassing from an abstract).
-	 */		
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract, IBeanTypeProxy superType) {
-		if (!anAbstract)
-			return new REMPointBeanTypeProxy(fRegistry, anID, aClassname, superType);
-		else
-			return new REMAnAbstractBeanTypeProxy(fRegistry, anID, aClassname, superType, this);
-	}
-	
-	/**
-	 * Specialized from REMAbstractBeanTypeProxy to ensure ExceptionBeanProxies are created correctly.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer objectID) {
-		return createPointBeanProxy(objectID);
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRectangleBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRectangleBeanProxy.java
deleted file mode 100644
index be3194d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRectangleBeanProxy.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMRectangleBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.remote.*;
-import org.eclipse.jem.internal.proxy.awt.*;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * The REM Bean Proxy for java.awt.Rectangle.
- */
-public class REMRectangleBeanProxy extends REMBeanProxy implements IRectangleBeanProxy {
-	
-	protected REMRectangleBeanProxy(REMProxyFactoryRegistry aRegistry, Integer anID, IBeanTypeProxy aType) {	
-		super(aRegistry, anID, aType);
-	}
-	
-	public int getX() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleXFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public int getY() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleYFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public void setX(int x) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleXFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(x));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setY(int y) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleYFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(y));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setLocation(int x, int y) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleSetLocationXYProxy().invokeCatchThrowableExceptions(this, new IBeanProxy[] {fFactory.getBeanProxyFactory().createBeanProxyWith(x), fFactory.getBeanProxyFactory().createBeanProxyWith(y)});
-	}
-	
-	public void setLocation(IPointBeanProxy fromPointProxy) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleSetLocationPProxy().invokeCatchThrowableExceptions(this, fromPointProxy);
-	}
-	
-	
-	public int getHeight() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleHeightFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public int getWidth() {
-		try {
-			IIntegerBeanProxy h = (IIntegerBeanProxy) JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleWidthFieldProxy().get(this);
-			return h.intValue();
-		} catch (ThrowableProxy e) {
-			return 0;
-		}
-	}
-	
-	public void setHeight(int height) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleHeightFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(height));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setWidth(int width) {
-		try {
-			JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleWidthFieldProxy().set(this, fFactory.getBeanProxyFactory().createBeanProxyWith(width));
-		} catch (ThrowableProxy e) {
-		}
-	}
-	
-	public void setSize(int width, int height) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleSetSizeHWProxy().invokeCatchThrowableExceptions(this, new IBeanProxy[] {fFactory.getBeanProxyFactory().createBeanProxyWith(width), fFactory.getBeanProxyFactory().createBeanProxyWith(height)});
-	}
-	
-	public void setSize(IDimensionBeanProxy fromDimensionProxy) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleSetSizeDProxy().invokeCatchThrowableExceptions(this, fromDimensionProxy);
-	}
-	
-	public void setBounds(int x, int y, int width, int height) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleSetBoundsXYHWProxy().invokeCatchThrowableExceptions(this, new IBeanProxy[] {fFactory.getBeanProxyFactory().createBeanProxyWith(x), fFactory.getBeanProxyFactory().createBeanProxyWith(y), fFactory.getBeanProxyFactory().createBeanProxyWith(width), fFactory.getBeanProxyFactory().createBeanProxyWith(height)});
-	}
-	
-	public void setBounds(IRectangleBeanProxy fromRectangleProxy) {
-		JavaStandardAwtBeanConstants.getConstants(fFactory).getRectangleSetBoundsRProxy().invokeCatchThrowableExceptions(this, fromRectangleProxy);
-	}			
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRectangleBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRectangleBeanTypeProxy.java
deleted file mode 100644
index 31fcc77..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRectangleBeanTypeProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMRectangleBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.remote.*;
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-/**
- * Beantype proxy for java.awt.Dimension
- */
-public class REMRectangleBeanTypeProxy extends REMAbstractBeanTypeProxy implements IREMSpecialBeanTypeProxy {
-	
-	protected REMRectangleBeanTypeProxy(REMProxyFactoryRegistry aRegistry, Integer anID, String aClassname, IBeanTypeProxy aSuperType) {
-		super(aRegistry, anID, aClassname, aSuperType);
-	}
-		
-	/**
-	 * Helper to create a bean proxy
-	 * Package protected because everyone should go through the factory API
-	 * that is defined as part of IBeanProxyFactory
-	 */
-	REMRectangleBeanProxy createRectangleBeanProxy(Integer objectID) {
-		return new REMRectangleBeanProxy(fRegistry, objectID, this);
-	}
-	
-	/**
-	 * newBeanTypeForClass: Create a new beantypeproxy of this kind for the given class.
-	 * This is used by beantype proxy factory when creating a beantype proxy for a subclass.
-	 * This is because subclasses, unless explicitly overridden, should use the same kind
-	 * of beantype proxy. This way if anything special is needed for a specific type, then
-	 * that can be done.
-	 *
-	 * NOTE: All subclasses must override this to return the correct type of BeanTypeProxy.
-	 */
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract) {
-		return newBeanTypeForClass(anID, aClassname, anAbstract, this);
-	}
-
-	/**
-	 * The special method to handle subclassing from an abstract).
-	 */		
-	public IREMBeanTypeProxy newBeanTypeForClass(Integer anID, String aClassname, boolean anAbstract, IBeanTypeProxy superType) {
-		if (!anAbstract)
-			return new REMRectangleBeanTypeProxy(fRegistry, anID, aClassname, superType);
-		else
-			return new REMAnAbstractBeanTypeProxy(fRegistry, anID, aClassname, superType, this);
-	}
-	
-	/**
-	 * Specialized from REMAbstractBeanTypeProxy to ensure ExceptionBeanProxies are created correctly.
-	 */
-	public IREMBeanProxy newBeanProxy(Integer objectID) {
-		return createRectangleBeanProxy(objectID);
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRegisterAWT.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRegisterAWT.java
deleted file mode 100644
index af121c4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMRegisterAWT.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMRegisterAWT.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-import org.eclipse.jem.internal.proxy.core.IMethodProxy;
-import org.eclipse.jem.internal.proxy.remote.REMProxyFactoryRegistry;
-/**
- * This class is used to register the AWT factories. It is not
- * meant to be called by anyone other than ProxyVMStarter.
- */
-public final class REMRegisterAWT {
-	public static void registerAWT(REMProxyFactoryRegistry registry) {
-		new REMStandardAWTBeanTypeProxyFactory(registry);
-		new REMStandardAWTBeanProxyFactory(registry);
-		
-		// If we are doing AWT, get the AWT event queue going. This is trying to be a time-saver
-		// by having it up right away.
-		IBeanTypeProxy starterBeanType = registry.getBeanTypeProxyFactory().getBeanTypeProxy("org.eclipse.jem.internal.proxy.vm.remote.AWTStarter"); //$NON-NLS-1$
-		if (starterBeanType != null) {
-			IMethodProxy starter = starterBeanType.getMethodProxy("startAWT"); //$NON-NLS-1$
-			if (starter != null)
-				starter.invokeCatchThrowableExceptions(null);
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMStandardAWTBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMStandardAWTBeanProxyFactory.java
deleted file mode 100644
index 29adbf6..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMStandardAWTBeanProxyFactory.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.remote.awt;
-/*
- *  $RCSfile: REMStandardAWTBeanProxyFactory.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import org.eclipse.jem.internal.proxy.awt.*;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.remote.REMProxyFactoryRegistry;
-
-/**
- * Standard AWT Bean Proxy Factory.
- * Package protected because it should not referenced
- * outside of the package other than through the interface.
- */
-class REMStandardAWTBeanProxyFactory implements IStandardAwtBeanProxyFactory {
-
-	final IStandardBeanTypeProxyFactory fBeanTypeFactory;
-	
-	public REMStandardAWTBeanProxyFactory(REMProxyFactoryRegistry factory) {
-		factory.registerBeanProxyFactory(IStandardAwtBeanProxyFactory.REGISTRY_KEY, this);
-		fBeanTypeFactory = factory.getBeanTypeProxyFactory();
-	}
-	
-	public IDimensionBeanProxy createDimensionBeanProxyWith(int width, int height){
-		try {
-			return (IDimensionBeanProxy) fBeanTypeFactory.getBeanTypeProxy("java.awt.Dimension").newInstance("new java.awt.Dimension("+width+","+height+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-		} catch (ThrowableProxy e) {
-			return null;
-		} catch (InstantiationException e) {
-			return null;	// Shouldn't occur
-		}
-	}
-	
-	public IPointBeanProxy createPointBeanProxyWith(int x, int y){
-		try {
-			return (IPointBeanProxy) fBeanTypeFactory.getBeanTypeProxy("java.awt.Point").newInstance("new java.awt.Point("+x+","+y+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-		} catch (ThrowableProxy e) {
-			return null;
-		} catch (InstantiationException e) {
-			return null;	// Shouldn't occur
-		}
-
-	}
-	
-	public IRectangleBeanProxy createBeanProxyWith(int x, int y, int width, int height){
-		try {
-			return (IRectangleBeanProxy) fBeanTypeFactory.getBeanTypeProxy("java.awt.Rectangle").newInstance("new java.awt.Rectangle("+x+","+y+","+width+","+height+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
-		} catch (ThrowableProxy e) {
-			return null;
-		} catch (InstantiationException e) {
-			return null;	// Shouldn't occur
-		}
-
-	}
-	
-	/*
-	 * Terminate this factory. Since it doesn't hold onto anything other than the beantype factory,
-	 * and nothing will be holding onto this factory, nothing needs to be done. It will be GC'd.
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMStandardAWTBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMStandardAWTBeanTypeProxyFactory.java
deleted file mode 100644
index 57f6e4a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/awt/REMStandardAWTBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: REMStandardAWTBeanTypeProxyFactory.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.remote.awt;
-
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-import org.eclipse.jem.internal.proxy.remote.*;
-
-/**
- * BeanType factory standard AWT bean types. This is package protected because it shouldn't be referenced outside the package. It should only be
- * accessed through the interface.
- */
-class REMStandardAWTBeanTypeProxyFactory implements IREMBeanTypeProxyFactory {
-
-	static final String BEAN_TYPE_FACTORY_KEY = "java.awt"; //$NON-NLS-1$
-
-	protected final REMProxyFactoryRegistry fFactoryRegistry;
-
-	REMStandardAWTBeanTypeProxyFactory(REMProxyFactoryRegistry aRegistry) {
-		fFactoryRegistry = aRegistry;
-		fFactoryRegistry.registerBeanTypeProxyFactory(BEAN_TYPE_FACTORY_KEY, this);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanTypeProxyFactory#getExtensionBeanTypeProxy(java.lang.String)
-	 */
-	public IREMBeanTypeProxy getExtensionBeanTypeProxy(String className) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanTypeProxyFactory#getExtensionBeanTypeProxy(java.lang.String, java.lang.Integer,
-	 *      org.eclipse.jem.internal.proxy.core.IBeanTypeProxy)
-	 */
-	public IREMBeanTypeProxy getExtensionBeanTypeProxy(String className, Integer classID, IBeanTypeProxy superType) {
-
-		if ("java.awt.Dimension".equals(className)) //$NON-NLS-1$
-			return new REMDimensionBeanTypeProxy(fFactoryRegistry, classID, className, superType);
-		else if ("java.awt.Point".equals(className)) //$NON-NLS-1$
-			return new REMPointBeanTypeProxy(fFactoryRegistry, classID, className, superType);
-		else if ("java.awt.Rectangle".equals(className)) //$NON-NLS-1$
-			return new REMRectangleBeanTypeProxy(fFactoryRegistry, classID, className, superType);
-		else
-			return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.remote.IREMBeanTypeProxyFactory#getExtensionBeanTypeProxy(java.lang.String,
-	 *      org.eclipse.jem.internal.proxy.core.IExpression)
-	 */
-	public IProxyBeanType getExtensionBeanTypeProxy(String typeName, IExpression expression) {
-		return getExtensionBeanTypeProxy(typeName);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxyFactory#terminateFactory(boolean)
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/messages.properties b/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/messages.properties
deleted file mode 100644
index 088b53f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/messages.properties
+++ /dev/null
@@ -1,66 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.proxy/proxyRemote/org/eclipse/jem/internal/proxy/remote/messages.properties,v $
-# $Revision: 1.15 $  $Date: 2005/08/24 20:39:06 $
-#
-
-
-
-# Exception message - {0} is the name of a project within Eclipse.
-NO_OUTPUT_FOLDER_EXC_                                                 = IWAV0071E No output folder for project "{0}."
-
-# These are lines that are placed into a log file listing the outputs from the two different streams.
-VM_TERMINATED_INFO_                                                   = IWAV0072I Remote VM terminated before any commands can be sent. Following are the error and output streams.
-VM_TERMINATED_LINE1                                                   = -- Error Stream --
-VM_TERMINATED_LINE2                                                   = -- Output Stream --
-VM_TERMINATED_LINE3                                                   = -- End of Stream Output --
-
-# These are the headers for two parts of a stack trace of an exception. The first one is the trace from the remote system.
-# The second is the trace from the local system.
-REMOTE_VM_TRACE_INFO_                                                 = IWAV0073I *** RemoteVM Exception - Trace from Remote VM:
-REMOTE_VM_LOCAL_TRACE_INFO_                                           = IWAV0074I *** Local StackTrace:
-
-# In the two below, {0} is a string that is a java creation string, e.g. "new Integer(3)", so they don't participate in translation.
-# In Classcast, {1} is a java type name, e.g. java.lang.Integer.
-Classcast_EXC_                                                        = IWAV0124E "{0}" does not evaluate to an object of type {1}
-Instantiate_EXC_                                                      = IWAV0125E "{0}" is too complicated to be evaluated
-
-# {0} is a number, e.g. 1, 2, ...
-RemoteCmd_EXC_                                                        = IWAV0126E Remote command error {0}
-
-# The following is an exception error where {0} is the name of the class of the exception and {1} is the message from the exception
-# The message {1} has already been localized (if it supplied it localized). It comes from somewhere outside of our project.
-ExceptionErrorMsg_EXC_                                                = IWAV0135E {0}({1})
-OK_7                                                                  = OK
-Proxy_NoRunner_ERROR_                                                 = IWAV0137E Could not find a Run type runner to launch for \"{0}\".
-Proxy_Error_Title                                                     = Error:
-Proxy_Terminated_too_soon_ERROR_                                      = IWAV0138E Remote VM terminated too soon. See .log file for trace of output. For VM \"{0}\".
-# This is a launch name for a given project name ({0}).
-# WARNING for the ProxyRemoteVMName and ProxyRemoteVMNameWithComment do not use double-quote ("). It will cause problems.
-ProxyRemoteVMName                                                     = Project ({0})
-# This is a launch name that has a comment ({0} is project name, {1} is the comment for this project launch)
-ProxyRemoteVMNameWithComment                                          = Project ({0})-{1}
-
-ProxyRemoteNoLaunchKey                                                = Cannot launch local proxy registry. Not launched from valid launcher.
-
-# {0} is the appropriate VMName from the above two entries.
-ProxyRemoteLaunchVM                                                   = Launching remote vm "{0}"
-
-CleanupJob_title                                                      = Remote VM Cleanup GC'd Proxies Job
-
-REMProxyFactoryRegistry_CallbackConnectionNotWorking_EXC_             = IWAV0169E Callback connection is not working.
-REMProxyFactoryRegistry_ConnectionCreationFailed_INFO_                = IWAV0170I Connection creation failed.
-REMProxyFactoryRegistry_Job_TerminateProcess_Title=Terminate the remote vm process.
-REMProxyFactoryRegistry_CouldNotCreateSocketConnectionToRemoteVM_EXC_ = IWAV0171E Could not create a socket connection to remote vm.
-REMExpression_IOExceptionSeeLog_INFO_                                 = IWAV0172I I/O Exception occurred. See .log file for details.
-REMExpression_CommandExceptionSeeLog_INFO_                            = IWAV0173I Command Exception occurred. See .log file for details.
-LocalProxyLaunchDelegate_Monitor_PrintRemoteTrace_Text=Print remote vm trace output
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEAccessibleObjectProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEAccessibleObjectProxy.java
deleted file mode 100644
index 710989d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEAccessibleObjectProxy.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IDEAccessibleObjectProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:06 $ 
- */
-package org.eclipse.jem.internal.proxy.ide;
-
-import java.lang.reflect.AccessibleObject;
-
-import org.eclipse.jem.internal.proxy.core.*;
- 
-/**
- * 
- * @since 1.0.0
- */
-public class IDEAccessibleObjectProxy extends IDEBeanProxy implements IAccessibleObjectProxy {
-
-	protected IDEAccessibleObjectProxy(IDEProxyFactoryRegistry aProxyFactoryRegistry) {
-		super(aProxyFactoryRegistry);
-	}
-
-	protected IDEAccessibleObjectProxy(IDEProxyFactoryRegistry aProxyFactoryRegistry, Object anObject) {
-		super(aProxyFactoryRegistry, anObject);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IAccessibleObjectProxy#isAccessible()
-	 */
-	public boolean isAccessible() throws ThrowableProxy {
-		return ((AccessibleObject) getBean()).isAccessible();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IAccessibleObjectProxy#setAccessible(boolean)
-	 */
-	public void setAccessible(boolean flag) throws ThrowableProxy {
-		((AccessibleObject) getBean()).setAccessible(flag);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#getTypeProxy()
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).accessibleType;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEArrayBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEArrayBeanProxy.java
deleted file mode 100644
index 518d565..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEArrayBeanProxy.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEArrayBeanProxy.java,v $
- *  $Revision: 1.9 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-import java.lang.reflect.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-/**
- * IDE VM version of the Array proxy
- */
-
-public final class IDEArrayBeanProxy extends IDEObjectBeanProxy implements IArrayBeanProxy {
-
-	private IDEStandardBeanTypeProxyFactory fBeanTypeProxyFactory;
-	
-IDEArrayBeanProxy(IDEProxyFactoryRegistry aRegistry, Object array,IBeanTypeProxy aType) {
-	super(aRegistry, array ,aType);
-	fBeanTypeProxyFactory = (IDEStandardBeanTypeProxyFactory)aRegistry.getBeanTypeProxyFactory();
-}
-/**
- * Get the object at the specified index.
- */
-public IBeanProxy get(int index) throws ThrowableProxy {
-	// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
-	// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-	IBeanTypeProxy compType = ((IArrayBeanTypeProxy) getTypeProxy()).getComponentType();
-	if (!compType.isPrimitive()) {
-		// Use standard getter.
-		Object result = Array.get(fBean,index);
-		if ( result == null ) return null;
-		return ((IDEBeanTypeProxy)fBeanTypeProxyFactory.getBeanTypeProxy(result.getClass())).newBeanProxy(result);
-	} else {
-		// Use the correct primitive getter.
-		int id = ((IDEPrimitiveBeanTypeProxy)compType).getPrimitiveType();
-		switch (id) {
-			case IDEPrimitiveBeanTypeProxy.BYTE:
-				return fBeanTypeProxyFactory.byteType.createByteBeanProxy(Array.getByte(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.BOOLEAN:
-				return fBeanTypeProxyFactory.booleanType.createBooleanBeanProxy(Array.getBoolean(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.CHAR:
-				return fBeanTypeProxyFactory.charType.createCharBeanProxy(Array.getChar(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.DOUBLE:
-				return fBeanTypeProxyFactory.doubleType.createDoubleBeanProxy(Array.getDouble(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.FLOAT:
-				return fBeanTypeProxyFactory.floatType.createFloatBeanProxy(Array.getFloat(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.INTEGER:
-				return fBeanTypeProxyFactory.intType.createIntegerBeanProxy(Array.getInt(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.LONG:
-				return fBeanTypeProxyFactory.longType.createLongBeanProxy(Array.getLong(fBean,index));
-			case IDEPrimitiveBeanTypeProxy.SHORT:
-				return fBeanTypeProxyFactory.shortType.createShortBeanProxy(Array.getShort(fBean,index));
-			default :
-				return null; // Shouldn't get here, said it was primitive, but not one we understand				
-		}
-	}		
-}
-/**
- * Get the object at the specified multi-dimensional index.
- * The array must be at least the number of dimensions specified,
- * and each index along the way must exist.
- * The number of dimensions can't be greater than the number
- * of dimensions of the real object.
- */
-public IBeanProxy get(int[] indexes) throws ThrowableProxy {
-	if (indexes.length == 1)
-		return get(indexes[0]);
-	int dims = ((IArrayBeanTypeProxy) getTypeProxy()).getDimensions();
-	if (dims < indexes.length)
-		throw new IllegalArgumentException(); // Too many dimensions
-	// Get up to the next to last dimension so that we can do the appropriate final get depending upon primitive or not.
-	Object array = fBean;
-	int lastArrayDim = indexes.length - 1;
-	for (int i = 0; i < lastArrayDim; i++)
-		array = Array.get(array, indexes[i]);
-
-	int index = indexes[lastArrayDim];	// Final array dim to retrieve
-	
-	if (dims == indexes.length) {
-		IBeanTypeProxy finalCompType = ((IArrayBeanTypeProxy) getTypeProxy()).getFinalComponentType();
-		if (finalCompType.isPrimitive()) {
-			// If the component type at the specified dimension is primitive, we need to use the correct getter so that a valid value is returned,
-			// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-			int id = ((IDEPrimitiveBeanTypeProxy) finalCompType).getPrimitiveType();
-			switch (id) {
-				case IDEPrimitiveBeanTypeProxy.BYTE :
-					return fBeanTypeProxyFactory.byteType.createByteBeanProxy(Array.getByte(array, index));
-				case IDEPrimitiveBeanTypeProxy.BOOLEAN :
-					return fBeanTypeProxyFactory.booleanType.createBooleanBeanProxy(Array.getBoolean(array, index));
-				case IDEPrimitiveBeanTypeProxy.CHAR :
-					return fBeanTypeProxyFactory.charType.createCharBeanProxy(Array.getChar(array, index));
-				case IDEPrimitiveBeanTypeProxy.DOUBLE :
-					return fBeanTypeProxyFactory.doubleType.createDoubleBeanProxy(Array.getDouble(array, index));
-				case IDEPrimitiveBeanTypeProxy.FLOAT :
-					return fBeanTypeProxyFactory.floatType.createFloatBeanProxy(Array.getFloat(array, index));
-				case IDEPrimitiveBeanTypeProxy.INTEGER :
-					return fBeanTypeProxyFactory.intType.createIntegerBeanProxy(Array.getInt(array, index));
-				case IDEPrimitiveBeanTypeProxy.LONG :
-					return fBeanTypeProxyFactory.longType.createLongBeanProxy(Array.getLong(array, index));
-				case IDEPrimitiveBeanTypeProxy.SHORT :
-					return fBeanTypeProxyFactory.shortType.createShortBeanProxy(Array.getShort(array, index));
-				default :
-					return null; // Shouldn't get here, said it was primitive, but not one we understand
-			}
-		}
-	}
-
-	// Won't be returning a primitive, so use standard accessor
-	Object result = Array.get(array, index);
-	if (result == null)
-		return null;
-	return ((IDEBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(result.getClass())).newBeanProxy(
-		result);
-}
-
-/**
- * Set the object at the specified index.
- */
-public void set(IBeanProxy valueProxy, int index) throws ThrowableProxy {
-	// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
-	// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-	Object value = ((IIDEBeanProxy)valueProxy).getBean();
-	Class valueClass = value.getClass();
-	if (!valueClass.isPrimitive()) {
-		// Use standard getter.
-		Array.set(fBean,index,value);
-	} else if (valueClass == Byte.TYPE ) {
-		Array.setByte(fBean,index,((Byte)value).byteValue());
-	} else if (valueClass == Boolean.TYPE ){
-		Array.setBoolean(fBean,index,((Boolean)value).booleanValue());			
-	} else if (valueClass == Character.TYPE) {
-		Array.setChar(fBean,index,((Character)value).charValue());
-	} else if (valueClass == Double.TYPE) {
-		Array.setDouble(fBean,index,((Double)value).doubleValue());
-	} else if (valueClass == Float.TYPE) {
-		Array.setFloat(fBean,index,((Float)value).floatValue());		
-	} else if (valueClass == Integer.TYPE) {
-		Array.setInt(fBean,index,((Integer)value).intValue());		
-	} else if (valueClass == Long.TYPE ) {
-		Array.setLong(fBean,index,((Long)value).longValue());		
-	} else if (valueClass == Short.TYPE ) {
-		Array.setShort(fBean,index,((Short)value).shortValue());		
-	}
-}
-/**
- * Set the object at the specified multi-dimensional index.
- * The array must be at least the number of dimensions specified,
- * and each index along the way must exist.
- * The number of dimensions can't be greater than the number
- * of dimensions of the real object.
- */
-public void set(IBeanProxy valueProxy, int[] indexes) throws ThrowableProxy {
-
-	Object subArray = fBean;
-	int upTo = indexes.length - 1;
-	for (int i = 0; i < upTo; i++)
-		subArray = Array.get(subArray, indexes[i]);
-	int index = indexes[upTo];
-
-	// Now set the appropriate value in
-	// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
-	// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-	Object value = ((IIDEBeanProxy) valueProxy).getBean();
-	Class valueClass = value.getClass();
-	if (!valueClass.isPrimitive()) {
-		// Use standard getter.
-		Array.set(subArray, index, value);
-	} else if (valueClass == Byte.TYPE) {
-		Array.setByte(subArray, index, ((Byte) value).byteValue());
-	} else if (valueClass == Boolean.TYPE) {
-		Array.setBoolean(subArray, index, ((Boolean) value).booleanValue());
-	} else if (valueClass == Character.TYPE) {
-		Array.setChar(subArray, index, ((Character) value).charValue());
-	} else if (valueClass == Double.TYPE) {
-		Array.setDouble(subArray, index, ((Double) value).doubleValue());
-	} else if (valueClass == Float.TYPE) {
-		Array.setFloat(subArray, index, ((Float) value).floatValue());
-	} else if (valueClass == Integer.TYPE) {
-		Array.setInt(subArray, index, ((Integer) value).intValue());
-	} else if (valueClass == Long.TYPE) {
-		Array.setLong(subArray, index, ((Long) value).longValue());
-	} else if (valueClass == Short.TYPE) {
-		Array.setShort(subArray, index, ((Short) value).shortValue());
-	}
-
-}
-/**
- * Get the length of the first dimension of this array.
- * If there are multi-dimensions, you must get the appropriate
- * dimension from the get method to see the size of that dimension.
- *
- * e.g.
- *    int [3] returns 3
- *    int [3][2] returns 3
- *
- *    ((IArrayBeanProxy) get(1)).getLength() returns 2
- *    Since arrays do not have to be homogenous, there could
- *    be a different length array for each of the arrays 
- *    returned from the first dimension, the returned length
- *    from get(2) and get(3) could result in a different value
- *    from get(1).
- */
-public int getLength() {
-	return Array.getLength(fBean);
-}	
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IArrayBeanProxy#getCatchThrowableException(int)
-	 */
-	public IBeanProxy getCatchThrowableException(int index) {
-		try {
-			return get(index);
-		} catch ( ThrowableProxy exc ) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc));			 //$NON-NLS-1$
-			return null;
-		}
-	}
-
-	
-	public IBeanProxy[] getSnapshot() throws ThrowableProxy {
-		// If the component type is primitive, we need to use the correct getter so that a valid value is returned,
-		// if we just used the standard get, if the type was "int" the value returned would be an java.lang.Integer.
-		IBeanTypeProxy compType = ((IArrayBeanTypeProxy) getTypeProxy()).getComponentType();
-		int id = compType.isPrimitive() ? ((IDEPrimitiveBeanTypeProxy)compType).getPrimitiveType() : -1;
-		IBeanProxy[] result = new IBeanProxy[Array.getLength(fBean)];
-		for (int i = 0; i < result.length; i++) {
-			if (id == -1) {
-				// Use standard getter.
-				Object val = Array.get(fBean,i);
-				if ( val != null )
-					result[i] = ((IDEBeanTypeProxy)fBeanTypeProxyFactory.getBeanTypeProxy(val.getClass())).newBeanProxy(val);
-			} else {
-				// Use the correct primitive getter.
-				switch (id) {
-					case IDEPrimitiveBeanTypeProxy.BYTE:
-						result[i] = fBeanTypeProxyFactory.byteType.createByteBeanProxy(Array.getByte(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.BOOLEAN:
-						result[i] = fBeanTypeProxyFactory.booleanType.createBooleanBeanProxy(Array.getBoolean(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.CHAR:
-						result[i] = fBeanTypeProxyFactory.charType.createCharBeanProxy(Array.getChar(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.DOUBLE:
-						result[i] = fBeanTypeProxyFactory.doubleType.createDoubleBeanProxy(Array.getDouble(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.FLOAT:
-						result[i] = fBeanTypeProxyFactory.floatType.createFloatBeanProxy(Array.getFloat(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.INTEGER:
-						result[i] = fBeanTypeProxyFactory.intType.createIntegerBeanProxy(Array.getInt(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.LONG:
-						result[i] = fBeanTypeProxyFactory.longType.createLongBeanProxy(Array.getLong(fBean,i));
-						break;
-					case IDEPrimitiveBeanTypeProxy.SHORT:
-						result[i] = fBeanTypeProxyFactory.shortType.createShortBeanProxy(Array.getShort(fBean,i));
-						break;
-					default :
-						break; // Shouldn't get here, said it was primitive, but not one we understand				
-				}
-			}		
-		}
-		return result;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEArrayBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEArrayBeanTypeProxy.java
deleted file mode 100644
index ba1e812..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEArrayBeanTypeProxy.java
+++ /dev/null
@@ -1,326 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-
-/*
- *  $RCSfile: IDEArrayBeanTypeProxy.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-import java.lang.reflect.*;
-
-/**
- * Array Type Proxy for the IDE VM.
- * 
- * The class is final because array's are special and shouldn't have any subclasses since the factory would never call it.
- */
-
-public final class IDEArrayBeanTypeProxy extends IDEBeanTypeProxy implements IArrayBeanTypeProxy {
-
-	IBeanTypeProxy fFinalComponentType;
-
-	IBeanTypeProxy fComponentType;
-
-	String fTypeName;
-
-	/**
-	 * Create with a registry and a class. It is package so that only the factory with this IDE package can call it.
-	 */
-	IDEArrayBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, String aTypeName, Class aClass) {
-		// The class of an Array is always Object
-		super(aRegistry, aClass);
-		fTypeName = aTypeName;
-	}
-
-	/**
-	 * This is an array type!
-	 */
-	public boolean isArray() {
-		return true;
-	}
-
-	public String getTypeName() {
-		return fTypeName;
-	}
-
-	/**
-	 * Return the final component type.
-	 */
-	public IBeanTypeProxy getFinalComponentType() {
-		if (fFinalComponentType == null) {
-			// Component type is strip off all '[' and return class name (if we ever add classLoader support, this won't work).
-			// However, if the type is a primitive we need to go through the change table).
-			int typeStart = getTypeName().lastIndexOf('[') + 1;
-			if (getTypeName().charAt(typeStart) == 'L') {
-				// It is a class.
-				// Strip off up to the 'L', and the trailing ';'. That is the class name.
-				fFinalComponentType = fProxyFactoryRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(
-						getTypeName().substring(typeStart + 1, getTypeName().length() - 1));
-			} else {
-				// It is a type. Need to map it.
-				Class aType = (Class) IDEStandardBeanTypeProxyFactory.MAP_SHORTSIG_TO_TYPE.get(getTypeName().substring(typeStart, typeStart + 1));
-				fFinalComponentType = aType != null ? fProxyFactoryRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(aType.getName()) : null;
-			}
-		}
-		return fFinalComponentType;
-	}
-
-	/**
-	 * Return the component type.
-	 */
-	public IBeanTypeProxy getComponentType() {
-		if (fComponentType == null) {
-			// Component type is strip off first '[' and return class name (if we ever add classLoader support, this won't work).
-			// However, if the type is a primitive we need to go through the change table).
-			if (getTypeName().charAt(1) != '[') {
-				// It is a one dimensional array, just send to getFinalComponentType to figure out the type.
-				fComponentType = getFinalComponentType();
-			} else {
-				// It is a multi-dimensional array. Just strip off one '[' and send that to the bean type factory.
-				fComponentType = fProxyFactoryRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(getTypeName().substring(1));
-			}
-		}
-		return fComponentType;
-	}
-
-	/**
-	 * Return the number of dimensions.
-	 */
-	public int getDimensions() {
-		return getTypeName().lastIndexOf('[') + 1;
-	}
-
-	/**
-	 * Return the null ctor proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy getNullConstructorProxy() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors() For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy[] getConstructors() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the REM For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors() For all of the array types, this is an invalid operation.
-	 */
-	public IConstructorProxy[] getDeclaredConstructors() {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors() For all of the array types, this is an invalid operation.
-	 */
-	public IFieldProxy[] getFields() {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String,
-	 *      org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors() For all of the array types, this is an invalid operation.
-	 */
-	public IFieldProxy[] getDeclaredFields() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return a proxy to the field for the target VM being the same as the REM For all of the array types, this is an invalid operation.
-	 */
-	public IFieldProxy getFieldProxy(String fieldName) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String argumentQualifiedTypeName) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy getMethodProxy(String methodName) {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors() For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy[] getMethods() {
-		throw new UnsupportedOperationException();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors() For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy[] getDeclaredMethods() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Return the method proxy for this method with these arguments. For all of the array types, this is an invalid operation.
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames) {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Create an array bean proxy.
-	 *  - (int, new int[2] {3, 4}) will create: int [3] [4]
-	 *  - (int[], new int[1] {1}) int [1]
-	 *  - (int[], new int[2] {2,3}) int [2] [3]
-	 * 
-	 *  - (int[], null) or (int[], new int[0]) or (int, null) or (int, new int[0]) int [0] (int[][], null) or (int[][], new int[0]) int[0][] This is
-	 * because an array instance with no dimensions specified is not valid.
-	 *  - (int[][], new int[1] {3}) int[3][]
-	 * 
-	 * It is package protected so that only the REM Factory can call it.
-	 */
-	IDEArrayBeanProxy createBeanProxyWith(int[] dimensions) throws ThrowableProxy {
-		// If the dimensions is null or zero length, then create the
-		// array as a 0 sized array one dimensional array.
-		if (dimensions == null || dimensions.length == 0)
-			return createBeanProxyWith(new int[] { 0});
-
-		// Remove from this type the number of dimensions specified
-		// coming in, up to but no further than the final component.
-		// From here we can then use the appropriate java.lang.reflect.Array
-		// method to create the array.
-		IBeanTypeProxy compType = null; // The type of array to create (it may be different number of dimensions).
-		int numDims = getDimensions();
-		if (numDims <= dimensions.length)
-			compType = getFinalComponentType(); // There are the same or more requested dimensions, so use final component type
-		else {
-			// There are fewer requested dimensions, so strip off that many
-			String compClass = getTypeName().substring(dimensions.length);
-			compType = fProxyFactoryRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(compClass);
-		}
-
-		if (dimensions.length == 1) {
-			// Use the one dimension call
-			Object array = Array.newInstance(((IDEBeanTypeProxy) compType).fClass, dimensions[0]);
-			return new IDEArrayBeanProxy(fProxyFactoryRegistry, array, null);
-		} else {
-			// Use the multi dimension call
-			Object array = Array.newInstance(((IDEBeanTypeProxy) compType).fClass, dimensions);
-			return new IDEArrayBeanProxy(fProxyFactoryRegistry, array, null);
-		}
-	}
-
-	/**
-	 * Create a new bean proxy with the specified object
-	 */
-	protected IIDEBeanProxy newBeanProxy(Object anObject) {
-
-		return new IDEArrayBeanProxy(fProxyFactoryRegistry, anObject, this);
-
-	}
-
-	/**
-	 * @see IBeanTypeProxy#getFormalTypeName()
-	 */
-	public String getFormalTypeName() {
-		String name = getTypeName();
-		int dims = name.lastIndexOf('[') + 1;
-		String type = getFinalComponentType().getTypeName();
-		StringBuffer formalType = new StringBuffer(type.length() + ("[]".length() * dims)); //$NON-NLS-1$
-		formalType.append(type);
-		for (int i = 0; i < dims; i++)
-			formalType.append("[]"); //$NON-NLS-1$
-		return formalType.toString();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBeanProxy.java
deleted file mode 100644
index ca53a1c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBeanProxy.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEBeanProxy.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-public abstract class IDEBeanProxy implements IBeanProxy, IIDEBeanProxy {
-
-	protected Object fBean;
-	protected final IDEProxyFactoryRegistry fProxyFactoryRegistry;
-
-	protected IDEBeanProxy(IDEProxyFactoryRegistry aProxyFactoryRegistry) {
-		fProxyFactoryRegistry = aProxyFactoryRegistry;
-	}
-	protected IDEBeanProxy(IDEProxyFactoryRegistry aProxyFactoryRegistry, Object anObject) {
-		fProxyFactoryRegistry = aProxyFactoryRegistry;
-		fBean = anObject;
-	}
-	public boolean isValid() {
-		return true;
-	}
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fProxyFactoryRegistry;
-	}
-	/**
-	 * USE with extreme care
-	 */
-	public final Object getBean() {
-		return fBean;
-	}
-	/**
-	 * Return the toString() of the bean
-	 */
-	public String toBeanString() {
-		return (fBean != null ? fBean.toString() : "null"); //$NON-NLS-1$
-	}
-	/**
-	 Append the bean's to string to our own name if we have one
-	 */
-	public String toString() {
-
-		if (fBean == null)
-			return super.toString();
-		else
-			return super.toString() + "(" + fBean.toString() + ")"; //$NON-NLS-2$//$NON-NLS-1$
-
-	}
-	/**
-	 * equals: If there are identical or if they wrapper the same bean. In the IDE VM this
-	 * can happen if bean proxies are created from a Bean, since proxies aren't cached in
-	 * the beanproxy factory, more than one proxy can be created for the same bean.
-	 */
-	public boolean equals(Object obj) {
-		if (super.equals(obj))
-			return true;
-		if (obj instanceof IIDEBeanProxy) {
-			return fBean.equals(((IIDEBeanProxy) obj).getBean());
-		}
-		return false;
-	}
-	
-	public int hashCode() {
-		return 12345 + (getBean() != null ? getBean().hashCode() : 0); 
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		if (this == aBeanProxy)
-			return true;
-		if (aBeanProxy instanceof IIDEBeanProxy)
-			return getBean() == ((IIDEBeanProxy) aBeanProxy).getBean();
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBeanTypeProxy.java
deleted file mode 100644
index 330c9b9..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBeanTypeProxy.java
+++ /dev/null
@@ -1,451 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * $RCSfile: IDEBeanTypeProxy.java,v $ $Revision: 1.14 $ $Date: 2005/08/24 20:39:06 $
- */
-package org.eclipse.jem.internal.proxy.ide;
-
-import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;
-import org.eclipse.jem.internal.proxy.core.*;
-
-import java.lang.reflect.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-public class IDEBeanTypeProxy extends IDEBeanProxy implements IBeanTypeProxy {
-
-	protected IDEProxyFactoryRegistry fProxyFactoryRegistry;
-
-	Class fClass;
-
-	protected IDEBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-		super(aRegistry, aClass);
-		fProxyFactoryRegistry = aRegistry;
-		fClass = aClass;
-	}
-
-	/**
-	 * Get Type Proxy. The type proxy of a BeanType is Class.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).classClass;
-	}
-
-	public Class getTypeClass() {
-		return fClass;
-	}
-
-	public String toBeanString() {
-		return fClass.toString();
-	}
-
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fProxyFactoryRegistry;
-	}
-
-	public String getTypeName() {
-		return fClass.getName();
-	}
-
-	public boolean isKindOf(IBeanTypeProxy aBeanTypeProxy) {
-		return ((IDEBeanTypeProxy) aBeanTypeProxy).fClass.isAssignableFrom(fClass);
-	}
-
-	public boolean isInterface() {
-		return fClass.isInterface();
-	}
-
-	public boolean isPrimitive() {
-		return fClass.isPrimitive();
-	}
-
-	public boolean isArray() {
-		return fClass.isArray();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IMethodProxy[] getMethods() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getMethods(fClass);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IMethodProxy[] getDeclaredMethods() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getDeclaredMethods(fClass);
-	}
-
-	/**
-	 * We can use reflection on our class to find the java.reflect.Method instance and create the IDEMethodProxy directly
-	 */
-	public IMethodProxy getMethodProxy(String methodName) {
-
-		try {
-			Method aMethod = fClass.getMethod(methodName, new Class[0]);
-			return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getMethodProxy(aMethod);
-		} catch (Exception exc) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-		}
-		return null;
-
-	}
-
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getMethodProxy(this, methodName, argumentClassNames);
-	}
-
-	public IMethodProxy getMethodProxy(String methodName, String firstArgClass) {
-		return getMethodProxy(methodName, new String[] { firstArgClass});
-	}
-
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] args) {
-		Class[] argClasses = new Class[args.length];
-		for (int i = 0; i < args.length; i++) {
-			argClasses[i] = ((IDEBeanTypeProxy) args[i]).fClass;
-		}
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getMethodProxy(fClass, methodName, argClasses);
-	}
-
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames) {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getDeclaredMethodProxy(fClass, methodName, argumentClassNames);
-	}
-
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] args) {
-		Class[] argClasses = null;
-		if (args != null) {
-			argClasses = new Class[args.length];
-			for (int i = 0; i < args.length; i++) {
-				argClasses[i] = ((IDEBeanTypeProxy) args[i]).fClass;
-			}
-		}
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getDeclaredMethodProxy(fClass, methodName, argClasses);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IInvokable getInvokable(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return getMethodProxy(methodName, argumentTypes);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, java.lang.String)
-	 */
-	public IInvokable getInvokable(String methodName, String argumentClassName) {
-		return getMethodProxy(methodName, argumentClassName);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String, java.lang.String[])
-	 */
-	public IInvokable getInvokable(String methodName, String[] argumentClassNames) {
-		return getMethodProxy(methodName, argumentClassNames);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInvokable(java.lang.String)
-	 */
-	public IInvokable getInvokable(String methodName) {
-		return getMethodProxy(methodName);
-	}
-
-	public IConstructorProxy getConstructorProxy(String[] argTypeNames) {
-		IBeanTypeProxy[] argClasses = new IBeanTypeProxy[argTypeNames.length];
-		IStandardBeanTypeProxyFactory btFactory = fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		for (int i = 0; i < argTypeNames.length; i++) {
-			argClasses[i] = btFactory.getBeanTypeProxy(argTypeNames[i]);
-			if (argClasses[i] == null) {
-				ProxyPlugin.getPlugin().getLogger().log(
-						new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "Constructor not found - " //$NON-NLS-1$
-								+ fClass.getName() + " args=" + argTypeNames, null)); //$NON-NLS-1$
-				return null;
-			}
-		}
-		return getConstructorProxy(argClasses);
-	}
-
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] args) {
-		Class[] argClasses = new Class[args.length];
-		for (int i = 0; i < args.length; i++) {
-			argClasses[i] = ((IDEBeanTypeProxy) args[i]).fClass;
-		}
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getConstructorProxy(fClass, argClasses);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IConstructorProxy[] getConstructors() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getConstructors(fClass);
-	}
-
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argTypeNames) {
-		IBeanTypeProxy[] argClasses = new IBeanTypeProxy[argTypeNames.length];
-		IStandardBeanTypeProxyFactory btFactory = fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		for (int i = 0; i < argTypeNames.length; i++) {
-			argClasses[i] = btFactory.getBeanTypeProxy(argTypeNames[i]);
-			if (argClasses[i] == null) {
-				ProxyPlugin.getPlugin().getLogger().log(
-						new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "Constructor not found - " //$NON-NLS-1$
-								+ fClass.getName() + " args=" + argTypeNames, null)); //$NON-NLS-1$
-				return null;
-			}
-		}
-		return getDeclaredConstructorProxy(argClasses);
-	}
-
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] args) {
-		Class[] argClasses = new Class[args.length];
-		for (int i = 0; i < args.length; i++) {
-			argClasses[i] = ((IDEBeanTypeProxy) args[i]).fClass;
-		}
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getDeclaredConstructorProxy(fClass, argClasses);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IConstructorProxy[] getDeclaredConstructors() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getDeclaredConstructors(fClass);
-	}
-
-	/**
-	 * Return the supertype for us Use the factory to get it rather than create it directly so that the factory has the chance to cache classes if
-	 * required This is required as part of the interface
-	 */
-	public IBeanTypeProxy getSuperBeanTypeProxy() {
-
-		if (fClass.isInterface())
-			return null;
-		else
-			return fProxyFactoryRegistry.getBeanTypeProxyFactory().getBeanTypeProxy(fClass.getSuperclass().getName());
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IFieldProxy[] getFields() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getFields(fClass);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructors()
-	 */
-	public IFieldProxy[] getDeclaredFields() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getDeclaredFields(fClass);
-	}
-
-	public IFieldProxy getFieldProxy(String fieldName) {
-		try {
-			Field field = fClass.getField(fieldName);
-			return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getFieldProxy(field);
-		} catch (NoSuchFieldException exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-					new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "Field not found " + fClass.getName() //$NON-NLS-1$
-							+ " - " + fieldName, exc)); //$NON-NLS-1$
-			return null;
-		}
-	}
-
-	public IFieldProxy getDeclaredFieldProxy(String fieldName) {
-		try {
-			Field field = fClass.getDeclaredField(fieldName);
-			return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getFieldProxy(field);
-		} catch (NoSuchFieldException exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-					new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "Field not found " + fClass.getName() //$NON-NLS-1$
-							+ " - " + fieldName, exc)); //$NON-NLS-1$
-			return null;
-		}
-	}
-
-	/**
-	 * Return a proxy to the constructor for the target VM being the same as the IDE We can use the package protected contstructor on
-	 * IDEConstructorProxy
-	 */
-	IConstructorProxy getConstructorProxy(Class[] parameterTypes) {
-
-		Constructor aConstructor = null;
-
-		// Use reflection to try and find a constructor. The argumentClassNames must be converted to classes
-		try {
-			aConstructor = fClass.getConstructor(parameterTypes);
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-		// If we have a constructor return it
-		if (aConstructor != null) {
-			return getNewConstructorProxy(aConstructor);
-		} else {
-			return null;
-		}
-
-	}
-
-	/**
-	 * Factored into its own method so subclass can override
-	 */
-	protected IConstructorProxy getNewConstructorProxy(Constructor aConstructor) {
-
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getConstructorProxy(aConstructor);
-
-	}
-
-	/**
-	 * Return a proxy to the null constructor for the target VM being the same as the IDE We can use the package protected contstructor on
-	 * IDEConstructorProxy
-	 */
-	public IConstructorProxy getNullConstructorProxy() {
-
-		Constructor aConstructor = null;
-
-		// Use reflection to try and find a constructor. The argumentClassNames must be converted to classes
-		try {
-			aConstructor = fClass.getConstructor(null);
-			return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getConstructorProxy(aConstructor);
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			return null;
-		}
-
-	}
-
-	public IBeanProxy newInstance(String initializationString) {
-		return ((IDEStandardBeanProxyFactory) fProxyFactoryRegistry.getBeanProxyFactory()).createBeanProxy(this, initializationString);
-	}
-
-	public IBeanProxy newInstance() {
-		return ((IDEStandardBeanProxyFactory) fProxyFactoryRegistry.getBeanProxyFactory()).createBeanProxy(this);
-	}
-
-	/**
-	 * Create a new bean proxy with the specified object Use the constructor that allows the type proxy to be set as well as the bean because we are
-	 * the type and by setting it now we might avoid it being lookup for in the factory the first time it is asked for
-	 * 
-	 * NOTE: All subclasses need to override this to return the appropriate IDEBeanProxy.
-	 */
-	protected IIDEBeanProxy newBeanProxy(Object anObject) {
-
-		return new IDEObjectBeanProxy(fProxyFactoryRegistry, anObject, this);
-
-	}
-
-	/**
-	 * Create a subclass beantype proxy.
-	 */
-	public IDEBeanTypeProxy newBeanTypeForClass(Class type) {
-		// Default is just another instance of this same class.
-		return new IDEBeanTypeProxy(fProxyFactoryRegistry, type);
-	}
-
-	/**
-	 * @see IBeanTypeProxy#getFormalTypeName()
-	 */
-	public String getFormalTypeName() {
-		return getTypeName();
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInitializationError()
-	 */
-	public String getInitializationError() {
-		return null; // By default none have an initialization error. There is a special instance for init errors.
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) throws AmbiguousMethodException, NoSuchMethodException {
-
-		Class[] argClasses = new Class[argumentTypes.length];
-		for (int i = 0; i < argumentTypes.length; i++) {
-			argClasses[i] = ((IDEBeanTypeProxy) argumentTypes[i]).fClass;
-		}
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getCompatibleConstructor(fClass, argClasses);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String,
-	 *      org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) throws NoSuchMethodException, AmbiguousMethodException {
-		Class[] argClasses = new Class[argumentTypes.length];
-		for (int i = 0; i < argumentTypes.length; i++) {
-			argClasses[i] = ((IDEBeanTypeProxy) argumentTypes[i]).fClass;
-		}
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getCompatibleMethod(fClass, methodName, argClasses);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameterTypes) {
-		IProxyMethod method = ((IDEExpression) expression).getMethodExpressionProxy(this, methodName, parameterTypes);
-		if (method == null) {
-			// Need to go to the expression and create it.
-			method = ((Expression) expression).createMethodExpressionProxy(this, methodName, parameterTypes);
-		}
-		return method;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes) {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes);
-	}
-	
-	public IProxyMethod getMethodProxy(IExpression expression, String methodName) {
-		return getMethodProxy(expression, methodName, (IProxyBeanType[]) null);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String)
-	 */
-	public IProxyField getFieldProxy(IExpression expression, String fieldName) {
-		IProxyField field = ((IDEExpression) expression).getFieldExpressionProxy(this, fieldName);
-		if (field == null) {
-			// Need to go to the expression and create it.
-			field = ((Expression) expression).createFieldExpressionProxy(this, fieldName);
-		}
-		return field;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBigDecimalBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBigDecimalBeanTypeProxy.java
deleted file mode 100644
index 866b5e3..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBigDecimalBeanTypeProxy.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEBigDecimalBeanTypeProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-import java.math.*;
-
-final class IDEBigDecimalBeanTypeProxy extends IDENumberBeanTypeProxy {
-// Some values are cache'd for speed
-IDEBigDecimalBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass,new BigDecimal(0));
-}
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createBigDecimalBeanProxy(BigDecimal aBigDecimal) {
-	if ( aBigDecimal == null || aBigDecimal.intValue() == 0 ) {
-		return zeroProxy;
-	} else {
-		return new IDENumberBeanProxy(fProxyFactoryRegistry,aBigDecimal,this);
-	}
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBigIntegerBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBigIntegerBeanTypeProxy.java
deleted file mode 100644
index 8b91066..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBigIntegerBeanTypeProxy.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEBigIntegerBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-import java.math.*;
-/**
- * IDE Implementation of IIntegerBeanTypeProxy
- */
-final class IDEBigIntegerBeanTypeProxy extends IDENumberBeanTypeProxy {
-// Some values are cache'd for speed
-IDEBigIntegerBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new BigInteger("0")); //$NON-NLS-1$
-}
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createBigIntegerBeanProxy(BigInteger aBigInteger) {
-	if ( aBigInteger == null || aBigInteger.intValue() == 0 ) {
-		return zeroProxy;
-	} else {
-		return new IDENumberBeanProxy(fProxyFactoryRegistry,aBigInteger,this);
-	}
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanBeanProxy.java
deleted file mode 100644
index 853e0a1..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanBeanProxy.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEBooleanBeanProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * IDE Implementation of IBooleanBeanProxy..
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-class IDEBooleanBeanProxy extends IDEObjectBeanProxy implements IBooleanBeanProxy {
-	protected Boolean fBooleanValue;
-/**
- * As well as storing the bean store the boolean value so that we can return the booleanValue faster
- * without the need for repeated re-casting. It is package protected because it is created in
- * special way, so no one else should create these.
- * @param aBean java.lang.Object
- */
-IDEBooleanBeanProxy(IDEProxyFactoryRegistry aRegistry, Object aBean, IBeanTypeProxy aBeanTypeProxy) {
-	super(aRegistry, aBean,aBeanTypeProxy);
-	fBooleanValue = (Boolean)aBean;
-}
-public boolean booleanValue() {
-	return fBooleanValue.booleanValue();
-}
-public Boolean getBooleanValue() {
-	return fBooleanValue;
-}
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanBeanTypeProxy.java
deleted file mode 100644
index c06f941..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanBeanTypeProxy.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Sep 15, 2003
- *
- * To change the template for this generated file go to
- * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
- */
-package org.eclipse.jem.internal.proxy.ide;
-
-import org.eclipse.jem.internal.proxy.core.IBeanProxy;
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-
-/**
- * @author richkulp
- *
- * To change the template for this generated type comment go to
- * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
- */
-public class IDEBooleanBeanTypeProxy extends IDEBooleanBeanProxy {
-
-	/**
-	 * @param aRegistry
-	 * @param aBean
-	 * @param aBeanTypeProxy
-	 */
-	public IDEBooleanBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Object aBean, IBeanTypeProxy aBeanTypeProxy) {
-		super(aRegistry, aBean, aBeanTypeProxy);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		return (aBeanProxy instanceof IDEBooleanBeanTypeProxy) ? getBooleanValue() == ((IDEBooleanBeanTypeProxy) aBeanProxy).getBooleanValue() : false;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanClassBeanTypeProxy.java
deleted file mode 100644
index 41b31b4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanClassBeanTypeProxy.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEBooleanClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-final public class IDEBooleanClassBeanTypeProxy extends IDEBeanTypeProxy {
-
-	// Cache these instances. Since the BeanType proxies are cached also, only one instance
-	// of true/false will be in system.
-	protected final IDEBooleanBeanProxy trueProxy;
-	protected final IDEBooleanBeanProxy falseProxy;
-
-IDEBooleanClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-
-	super(aRegistry, aClass);
-	trueProxy = new IDEBooleanBeanProxy( fProxyFactoryRegistry, Boolean.TRUE, this );
-	falseProxy = new IDEBooleanBeanProxy( fProxyFactoryRegistry, Boolean.FALSE, this);	
-}
-IBooleanBeanProxy createBooleanBeanProxy(Boolean aBoolean) {
-	if ( aBoolean.booleanValue() ){
-		return trueProxy;
-	} else {
-		return falseProxy;
-	}
-}
-/* Specialized from IDEBeanTypeProxy to ensure IBooleanBeanProxies are created correctly
- */
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	if ( anObject == null || anObject == Boolean.FALSE ) {
-		return falseProxy;
-	} else {
-		return trueProxy;
-	}
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanTypeBeanTypeProxy.java
deleted file mode 100644
index 45f0fd0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEBooleanTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEBooleanTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-final public class IDEBooleanTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-
-	// Cache these instances. Since the BeanType proxies are cached also, only one instance
-	// of true/false will be in system.
-	protected final IDEBooleanBeanProxy trueProxy;
-	protected final IDEBooleanBeanProxy falseProxy;
-
-IDEBooleanTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-
-	super(aRegistry, aClass);
-	trueProxy = new IDEBooleanBeanTypeProxy( fProxyFactoryRegistry, Boolean.TRUE, this );
-	falseProxy = new IDEBooleanBeanTypeProxy( fProxyFactoryRegistry, Boolean.FALSE, this );
-	
-	// TODO Need to go through all of the primitives, separate them out into a separate classes so
-	// that sameAs can work with them correctly. Currently only boolean type will do sameAs correctly.
-	// Should also look into storing the primitive in the proxy instead of creating a new wrapper object
-	// for each for the non-boolean primitives.	
-}
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-IBooleanBeanProxy createBooleanBeanProxy(boolean aBoolean) {
-	if ( aBoolean ){
-		return trueProxy;
-	} else {
-		return falseProxy;
-	}
-}
-/* Specialized from IDEBeanTypeProxy to ensure IBooleanBeanProxies are created correctly
- */
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return (IIDEBeanProxy)createBooleanBeanProxy( anObject != null ? ((Boolean)anObject).booleanValue() : false );
-
-}
-int getPrimitiveType(){
-	return BOOLEAN;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEByteClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEByteClassBeanTypeProxy.java
deleted file mode 100644
index bcd682c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEByteClassBeanTypeProxy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEByteClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Byte BeanType Proxy.
- */
-final class IDEByteClassBeanTypeProxy extends IDENumberBeanTypeProxy {
-		
-protected IDEByteClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new Byte((byte)0));
-}
-INumberBeanProxy createByteBeanProxy(Byte aByte){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,aByte,this);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEByteTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEByteTypeBeanTypeProxy.java
deleted file mode 100644
index cb8c88a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEByteTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEByteTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Byte BeanType Proxy.
- */
-final class IDEByteTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-protected IDEByteTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-INumberBeanProxy createByteBeanProxy(byte aByte){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,new Byte(aByte),this);
-}
-int getPrimitiveType(){
-	return BYTE;
-}
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Number n = anObject instanceof Character ? new Byte((byte)((Character) anObject).charValue()) : (Number) anObject;
-	return new IDENumberBeanProxy(fProxyFactoryRegistry, n, this);
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECallbackRegistry.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECallbackRegistry.java
deleted file mode 100644
index e47d77b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECallbackRegistry.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDECallbackRegistry.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.io.*;
-import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
-
-public class IDECallbackRegistry implements ICallbackRegistry {
-	
-	IDEVMServer fVMServer;
-	int fNextCallbackID;
-	IDEProxyFactoryRegistry fProxyFactoryRegistry;
-	Map fCallbackIDToCallback = new HashMap(25);
-	Map fBeanProxyToCallbackID = new HashMap(25);
-	Map fCallbackIDToStream = new HashMap(25);
-	private IProxyMethod initializeCallbackMethodProxy;
-	private IBeanProxy vmServerProxy;
-	
-IDECallbackRegistry(IDEProxyFactoryRegistry aRegistry){
-	fProxyFactoryRegistry = aRegistry;
-	fVMServer = new IDEVMServer(this);
-	
-	vmServerProxy = aRegistry.getBeanProxy(fVMServer.getClass(), fVMServer);
-	
-	try {
-		Method initializeCallbackMethod = org.eclipse.jem.internal.proxy.common.ICallback.class.getMethod("initializeCallback", new Class[] {org.eclipse.jem.internal.proxy.common.IVMCallbackServer.class, Integer.TYPE}); //$NON-NLS-1$
-		initializeCallbackMethodProxy = (IProxyMethod) aRegistry.getBeanProxy(Method.class, initializeCallbackMethod);
-	} catch (SecurityException e) {
-		e.printStackTrace();
-	} catch (NoSuchMethodException e) {
-		e.printStackTrace();
-	}
-	
-}
-
-
-/**
- * Add a callback.  aBeanProxy is running on the target VM and ICallback runs on our VM
- * aBeanProxy will implement ICallback on the target side
- */	
-public void registerCallback(IBeanProxy aBeanProxy, ICallback aCallback){
-
-	// Get a handle to the remote VM callback	
-	org.eclipse.jem.internal.proxy.common.ICallback vmCallback = (org.eclipse.jem.internal.proxy.common.ICallback) ((IIDEBeanProxy)aBeanProxy).getBean(); 
-	fNextCallbackID = fNextCallbackID + 1;
-	int callbackID = fNextCallbackID;
-	vmCallback.initializeCallback(
-		fVMServer,
-		callbackID);
-	Integer callbackIntegerID = new Integer(callbackID);
-	fCallbackIDToCallback.put(callbackIntegerID,aCallback);
-	fBeanProxyToCallbackID.put(aBeanProxy,callbackIntegerID);
-
-}
-
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.proxy.core.ICallbackRegistry#registerCallback(org.eclipse.jem.internal.proxy.core.IProxy, org.eclipse.jem.internal.proxy.core.ICallback, org.eclipse.jem.internal.proxy.core.IExpression)
- */
-public void registerCallback(IProxy callbackProxy, final ICallback cb, IExpression expression) {
-	final Integer callbackID = new Integer(++fNextCallbackID);
-	fCallbackIDToCallback.put(callbackID, cb);
-	if (callbackProxy.isBeanProxy()) {
-		fBeanProxyToCallbackID.put(callbackProxy, callbackID);		
-	} else {
-		((ExpressionProxy) callbackProxy).addProxyListener(new ExpressionProxy.ProxyAdapter() {
-			public void proxyResolved(ProxyEvent event) {
-				fBeanProxyToCallbackID.put(event.getProxy(), callbackID);		
-			}
-		});
-	}
-	expression.createSimpleMethodInvoke(initializeCallbackMethodProxy, callbackProxy, new IProxy[] {vmServerProxy, fProxyFactoryRegistry.getBeanProxyFactory().createBeanProxyWith(callbackID.intValue())}, false);
-	
-}
-
-OutputStream requestStream(final int aCallbackID, final int aMsgID){
-	final PipedOutputStream result = new PipedOutputStream();
-	PipedInputStream tempStream = null;
-	try {
-		tempStream = new PipedInputStream(result);	
-	} catch ( IOException exc ) {
-		ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-		return null;
-	}
-	final PipedInputStream inputStream = tempStream;
-	Thread streamProcessor = new Thread(){
-		public void run(){
-			ICallback ideCallback = (ICallback)fCallbackIDToCallback.get(new Integer(aCallbackID));
-			if (ideCallback != null) {
-				try {
-					ideCallback.calledBackStream(aMsgID, inputStream);
-				} finally {
-					try {
-						inputStream.close();	// Make sure it's closed.
-					} catch ( IOException  exc ){
-						ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-					}
-				}			
-			}
-		}
-	};
-	streamProcessor.start();
-	return result;	
-}
-
-Object vmCallback(int aCallbackID ,int aMsgID, Object[] parms){
-	// Find the bean proxy that registered with the ID
-	ICallback ideCallback = (ICallback) fCallbackIDToCallback.get(new Integer(aCallbackID));
-	Object callbackResult = null;
-	if ( parms.length == 1 ) {
-		callbackResult = ideCallback.calledBack(aMsgID,(IBeanProxy)parms[0]);
-	} else {
-		callbackResult = ideCallback.calledBack(aMsgID,parms);
-	}
-	return callbackResult;
-}
-
-Object vmCallback(int aCallbackID ,int aMsgID, Object parm){
-	// Find the bean proxy that registered with the ID
-	ICallback ideCallback = (ICallback) fCallbackIDToCallback.get(new Integer(aCallbackID));
-	return ideCallback.calledBack(aMsgID,parm);
-}
-
-public void deregisterCallback(IBeanProxy aBeanProxy){
-	// Remove the callback from both maps.  The actual unregistering of the callback
-	// on the target VM is done separately by the object that added the event handler on the target VM
-	Integer callbackID = (Integer) fBeanProxyToCallbackID.remove(aBeanProxy);
-	fCallbackIDToCallback.remove(callbackID);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharTypeBeanTypeProxy.java
deleted file mode 100644
index cf86cfb..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDECharTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * char BeanType Proxy.
- */
-final class IDECharTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-protected IDECharTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-ICharacterBeanProxy createCharBeanProxy(char aChar){
-	return new IDECharacterBeanProxy(fProxyFactoryRegistry,new Character(aChar),this);
-}
-int getPrimitiveType(){
-	return CHAR;
-}
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Character c = anObject instanceof Character ? (Character) anObject : new Character((char)((Number) anObject).intValue());
-	return new IDECharacterBeanProxy(fProxyFactoryRegistry, c, this);
-	
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharacterBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharacterBeanProxy.java
deleted file mode 100644
index cf5b69b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharacterBeanProxy.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- * $RCSfile: IDECharacterBeanProxy.java,v $ $Revision: 1.6 $ $Date: 2005/08/24 20:39:06 $
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * IDE Implementation of ICharacterBeanBeanProxy..
- */
-class IDECharacterBeanProxy extends IDEObjectBeanProxy implements ICharacterBeanProxy {
-	protected Character fCharacterValue;
-	IDECharacterBeanProxy(IDEProxyFactoryRegistry aRegistry, Object aBean, IBeanTypeProxy aBeanTypeProxy) {
-		super(aRegistry, aBean, aBeanTypeProxy);
-		fCharacterValue = (Character) aBean;
-	}
-	public char charValue() {
-		return fCharacterValue.charValue();
-	}
-	public Character characterValue() {
-		return fCharacterValue;
-	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy#intValue()
-	 */
-	public int intValue() {
-		return charValue();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#byteValue()
-	 */
-	public byte byteValue() {
-		return (byte) charValue();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#doubleValue()
-	 */
-	public double doubleValue() {
-		return charValue();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#floatValue()
-	 */
-	public float floatValue() {
-		return charValue();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#longValue()
-	 */
-	public long longValue() {
-		return charValue();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#numberValue()
-	 */
-	public Number numberValue() {
-		// This is a kludge. Need to new one up.
-		return new Integer(charValue());
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.INumberBeanProxy#shortValue()
-	 */
-	public short shortValue() {
-		return (short) charValue();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharacterClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharacterClassBeanTypeProxy.java
deleted file mode 100644
index 1aadde0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDECharacterClassBeanTypeProxy.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDECharacterClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Char BeanType Proxy.
- */
-final class IDECharacterClassBeanTypeProxy extends IDEBeanTypeProxy {
-	
-protected IDECharacterClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-ICharacterBeanProxy createCharacterBeanProxy(Character aChar){
-	return new IDECharacterBeanProxy(fProxyFactoryRegistry,aChar,this);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEClassBeanTypeProxy.java
deleted file mode 100644
index eabe62c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEClassBeanTypeProxy.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IDEClassBeanTypeProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-package org.eclipse.jem.internal.proxy.ide;
-
-import org.eclipse.jem.internal.proxy.core.IBeanProxy;
- 
-/**
- * For java.lang.Class type.
- * @since 1.0.0
- */
-public class IDEClassBeanTypeProxy extends IDEBeanTypeProxy {
-
-	/**
-	 * @param aRegistry
-	 * @param aClass
-	 * 
-	 * @since 1.0.0
-	 */
-	public IDEClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-		super(aRegistry, aClass);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.ide.IDEBeanTypeProxy#newBeanProxy(java.lang.Object)
-	 */
-	protected IIDEBeanProxy newBeanProxy(Object anObject) {
-		return (IIDEBeanProxy) ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy((Class) anObject);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.ide.IDEBeanTypeProxy#newBeanTypeForClass(java.lang.Class)
-	 */
-	public IDEBeanTypeProxy newBeanTypeForClass(Class type) {
-		throw new UnsupportedOperationException();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance()
-	 */
-	public IBeanProxy newInstance() {
-		throw new UnsupportedOperationException();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance(java.lang.String)
-	 */
-	public IBeanProxy newInstance(String initializationString) {
-		throw new UnsupportedOperationException();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEConstructorProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEConstructorProxy.java
deleted file mode 100644
index bf594cf..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEConstructorProxy.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEConstructorProxy.java,v $
- *  $Revision: 1.10 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.lang.reflect.Constructor;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * This is an implementation of IConstructorProxy where the target VM is the same as
- * the IDE.  The java.lang.reflect.Constructor instance is held in a field
- */
-class IDEConstructorProxy extends IDEAccessibleObjectProxy implements IConstructorProxy {
-
-	/**
-	 * package protected constructor where the instance of java.lang.reflect.Constructor
-	 * can be passed in directly
-	 */
-	IDEConstructorProxy(IDEProxyFactoryRegistry aRegistry, Constructor aConstructor) {
-		super(aRegistry, aConstructor);
-	}
-	/**
-	 * The type proxy is constant proxy out of the method factory.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).constructorType;
-	}
-
-	/**
-	 * This is factored into a special method so that subclasses can override
-	 * if they wish.
-	 */
-	protected IBeanProxy getNewIDEBeanProxy(Object aBean) {
-
-		return IDEStandardBeanProxyFactory.createBeanProxy(fProxyFactoryRegistry, aBean); // Use local helper method to do this.
-	}
-	/**
-	 * Invoke the constructor and return an IDEBeanProxy with the result
-	 */
-	public IBeanProxy newInstance() {
-
-		// Invoke the constructor
-		try {
-			Object result = ((Constructor) getBean()).newInstance(null);
-			return getNewIDEBeanProxy(result);
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-			return null;
-		}
-
-	}
-	public IBeanProxy newInstanceCatchThrowableExceptions() {
-		return newInstance();
-	}
-	public IBeanProxy newInstanceCatchThrowableExceptions(IBeanProxy[] args) {
-		return newInstance(args);
-	}
-	/**
-	 * Invoke the constructor and return an IDEBeanProxy with the result
-	 */
-	public IBeanProxy newInstance(IBeanProxy[] creationArguments) {
-
-		// Get an array of bean objects from the bean proxy arguments
-		Object result = null;
-		Object[] creationObjects = new Object[creationArguments.length];
-		for (int i = 0; i < creationArguments.length; i++) {
-			// It is possible the arguments are null which is perfectly valid
-			if (creationArguments[i] != null)
-				creationObjects[i] = ((IIDEBeanProxy) creationArguments[i]).getBean();
-		}
-
-		// Invoke the constructor
-		try {
-			result = ((Constructor) getBean()).newInstance(creationObjects);
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-
-		// If we have a non-null result create an IDEBeanProxy and return it
-		if (result != null) {
-			return getNewIDEBeanProxy(result);
-		} else {
-			return null;
-		}
-
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IConstructorProxy#getParameterTypes()
-	 */
-	public IBeanTypeProxy[] getParameterTypes() {
-		Class[] parmClasses = ((Constructor) getBean()).getParameterTypes();
-		IBeanTypeProxy[] parmTypes = new IBeanTypeProxy[parmClasses.length];
-		IDEStandardBeanTypeProxyFactory factory = (IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		for (int i = 0; i < parmClasses.length; i++) {
-			parmTypes[i] = factory.getBeanTypeProxy(parmClasses[i]);
-		}
-		return parmTypes;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEConstructorTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEConstructorTypeProxy.java
deleted file mode 100644
index 48ac99a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEConstructorTypeProxy.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEConstructorTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * @version 	1.0
- * @author
- */
-public class IDEConstructorTypeProxy extends IDEBeanTypeProxy {
-	
-	IDEConstructorTypeProxy(IDEProxyFactoryRegistry registry) {
-		super(registry, java.lang.reflect.Constructor.class);
-	}
-
-	/*
-	 * @see IDEBeanTypeProxy#newBeanProxy(Object)
-	 */
-	protected IIDEBeanProxy newBeanProxy(Object anObject) {
-		return new IDEConstructorProxy(fProxyFactoryRegistry, (java.lang.reflect.Constructor) anObject);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEDoubleClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEDoubleClassBeanTypeProxy.java
deleted file mode 100644
index 4ca710c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEDoubleClassBeanTypeProxy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEDoubleClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Double BeanType Proxy.
- */
-final class IDEDoubleClassBeanTypeProxy extends IDENumberBeanTypeProxy {
-
-protected IDEDoubleClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new Double(0));
-}
-INumberBeanProxy createDoubleBeanProxy(Double aDouble){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,aDouble,this);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEDoubleTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEDoubleTypeBeanTypeProxy.java
deleted file mode 100644
index fbbad51..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEDoubleTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEDoubleTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * double BeanType Proxy.
- */
-final class IDEDoubleTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-protected IDEDoubleTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-INumberBeanProxy createDoubleBeanProxy(double aDouble){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,new Double(aDouble),this);
-}
-int getPrimitiveType(){
-	return DOUBLE;
-}
-
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Number n = anObject instanceof Character ? new Double(((Character) anObject).charValue()) : (Number) anObject;
-	return new IDENumberBeanProxy(fProxyFactoryRegistry, n, this);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEExpression.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEExpression.java
deleted file mode 100644
index ac88762..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEExpression.java
+++ /dev/null
@@ -1,1077 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * $RCSfile: IDEExpression.java,v $ $Revision: 1.12 $ $Date: 2005/08/24 20:39:06 $
- */
-package org.eclipse.jem.internal.proxy.ide;
-
-import java.util.*;
-
-import org.eclipse.core.runtime.Platform;
-
-import org.eclipse.jem.internal.proxy.common.MethodHelper;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
-import org.eclipse.jem.internal.proxy.initParser.tree.*;
-
-/**
- * IDE expression processing.
- * 
- * @since 1.0.0
- */
-public class IDEExpression extends Expression {
-
-	private final IDEStandardBeanTypeProxyFactory beantypefactory;
-	protected final ExpressionProcesser eproc;
-	{
-		boolean useTracing = !isTraceSet() ? 
-			"true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyLaunchSupport.EXPRESSION_TRACING)) : //$NON-NLS-1$
-			isTrace();
-		long threshold = Long.getLong(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyLaunchSupport.EXPRESSION_TRACEING_TIMER_THRESHOLD), -1L).longValue();
-		eproc = new ExpressionProcesser(useTracing, threshold);
-	}
-	
-
-	private void processExpressionError() throws ThrowableProxy, NoExpressionValueException {
-		if (!eproc.noErrors())
-			if (eproc.isNoExpressionValue())
-				throw (NoExpressionValueException) eproc.getErrorThrowable();
-			else {
-				Throwable t = eproc.getErrorThrowable();
-				if (t instanceof ThrowableProxy)
-					throw (ThrowableProxy) t;
-				else
-					throw new IDEThrowableProxy(eproc.getErrorThrowable(), beantypefactory.getBeanTypeProxy(t.getClass()));
-			}
-	}
-	
-	/**
-	 * Create the IDEExpression
-	 * 
-	 * @param registry
-	 * 
-	 * @since 1.0.0
-	 */
-	public IDEExpression(ProxyFactoryRegistry registry) {
-		super(registry);
-		beantypefactory = (IDEStandardBeanTypeProxyFactory) registry.getBeanTypeProxyFactory();
-	}
-
-	protected final IDEProxyFactoryRegistry getIDERegistry() {
-		return (IDEProxyFactoryRegistry) registry;
-	}
-
-	protected final IDEStandardBeanTypeProxyFactory getIDEBeanTypeFactory() {
-		return beantypefactory;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushToProxy(org.eclipse.jem.internal.proxy.core.IProxy)
-	 */
-	protected void pushToProxy(IProxy proxy) {
-		if (proxy == null)
-			eproc.pushExpression(null, MethodHelper.NULL_TYPE);
-		else if (proxy.isBeanProxy())
-			eproc.pushExpression(((IDEBeanProxy) proxy).getBean(), ((IDEBeanTypeProxy) ((IBeanProxy) proxy).getTypeProxy()).getTypeClass());
-		else
-			eproc.pushExpressionProxy(((ExpressionProxy) proxy).getProxyID());
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#closeProxy()
-	 */
-	protected void closeProxy() {
-		methodExpressionProxies = fieldExpressionProxies = null;
-		eproc.close();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pullProxyValue(int, java.util.List)
-	 */
-	protected IBeanProxy pullProxyValue(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException {
-		processExtensionProxies(proxycount, expressionProxies);
-		processExpressionError();
-		Object result[] = new Object[2];
-		eproc.pullValue(result);
-		IBeanProxy resultProxy = getIDERegistry().getBeanProxy((Class) result[1], result[0]);
-		return resultProxy;
-	}
-	
-	private void processExtensionProxies(int proxycount, List expressionProxies) {
-		if (proxycount > 0) {
-			int len = expressionProxies.size();
-			Object[] proxyResolution = new Object[2];
-			for (int i = 0; i < len; i++) {
-				ExpressionProxy ep = (ExpressionProxy) expressionProxies.get(i);
-				if (ep != null) {
-					try {
-						eproc.pullExpressionProxyValue(ep.getProxyID(), proxyResolution);
-						if (proxyResolution[1] != Void.TYPE)
-							fireProxyResolved(ep, getIDERegistry().getBeanProxy((Class) proxyResolution[1], proxyResolution[0]));
-						else
-							fireProxyVoid(ep);
-					} catch (NoExpressionValueException e) {
-						fireProxyNotResolved(ep);
-					}
-				}
-			}
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushCastToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushCastToProxy(IProxyBeanType type) {
-		try {
-			eproc.pushCast(getIDEBeanTypeProxy(type).getTypeClass());
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushInstanceofToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushInstanceofToProxy(IProxyBeanType type) {
-		try {
-			eproc.pushInstanceof(getIDEBeanTypeProxy(type).getTypeClass());
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-	
-	/**
-	 * Get the BeanType proxy and test if valid. Throw ThrowableProxy if not valid.
-	 * 
-	 * @param type 
-	 * @return 
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.0.0
-	 */
-	protected IDEBeanTypeProxy getIDEBeanTypeProxy(IProxyBeanType type) throws ThrowableProxy {
-		IDEBeanTypeProxy typeProxy;
-		if (type.isExpressionProxy()) {
-			// It should already be resolved at this point.
-			typeProxy = ((IDEBeanTypeExpressionProxy) type).getBeanTypeProxy();
-		} else
-			typeProxy = (IDEBeanTypeProxy) type;
-		if (!typeProxy.isValid()) {
-			throw new IDEThrowableProxy(
-					new Exception(typeProxy.getInitializationError()),
-					getIDEBeanTypeFactory().getBeanTypeProxy(Exception.class));
-		} else
-			return typeProxy;
-	}
-
-	
-	/**
-	 * Get the BeanType proxy and test if valid. Throw ThrowableProxy if not valid.
-	 * @param type
-	 * @return
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IDEBeanTypeProxy getIDEBeanTypeProxy(String type) throws ThrowableProxy {
-		return (IDEBeanTypeProxy) registry.getBeanTypeProxyFactory().getBeanTypeProxy(type);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushPrefixToProxy(org.eclipse.jem.internal.proxy.initParser.tree.PrefixOperator)
-	 */
-	protected void pushPrefixToProxy(PrefixOperator operator) {
-		eproc.pushPrefix(operator);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushInfixToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InfixOperator, org.eclipse.jem.internal.proxy.initParser.tree.InternalInfixOperandType)
-	 */
-	protected void pushInfixToProxy(InfixOperator operator, InternalInfixOperandType operandType) {
-		eproc.pushInfix(operator, operandType);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushArrayAccessToProxy(int)
-	 */
-	protected void pushArrayAccessToProxy(int indexCount) {
-		eproc.pushArrayAccess(indexCount);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushArrayCreationToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType, int)
-	 */
-	protected void pushArrayCreationToProxy(IProxyBeanType type, int dimensionCount) {
-		try {
-			eproc.pushArrayCreation(getIDEBeanTypeProxy(type).getTypeClass(), dimensionCount);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-
-	protected void pushArrayInitializerToProxy(IProxyBeanType type, int stripCount, int expressionCount) {
-		try {
-			eproc.pushArrayInitializer(getIDEBeanTypeProxy(type).getTypeClass(), stripCount, expressionCount);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushClassInstanceCreationToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType, int)
-	 */
-	protected void pushClassInstanceCreationToProxy(IProxyBeanType type, int argumentCount) {
-		try {
-			eproc.pushClassInstanceCreation(getIDEBeanTypeProxy(type).getTypeClass(), argumentCount);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTypeReceiverToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushTypeReceiverToProxy(IProxyBeanType type) {
-		try {
-			Class c = getIDEBeanTypeProxy(type).getTypeClass();
-			eproc.pushExpression(c, c);	// When as a receiver, the type is the same as the receiver. 
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		} catch (RuntimeException e) {
-			eproc.processException(e);
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushFieldAccessToProxy(java.lang.Object, boolean)
-	 */
-	protected void pushFieldAccessToProxy(Object field, boolean hasReceiver) {
-		boolean isString = field instanceof String;
-		try {
-			eproc.pushFieldAccess(isString ? field : getIDEFieldProxy((IProxyField) field).getBean(), isString, hasReceiver);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}		
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushMethodInvocationToProxy(java.lang.Object, boolean, int)
-	 */
-	protected void pushMethodInvocationToProxy(Object method, boolean hasReceiver, int argCount) {
-		boolean isString = method instanceof String;
-		try {
-			eproc.pushMethodInvocation(isString ? method : getIDEMethodProxy((IProxyMethod) method).getBean(), isString, hasReceiver, argCount);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushConditionalToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InternalConditionalOperandType)
-	 */
-	protected void pushConditionalToProxy(InternalConditionalOperandType expressionType) {
-		eproc.pushConditional(expressionType);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushInvoke()
-	 */
-	protected void pushInvoke(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException {
-		// In the IDE case do nothing. Nothing is pending. But still need to handle proxy resolution.
-		processExtensionProxies(proxycount, expressionProxies);
-		processExpressionError(); 
-	}
-	
-	/**
-	 * This is used as both an ExpressionProxy (i.e. IDE side) and the Expressions expression proxy result on the other side.
-	 * This makes it easier to just use same instance on both sides.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static class IDEExpressionProxy extends ExpressionProxy implements InternalExpressionProxy {
-		
-		protected IDEExpressionProxy(int proxyid, int proxyType, Expression expression) {
-			super(proxyid, proxyType, expression);
-		}
-		
-		private Object value;
-		private Class type;
-		private boolean set;
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#dispose()
-		 */
-		protected void dispose() {
-			super.dispose();
-			value = null;
-			type = null;
-			set = false;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getType()
-		 */
-		public Class getType() {
-			return type;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getValue()
-		 */
-		public Object getValue() {
-			return value;
-		}
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#setProxy(java.lang.Object, java.lang.Class)
-		 */
-		public void setProxy(Object value, Class type) {
-			this.value = value;
-			this.type = type;
-			set = true;
-		}
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#isSet()
-		 */
-		public boolean isSet() {
-			return set;
-		}
-	}
-	
-	/**
-	 * The Expression proxy for IDE BeanTypes.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static class IDEBeanTypeExpressionProxy extends IDEExpressionProxy implements IBeanTypeExpressionProxy {
-		
-		private String typeName;
-		private IDEBeanTypeProxy resolvedProxy;
-
-		/**
-		 * @param proxyid
-		 * 
-		 * @since 1.1.0
-		 */
-		public IDEBeanTypeExpressionProxy(int proxyid, Expression expression) {
-			super(proxyid, BEANTYPE_EXPRESSION_PROXY, expression);
-		}
-		
-		/*
-		 *  (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeExpressionProxy#setTypeName(java.lang.String)
-		 */
-		public void setTypeName(String typeName) {
-			this.typeName = typeName;
-		}
-		
-		/*
-		 *  (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getTypeName()
-		 */
-		public String getTypeName() {
-			return typeName;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString()
-		 */
-		public String toString() {
-			return super.toString()+" - "+getTypeName(); //$NON-NLS-1$
-		}
-
-		/**
-		 * Called by IDEExpression to resolve the beantype.
-		 * @param beantypeProxy
-		 * 
-		 * @since 1.1.0
-		 */
-		void setProxy(IDEBeanTypeProxy beantypeProxy) {
-			this.resolvedProxy = beantypeProxy;
-			setProxy(resolvedProxy.getTypeClass(), Class.class);
-		}
-		
-		/**
-		 * Called by IDEExpression to get the resolved beantype proxy.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		IDEBeanTypeProxy getBeanTypeProxy() {
-			return resolvedProxy;
-		}
-
-		/*
-		 *  (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-		 */
-		public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameterTypes) {
-			IProxyMethod method = ((IDEExpression) expression).getMethodExpressionProxy(this, methodName, parameterTypes);
-			if (method == null) {
-				// Need to go to the expression and create it.
-				method = ((Expression) expression).createMethodExpressionProxy(this, methodName, parameterTypes);
-			}
-			return method;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String[])
-		 */
-		public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes) {
-			return ((IDEMethodProxyFactory) expression.getRegistry().getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes);
-		}
-		
-		public IProxyMethod getMethodProxy(IExpression expression, String methodName) {
-			return getMethodProxy(expression, methodName, (IProxyBeanType[]) null);
-		}
-
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String)
-		 */
-		public IProxyField getFieldProxy(IExpression expression, String fieldName) {
-			IProxyField field = ((IDEExpression) expression).getFieldExpressionProxy(this, fieldName);
-			if (field == null) {
-				// Need to go to the expression and create it.
-				field = ((Expression) expression).createFieldExpressionProxy(this, fieldName);
-			}
-			return field;
-		}
-	}
-	
-	/**
-	 * The Expression proxy for IDE BeanTypes.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected static class IDEMethodExpressionProxy extends IDEExpressionProxy implements IProxyMethod {
-		
-		private String methodName;
-		private IDEMethodProxy resolvedProxy;
-		private ThrowableProxy errorThrowable;
-
-		/**
-		 * @param proxyid
-		 * 
-		 * @since 1.1.0
-		 */
-		public IDEMethodExpressionProxy(int proxyid, Expression expression) {
-			super(proxyid, METHOD_EXPRESSION_PROXY, expression);
-		}
-		
-		/**
-		 * Set by IDEExpression with the method name.
-		 * @param methodName
-		 * 
-		 * @since 1.1.0
-		 */
-		void setMethodName(String methodName) {
-			this.methodName = methodName;
-		}
-				
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString()
-		 */
-		public String toString() {
-			return super.toString()+" - "+methodName; //$NON-NLS-1$
-		}
-
-		/**
-		 * Called by IDEExpression to resolve the beantype.
-		 * @param methodProxy
-		 * 
-		 * @since 1.1.0
-		 */
-		void setProxy(IDEMethodProxy methodProxy) {
-			this.resolvedProxy = methodProxy;
-			setProxy(resolvedProxy.getBean(), Class.class);
-		}
-		
-		/**
-		 * Called by IDEExpression to say there was error in creating the proxy.
-		 * @param errorThrowable
-		 * 
-		 * @since 1.1.0
-		 */
-		void setThrowable(ThrowableProxy errorThrowable) {
-			this.errorThrowable = errorThrowable;
-		}
-		
-		/**
-		 * Called by IDEExpression to get the resolved method proxy.
-		 * @return
-		 * @throws ThrowableProxy
-		 * 
-		 * @since 1.1.0
-		 */
-		IDEMethodProxy getMethodProxy() throws ThrowableProxy {
-			if (errorThrowable != null)
-				throw errorThrowable;
-			return resolvedProxy;
-		}
-	}
-	
-	protected static class IDEFieldExpressionProxy extends IDEExpressionProxy implements IProxyField {
-		
-		private String fieldName;
-		private IDEFieldProxy resolvedProxy;
-		private ThrowableProxy errorThrowable;
-
-		/**
-		 * @param proxyid
-		 * 
-		 * @since 1.1.0
-		 */
-		public IDEFieldExpressionProxy(int proxyid, Expression expression) {
-			super(proxyid, FIELD_EXPRESSION_PROXY, expression);
-		}
-		
-		/**
-		 * Set by IDEExpression with the method name.
-		 * @param fieldName
-		 * 
-		 * @since 1.1.0
-		 */
-		void setField(String fieldName) {
-			this.fieldName = fieldName;
-		}
-				
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString()
-		 */
-		public String toString() {
-			return super.toString()+" - "+fieldName; //$NON-NLS-1$
-		}
-
-		/**
-		 * Called by IDEExpression to resolve the beantype.
-		 * @param fieldProxy
-		 * 
-		 * @since 1.1.0
-		 */
-		void setProxy(IDEFieldProxy fieldProxy) {
-			this.resolvedProxy = fieldProxy;
-			setProxy(resolvedProxy.getBean(), Class.class);
-		}
-		
-		/**
-		 * Called by IDEExpression to say there was error in creating the proxy.
-		 * @param errorThrowable
-		 * 
-		 * @since 1.1.0
-		 */
-		void setThrowable(ThrowableProxy errorThrowable) {
-			this.errorThrowable = errorThrowable;
-		}
-		
-		/**
-		 * Called by IDEExpression to get the resolved field proxy.
-		 * @return
-		 * @throws ThrowableProxy
-		 * 
-		 * @since 1.1.0
-		 */
-		IDEFieldProxy getFieldProxy() throws ThrowableProxy {
-			if (errorThrowable != null)
-				throw errorThrowable;
-			return resolvedProxy;
-		}
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#createExpressionProxy(int, int)
-	 */
-	protected ExpressionProxy createExpressionProxy(int proxyType, int proxyID) {
-		switch (proxyType) {
-			case NORMAL_EXPRESSION_PROXY:
-			default:
-				return new IDEExpressionProxy(proxyID, NORMAL_EXPRESSION_PROXY, this);
-			
-			case BEANTYPE_EXPRESSION_PROXY:
-				return new IDEBeanTypeExpressionProxy(proxyID, this);
-				
-			case METHOD_EXPRESSION_PROXY:
-				return new IDEMethodExpressionProxy(proxyID, this);
-				
-			case FIELD_EXPRESSION_PROXY:
-				return new IDEFieldExpressionProxy(proxyID, this);
-		}
-		
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushAssignmentToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy)
-	 */
-	protected void pushAssignmentToProxy(ExpressionProxy proxy) {
-		eproc.pushAssignment((InternalExpressionProxy) proxy);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushAssignmentToProxy()
-	 */
-	protected void pushAssignmentToProxy() {
-		eproc.pushAssignment();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockBeginToProxy(int)
-	 */
-	protected void pushBlockBeginToProxy(int blockNumber) {
-		eproc.pushBlockBegin(blockNumber);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockEndToProxy(int)
-	 */
-	protected void pushBlockEndToProxy(int blockNumber) {
-		eproc.pushBlockEnd(blockNumber);
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockBreakToProxy(int)
-	 */
-	protected void pushBlockBreakToProxy(int blockNumber) {
-		eproc.pushBlockBreak(blockNumber);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryBeginToProxy(int)
-	 */
-	protected void pushTryBeginToProxy(int tryNumber) {
-		eproc.pushTryBegin(tryNumber);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryCatchClauseToProxy(int, org.eclipse.jem.internal.proxy.core.IProxyBeanType, org.eclipse.jem.internal.proxy.core.ExpressionProxy)
-	 */
-	protected void pushTryCatchClauseToProxy(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep) {
-		try {
-			eproc.pushTryCatchClause(tryNumber, getIDEBeanTypeProxy(exceptionType).getTypeClass(), (InternalExpressionProxy) ep);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryFinallyClauseToProxy(int)
-	 */
-	protected void pushTryFinallyClauseToProxy(int tryNumber) {
-		eproc.pushTryFinallyClause(tryNumber);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryEndToProxy(int)
-	 */
-	protected void pushTryEndToProxy(int tryNumber) {
-		eproc.pushTryEnd(tryNumber);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushThrowToProxy()
-	 */
-	protected void pushThrowToProxy() {
-		eproc.pushThrowException();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushRethrowToProxy(int)
-	 */
-	protected void pushRethrowToProxy(int tryNumber) {
-		eproc.pushTryRethrow(tryNumber);
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushBeanTypeToProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeExpressionProxy)
-	 */
-	protected void pushBeanTypeToProxy(IBeanTypeExpressionProxy proxy) {
-		try {
-			IDEBeanTypeExpressionProxy ep = (IDEBeanTypeExpressionProxy) proxy;
-			IDEBeanTypeProxy typeProxy = getIDEBeanTypeProxy(proxy.getTypeName());
-			ep.setProxy(typeProxy);
-			eproc.allocateExpressionProxy(ep);
-			if (!typeProxy.isValid()) {
-				Throwable cause = ((IDEInitErrorBeanTypeProxy) typeProxy).getCause();
-				if (cause == null)
-					throw new IDEThrowableProxy(
-							new Exception(typeProxy.getInitializationError()),
-							getIDEBeanTypeFactory().getBeanTypeProxy(Exception.class));
-				else
-					throw new IDEThrowableProxy(
-							cause,
-							getIDEBeanTypeFactory().getBeanTypeProxy(cause.getClass()));
-
-			}
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-	
-	/**
-	 * Get the map of IProxyBeanTypes for a beantype name. Meant to be used only in conjunction with IDEStandardBeanTypeFactory.
-	 * It is here so the IDDEStandardBeanTypeFactory can store pending proxies per expression.
-	 * 
-	 * @param beanType
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyBeanType getBeanType(String beanTypeName) {
-		if (beanTypeCache == null)
-			beanTypeCache = new HashMap();
-		return (IProxyBeanType) beanTypeCache.get(beanTypeName);
-	}
-	
-	/**
-	 * Add the beantype expression proxy to the map of bean type expression proxies. Used in conjunction with IDEStandardBeanTypeFactory.
-	 * It is here so the IDEStandardBeanTypeFactory can store pending proxies per expression.
-	 * @param beanTypeName
-	 * @param beantype
-	 * 
-	 * @since 1.1.0
-	 */
-	public void addBeanType(String beanTypeName, IProxyBeanType beantype) {
-		beanTypeCache.put(beanTypeName, beantype);
-	}
-	
-	/**
-	 * Remove the beantype expression proxy from the map. This is called because there was a rollback due to an endmark.
-	 * @param beanTypeName
-	 * 
-	 * @since 1.1.0
-	 */
-	public void removeBeanType(String beanTypeName) {
-		beanTypeCache.remove(beanTypeName);
-	}
-
-	/**
-	 * Keeping a local map of Method Expression Proxies so that we don't keep recreating them for each request from within this expression.
-	 * The map will be:  declaringTypeName->(Map) methodName or IDEMethodKey -> method expression proxy. 
-	 * @see IDEExpression#pushMethodToProxy(ExpressionProxy, IProxyBeanType, String, IProxyBeanType[]) for the actual implementation. 
-	 */
-	protected Map methodExpressionProxies;
-	
-	/**
-	 * Keeping a local map of Field Expression Proxies so that we don't keep recreating them for each request from within this expression.
-	 * The map will be:  declaringTypeName->(Map) fieldname -> field expression proxy. 
-	 * @see IDEExpression#pushFieldToProxy(ExpressionProxy, IProxyBeanType, String) 
-	 */
-	protected Map fieldExpressionProxies;
-	
-	/**
-	 * Keeping a local map of BeanType expression proxies so that we don't keep recreating them for each request from within this expression.
-	 * The map will be: typename->beanTypeExpressionProxy
-	 */
-	protected Map beanTypeCache;	// Use to cache pending BeanTypes. Used in conjunction with IDEStandardBeanTypeFactory.
-
-	/*
-	 * Used as the key to the methodCache when there are parms.
-	 * It allows the parms to be either IProxyBeanType without the
-	 * overhead of creating complicated strings.
-	 * 
-	 * It will compare method name and each individual parm name without fluffing
-	 * up a string and building it up.
-	 * 
-	 * For no parm methods, just the name of the method as a string will be the key.
-	 * 
-	 * @since 1.1.0
-	 */
-	private static class MethodKey {
-		public String methodName;
-		public IProxyBeanType[] parmTypes;
-		public MethodKey(String methodName, IProxyBeanType[] parmTypes) {
-			this.methodName = methodName;
-			this.parmTypes = parmTypes;
-		}
-				
-				
-		/* (non-Javadoc)
-		 * @see java.lang.Object#equals(java.lang.Object)
-		 */
-		public boolean equals(Object obj) {
-			if (this == obj)
-				return true;
-			try {
-				return ((MethodKey) obj).compareParms(parmTypes);
-			} catch (ClassCastException e) {
-				return false;
-			}
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#hashCode()
-		 */
-		public int hashCode() {
-			int h = methodName.hashCode();;
-			for (int i = 0; i < parmTypes.length; i++) {
-				h += parmTypes[i].getTypeName().hashCode();
-			}
-			return h;
-		}
-				
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(java.lang.String[])
-		 */
-		protected boolean compareParms(IProxyBeanType[] parms) {
-			if (parms.length != parmTypes.length)
-				return false;
-			for (int i = 0; i < parms.length; i++) {
-				if (!parmTypes[i].getTypeName().equals(parms[i].getTypeName()))
-					return false;
-			}
-			return true;
-		}		
-	}
-
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushMethodToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy, org.eclipse.jem.internal.proxy.core.IProxyBeanType, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[])
-	 */
-	protected void pushMethodToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes) {
-		try {
-			final Map methods = getMethods(declaringType);
-			final Object key = getMethodKey(methodName, parameterTypes); 
-			methods.put(key, proxy);
-			proxy.addProxyListener(new ExpressionProxy.ProxyAdapter() {
-			
-				public void proxyNotResolved(ProxyEvent event) {
-					methods.remove(key);	// Back it out. tis could happen due to endmark rollback.
-				}
-			
-			});
-			
-			IDEMethodExpressionProxy ep = (IDEMethodExpressionProxy) proxy;
-			ep.setMethodName(methodName);
-			// We resolve immediately. Any expression proxies should also be resolved at this point too.
-			Class declaringClass = getIDEBeanTypeProxy(declaringType).getTypeClass();
-			Class[] parameterClasses;
-			if (parameterTypes == null || parameterTypes.length == 0)
-				parameterClasses = null;
-			else {
-				parameterClasses = new Class[parameterTypes.length];
-				for (int i = 0; i < parameterClasses.length; i++) {
-					parameterClasses[i] = getIDEBeanTypeProxy(parameterTypes[i]).getTypeClass();
-				}
-			}
-			IDEMethodProxy methodProxy = ((IDEMethodProxyFactory) registry.getMethodProxyFactory()).getMethodProxy(declaringClass, methodName, parameterClasses);
-			if (methodProxy == null) {
-				String parms = ""; //$NON-NLS-1$
-				if (parameterTypes != null && parameterTypes.length > 0) {
-					StringBuffer st = new StringBuffer(100);
-					for (int i = 0; i < parameterClasses.length; i++) {
-						if (i > 0)
-							st.append(',');
-						st.append(parameterTypes[i].getTypeName());
-					}
-					parms = st.toString();
-				}
-				throw new IDEThrowableProxy(new NoSuchMethodException("No method: "+declaringType+'.'+methodName+"("+parms+')'), //$NON-NLS-1$ //$NON-NLS-2$
-					getIDEBeanTypeFactory().getBeanTypeProxy(NoSuchMethodException.class));
-			}
-			
-			ep.setProxy(methodProxy);
-			eproc.allocateExpressionProxy(ep);
-		} catch (ThrowableProxy e) {
-			((IDEMethodExpressionProxy) proxy).setThrowable(e);	// So we don't recreate throwable all of the time.
-			eproc.processException(e);
-		}		
-	}
-	
-	private Map getMethods(IProxyBeanType classtype) {
-		if (methodExpressionProxies == null)
-			methodExpressionProxies = new HashMap();
-		Map methods = (Map) methodExpressionProxies.get(classtype.getTypeName());
-		if (methods == null)
-			methodExpressionProxies.put(classtype.getTypeName(), methods = new HashMap());
-		return methods;
-	}
-	
-	private Object getMethodKey(String methodName, IProxyBeanType[] parameterTypes) {
-		if (parameterTypes == null || parameterTypes.length == 0)
-			return methodName;
-		else
-			return new MethodKey(methodName, parameterTypes);
-	}
-	
-	private Map getFields(IProxyBeanType classtype) {
-		if (fieldExpressionProxies == null)
-			fieldExpressionProxies = new HashMap();
-		Map fields = (Map) fieldExpressionProxies.get(classtype.getTypeName());
-		if (fields == null)
-			fieldExpressionProxies.put(classtype.getTypeName(), fields = new HashMap());
-		return fields;
-	}
-	
-	/**
-	 * This is used by IDEBeanTypes and IDEBeanTypeExpressionProxy to access any already created Method Expression Proxies.
-	 * 
-	 * @param declaringType
-	 * @param methodName
-	 * @param parameterTypes
-	 * @return IProxyMethod or <code>null</code> if not yet created.
-	 * 
-	 * @since 1.1.0
-	 */
-	IProxyMethod getMethodExpressionProxy(IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes) {
-		Map methods = getMethods(declaringType);
-		Object key = getMethodKey(methodName, parameterTypes); 
-		return (IProxyMethod) methods.get(key);
-	}
-	
-	/**
-	 * This is used by IDEBeanTypes and IDEBeanTypeExpressionProxy to access any already created Field Expression Proxies.
-	 * @param declaringType
-	 * @param fieldName
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	IProxyField getFieldExpressionProxy(IProxyBeanType declaringType, String fieldName) {
-		Map fields = getFields(declaringType);
-		return (IProxyField) fields.get(fieldName);
-	}
-	
-	/**
-	 * Get the IDEMethodProxy out of the already resolved Expression Proxy or IDEMethodProxy itself.
-	 * @param method
-	 * @return
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IDEMethodProxy getIDEMethodProxy(IProxyMethod method) throws ThrowableProxy {
-		IDEMethodProxy methodProxy;
-		if (method.isExpressionProxy()) {
-			// It should already be resolved at this point.
-			methodProxy = ((IDEMethodExpressionProxy) method).getMethodProxy();
-		} else
-			methodProxy = (IDEMethodProxy) method;
-		return methodProxy;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushFieldToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy, org.eclipse.jem.internal.proxy.core.IProxyBeanType, java.lang.String)
-	 */
-	protected void pushFieldToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, final String fieldName) {
-
-		try {
-			final Map fields = getFields(declaringType);
-			fields.put(fieldName, proxy);
-			proxy.addProxyListener(new ExpressionProxy.ProxyAdapter(){
-				public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
-					fields.remove(fieldName);	// this can happen due to an endmark. It could be one of the ones that are rolled back.
-				}
-			});
-			
-			
-			IDEFieldExpressionProxy ep = (IDEFieldExpressionProxy) proxy;
-			// We resolve immediately. Any expression proxies should also be resolved at this point too.
-			IDEFieldProxy fieldProxy = (IDEFieldProxy) getIDEBeanTypeProxy(declaringType).getFieldProxy(fieldName);
-			if (fieldProxy == null) {
-			throw new IDEThrowableProxy(new NoSuchFieldException("No field: "+declaringType+'.'+fieldName), //$NON-NLS-1$
-					getIDEBeanTypeFactory().getBeanTypeProxy(NoSuchFieldException.class));
-			}
-			
-			ep.setProxy(fieldProxy);
-			eproc.allocateExpressionProxy(ep);
-		} catch (ThrowableProxy e) {
-			((IDEFieldExpressionProxy) proxy).setThrowable(e);	// So we don't recreate throwable all of the time.
-			eproc.processException(e);
-		}		
-
-	}
-	
-	/**
-	 * Get the IDEFieldProxy out of the already resolved Expression Proxy or IDEFieldProxy itself.
-	 * @param field
-	 * @return
-	 * @throws ThrowableProxy
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IDEFieldProxy getIDEFieldProxy(IProxyField field) throws ThrowableProxy {
-		IDEFieldProxy fieldProxy;
-		if (field.isExpressionProxy()) {
-			// It should already be resolved at this point.
-			fieldProxy = ((IDEFieldExpressionProxy) field).getFieldProxy();
-		} else
-			fieldProxy = (IDEFieldProxy) field;
-		return fieldProxy;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushIfTestToProxy()
-	 */
-	protected void pushIfTestToProxy() {
-		eproc.pushIfElse();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushIfElseToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InternalIfElseOperandType)
-	 */
-	protected void pushIfElseToProxy(InternalIfElseOperandType clauseType) {
-		eproc.pushIfElse(clauseType);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.Expression#pushNewInstanceToProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType)
-	 */
-	protected void pushNewInstanceToProxy(String initializationString, IProxyBeanType resultType) {
-		try {
-			eproc.pushNewInstanceFromString(initializationString, getIDEBeanTypeProxy(resultType).getTypeClass(), getIDERegistry().fClassLoader);
-		} catch (ThrowableProxy e) {
-			eproc.processException(e);
-		}
-	}
-
-	protected void pushMarkToProxy(int markID) {
-		eproc.pushMark(markID);
-	}
-
-	protected void pushEndmarkToProxy(int markID, boolean restore) {
-		eproc.pushEndmark(markID, restore);
-	}
-
-	protected void pushBeginTransferThreadToProxy() {
-		// For IDE it doesn't matter. Just go ahead and continue processing.
-	}
-
-	protected void pushTransferThreadToProxy() {
-		// For IDE it doesn't matter. Just go ahead and continue processing.
-	}
-
-	protected void pushSubexpressionBeginToProxy(int subexpressionNumber) {
-		eproc.pushSubexpressionBegin(subexpressionNumber);
-	}
-
-	protected void pushSubexpressionEndToProxy(int subexpressionNumber) {
-		eproc.pushSubexpressionEnd(subexpressionNumber);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEExtensionBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEExtensionBeanTypeProxyFactory.java
deleted file mode 100644
index 581b25a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEExtensionBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEExtensionBeanTypeProxyFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-public interface IDEExtensionBeanTypeProxyFactory extends IBeanTypeProxyFactory {
-
-public IDEBeanTypeProxy getExtensionBeanTypeProxy(String className);
-
-public IDEBeanTypeProxy getExtensionBeanTypeProxy(String typeName, IBeanTypeProxy superType);	
-
-public IProxyBeanType getExtensionBeanTypeProxy(String typeName, IExpression expression);
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFieldProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFieldProxy.java
deleted file mode 100644
index d254188..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFieldProxy.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEFieldProxy.java,v $
- *  $Revision: 1.9 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.lang.reflect.Field;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Implementation of IFieldProxy where the bean vm is the same as the IDE
- * Therefore we hold the instance of a java.lang.reflect.Field in a field
- * directly and have a package protected constructor to set this
- * Creation date: (1/17/00 12:32:24 PM)
- * @author: Joe Winchester
- */
-public class IDEFieldProxy extends IDEAccessibleObjectProxy implements IFieldProxy {
-	protected IBeanTypeProxy fFieldType;
-	/**
-	 * Package protected constructor that takes the field directly
-	 * This is package protected because only classes in the IDE package can construct
-	 * this.  Everyone else must go via the typeProxy
-	 */
-	IDEFieldProxy(IDEProxyFactoryRegistry aRegistry, Field aField) {
-		super(aRegistry, aField);
-	}
-	/**
-	 * Get the value of the field and return it wrapped in a bean proxy
-	 */
-	public IBeanProxy get(IBeanProxy aSubject) {
-
-		Object result = null;
-		// Get the field value and catch any errors	
-		try {
-			result = ((Field) getBean()).get(aSubject != null ? ((IIDEBeanProxy) aSubject).getBean() : null);
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-
-		// If we have a non null result wrap it in an IBeanProxy and return it
-		if (result != null) {
-			return fProxyFactoryRegistry.getBeanProxy(((Field) getBean()).getType(), result);
-		} else {
-			return null;
-		}
-
-	}
-	/**
-	 * Get the beans from both of the proxies and invoke the field set method
-	 * Cast to IDEBeanProxy and use package protected method
-	 */
-	public void set(IBeanProxy aSubject, IBeanProxy argument) {
-
-		// Set the field value and catch any errors	
-		try {
-			((Field) getBean()).set(
-				aSubject != null ? ((IIDEBeanProxy) aSubject).getBean() : null,
-				argument != null ? ((IIDEBeanProxy) argument).getBean() : null);
-		} catch (Exception e) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-	}
-	/**
-	 * The type proxy is constant proxy out of the method factory.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).fieldType;
-	}
-	/**
-	 * Return the type of the field.
-	 */
-	public IBeanTypeProxy getFieldType() {
-		if (fFieldType == null) {
-			fFieldType =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(
-					((Field) getBean()).getType());
-		}
-		return fFieldType;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFieldTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFieldTypeProxy.java
deleted file mode 100644
index 9e8c9ef..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFieldTypeProxy.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEFieldTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-/**
- * @version 	1.0
- * @author
- */
-public class IDEFieldTypeProxy extends IDEBeanTypeProxy {
-	
-	IDEFieldTypeProxy(IDEProxyFactoryRegistry registry) {
-		super(registry, java.lang.reflect.Field.class);
-	}
-
-	/*
-	 * @see IDEBeanTypeProxy#newBeanProxy(Object)
-	 */
-	protected IIDEBeanProxy newBeanProxy(Object anObject) {
-		return new IDEFieldProxy(fProxyFactoryRegistry, (java.lang.reflect.Field) anObject);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFloatClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFloatClassBeanTypeProxy.java
deleted file mode 100644
index 3dd912c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFloatClassBeanTypeProxy.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEFloatClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Float BeanType Proxy.
- */
-final class IDEFloatClassBeanTypeProxy extends IDENumberBeanTypeProxy {
-
-protected IDEFloatClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new Float(0));
-}
-INumberBeanProxy createFloatBeanProxy(Float aFloat){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,aFloat,this);
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFloatTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFloatTypeBeanTypeProxy.java
deleted file mode 100644
index 501c698..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEFloatTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEFloatTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Float BeanType Proxy.
- */
-final class IDEFloatTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-protected IDEFloatTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-INumberBeanProxy createFloatBeanProxy(float aFloat){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,new Float(aFloat),this);
-}
-int getPrimitiveType(){
-	return FLOAT;
-}
-
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Number n = anObject instanceof Character ? new Float(((Character) anObject).charValue()) : (Number) anObject;
-	return new IDENumberBeanProxy(fProxyFactoryRegistry, n, this);
-
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEInitErrorBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEInitErrorBeanTypeProxy.java
deleted file mode 100644
index cab3363..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEInitErrorBeanTypeProxy.java
+++ /dev/null
@@ -1,260 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-
-/*
- *  $RCSfile: IDEInitErrorBeanTypeProxy.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * @author richkulp
- * 
- * To change this generated comment edit the template variable "typecomment": Window>Preferences>Java>Templates. To enable and disable the creation of
- * type comments go to Window>Preferences>Java>Code Generation.
- */
-public class IDEInitErrorBeanTypeProxy extends IDEBeanTypeProxy {
-
-	protected String classname;
-
-	protected String initializationError;
-	
-	protected Throwable cause;
-
-	protected IDEInitErrorBeanTypeProxy(IDEProxyFactoryRegistry registry, String classname, String initializationError, Throwable cause) {
-		super(registry, null);
-		this.classname = classname;
-		this.initializationError = initializationError;
-		this.cause = cause;
-	}
-
-	/**
-	 * Get the throwable (cause) that made this bean type bad. 
-	 * @return the Throwable that was the cause, or null if not caused by an throwable.
-	 * 
-	 * @since 1.1.0
-	 */
-	public Throwable getCause() {
-		return cause;
-	}
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(String[])
-	 */
-	public IConstructorProxy getConstructorProxy(String[] argumentClassNames) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	public IConstructorProxy[] getConstructors() {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(String[])
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getConstructorProxy(IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	public IConstructorProxy[] getDeclaredConstructors() {
-		return null;
-	}
-
-	public IFieldProxy[] getFields() {
-		return null;
-	}
-
-	public IFieldProxy[] getDeclaredFields() {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getFieldProxy(String)
-	 */
-	public IFieldProxy getFieldProxy(String fieldName) {
-		return null;
-	}
-
-	public IMethodProxy[] getMethods() {
-		return null;
-	}
-
-	public IMethodProxy[] getDeclaredMethods() {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(String)
-	 */
-	public IMethodProxy getMethodProxy(String methodName) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(String, String[])
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(String, String)
-	 */
-	public IMethodProxy getMethodProxy(String methodName, String argumentClassName) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(String, IBeanTypeProxy[])
-	 */
-	public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(String, String[])
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getMethodProxy(String, IBeanTypeProxy[])
-	 */
-	public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getNullConstructorProxy()
-	 */
-	public IConstructorProxy getNullConstructorProxy() {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getSuperBeanTypeProxy()
-	 */
-	public IBeanTypeProxy getSuperBeanTypeProxy() {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getTypeName()
-	 */
-	public String getTypeName() {
-		return classname;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getFormalTypeName()
-	 */
-	public String getFormalTypeName() {
-		return getTypeName();
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isArray()
-	 */
-	public boolean isArray() {
-		return false;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isInterface()
-	 */
-	public boolean isInterface() {
-		return false;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isPrimitive()
-	 */
-	public boolean isPrimitive() {
-		return false;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#isKindOf(IBeanTypeProxy)
-	 */
-	public boolean isKindOf(IBeanTypeProxy aBeanProxyType) {
-		return false;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance()
-	 */
-	public IBeanProxy newInstance() {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#newInstance(String)
-	 */
-	public IBeanProxy newInstance(String initializationString) {
-		return null;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getInitializationError()
-	 */
-	public String getInitializationError() {
-		return initializationError;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#toBeanString()
-	 */
-	public String toBeanString() {
-		return classname;
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#isValid()
-	 */
-	public boolean isValid() {
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleConstructor(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanTypeProxy#getCompatibleMethod(java.lang.String,
-	 *      org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
-	 */
-	public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) {
-		return null;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerBeanProxy.java
deleted file mode 100644
index 3dee6a1..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerBeanProxy.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEIntegerBeanProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * IDE Proxy for Integers. Since Integers were first implemented
- * in the VCE, and because they are often referenced, we've created
- * a subclass to handle them. That way we wouldn't need to change
- * everyone that was using the IIntegerProxy interface and we
- * can store the int value to speed up access.
- */
-public class IDEIntegerBeanProxy extends IDENumberBeanProxy implements IIntegerBeanProxy {
-	protected int fIntValue;
-IDEIntegerBeanProxy(IDEProxyFactoryRegistry aRegistry, Number anInteger, IBeanTypeProxy aBeanTypeProxy) {
-	super(aRegistry, anInteger , aBeanTypeProxy);
-	fIntValue = anInteger.intValue();
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return fIntValue;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerClassBeanTypeProxy.java
deleted file mode 100644
index 59ea9ec..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerClassBeanTypeProxy.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEIntegerClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy;
-
-/**
- * IDE Implementation of IIntegerBeanTypeProxy
- */
-final class IDEIntegerClassBeanTypeProxy extends IDENumberBeanTypeProxy {
-// Some values are cache'd for speed
-	private final IDEIntegerBeanProxy zeroIntProxy;
-	private final IDEIntegerBeanProxy oneIntProxy;
-	private final IDEIntegerBeanProxy twoIntProxy;
-	private final IDEIntegerBeanProxy threeIntProxy;
-IDEIntegerClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new Integer(0));
-	// Create the cached values
-	zeroIntProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(0), this );	
-	oneIntProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(1), this );
-	twoIntProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(2), this );
-	threeIntProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(3), this );
-		
-}
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-IIntegerBeanProxy createIntegerBeanProxy(Integer anInteger) {
-	switch(anInteger.intValue()){
-		case 0: return zeroIntProxy ;
-		case 1: return oneIntProxy ;
-		case 2: return twoIntProxy ;
-		case 3: return threeIntProxy ;
-		default: return new IDEIntegerBeanProxy(fProxyFactoryRegistry,anInteger,this);
-	}
-}
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return (IIDEBeanProxy)createIntegerBeanProxy((Integer)anObject);
-
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerTypeBeanTypeProxy.java
deleted file mode 100644
index 5cf3edb..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEIntegerTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEIntegerTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy;
-
-/**
- * IDE Implementation of IIntegerBeanTypeProxy
- */
-final class IDEIntegerTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-// Some values are cache'd for speed
-	private final IDEIntegerBeanProxy zeroProxy;
-	private final IDEIntegerBeanProxy oneProxy;
-	private final IDEIntegerBeanProxy twoProxy;
-	private final IDEIntegerBeanProxy threeProxy;
-IDEIntegerTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-	// Create the cached values
-	zeroProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(0), this );
-	oneProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(1), this );
-	twoProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(2), this );
-	threeProxy = new IDEIntegerBeanProxy(aRegistry, new Integer(3), this );
-		
-}
-/**
- * Static helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-IIntegerBeanProxy createIntegerBeanProxy(int anInt) {
-	switch(anInt){
-		case 0: return zeroProxy ;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new IDEIntegerBeanProxy(fProxyFactoryRegistry,new Integer(anInt),this);
-	}
-}
-/* Specialized from IDEBeanTypeProxy to ensure IIntegerBeanProxies are created correctly
- */
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Number n = anObject instanceof Character ? new Integer(((Character) anObject).charValue()) : (Number) anObject;
-	switch(n.intValue()){
-		case 0: return zeroProxy ;
-		case 1: return oneProxy ;
-		case 2: return twoProxy ;
-		case 3: return threeProxy ;
-		default: return new IDEIntegerBeanProxy(fProxyFactoryRegistry, n, this);
-	}
-	
-	
-}
-int getPrimitiveType(){
-	return INTEGER;
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDELongClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDELongClassBeanTypeProxy.java
deleted file mode 100644
index 5706b57..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDELongClassBeanTypeProxy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDELongClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Long BeanType Proxy.
- */
-final class IDELongClassBeanTypeProxy extends IDENumberBeanTypeProxy {
-		
-protected IDELongClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new Long(0));
-}
-INumberBeanProxy createLongBeanProxy(Long aLong){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,aLong,this);
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDELongTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDELongTypeBeanTypeProxy.java
deleted file mode 100644
index 2113ea0..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDELongTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDELongTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Long BeanType Proxy.
- */
-final class IDELongTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-	
-protected IDELongTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-INumberBeanProxy createLongBeanProxy(long aLong){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,new Long(aLong),this);
-}
-int getPrimitiveType(){
-	return LONG;
-}
-
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Number n = anObject instanceof Character ? new Long(((Character) anObject).charValue()) : (Number) anObject;
-	return new IDENumberBeanProxy(fProxyFactoryRegistry, n, this);
-}
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodProxy.java
deleted file mode 100644
index 948f72b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodProxy.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEMethodProxy.java,v $
- *  $Revision: 1.9 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-public class IDEMethodProxy extends IDEAccessibleObjectProxy implements IMethodProxy {
-
-	protected IDEMethodProxy(IDEProxyFactoryRegistry aRegistry, Method aMethod) {
-		super(aRegistry, aMethod);
-	}
-
-	public IBeanTypeProxy getClassType() {
-		return ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(
-			((Method) getBean()).getDeclaringClass());
-	}
-	public IBeanTypeProxy getReturnType() {
-		return ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(
-			((Method) getBean()).getReturnType());
-	}
-	public IBeanTypeProxy[] getParameterTypes() {
-		Class[] parmClasses = ((Method) getBean()).getParameterTypes();
-		IBeanTypeProxy[] parmTypes = new IBeanTypeProxy[parmClasses.length];
-		IDEStandardBeanTypeProxyFactory factory = (IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		for (int i = 0; i < parmClasses.length; i++) {
-			parmTypes[i] = factory.getBeanTypeProxy(parmClasses[i]);
-		}
-		return parmTypes;
-	}
-	public String getName() {
-		return ((Method) getBean()).getName();
-	}
-
-	/**
-	 * The type proxy is constant proxy out of the method factory.
-	 */
-	public IBeanTypeProxy getTypeProxy() {
-		return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).methodType;
-	}
-
-	/**
-	 * Invoke the method directly.  Because we are an IDEMethodProxy we can assume that IBeanProxy
-	 * is an IDEBeanProxy and we can get its bean directly
-	 */
-	public IBeanProxy invoke(IBeanProxy subject) throws ThrowableProxy {
-		try {
-			Object result = ((Method) getBean()).invoke(subject != null ? ((IIDEBeanProxy) subject).getBean() : null, new Object[0]);
-			if (result == null) {
-				return null;
-			} else {
-				// The result may be a java.lang.Integer when we really want to create an int
-				// Reflection always give you the big object
-				Class returnType = ((Method) getBean()).getReturnType();
-				return getBeanProxy(returnType, result);
-			}
-		} catch (InvocationTargetException e) {
-			// This is a wrappered exception. Return the wrappered one so it looks like
-			// it was the real one.
-			IBeanTypeProxy exceptionTypeProxy =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(
-					e.getTargetException().getClass());
-			throw new IDEThrowableProxy(e.getTargetException(), exceptionTypeProxy);
-		} catch (Exception exc) {
-			IBeanTypeProxy exceptionTypeProxy =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(exc.getClass());
-			throw new IDEThrowableProxy(exc, exceptionTypeProxy);
-		}
-	}
-	/**
-	 * Do not throw an exception
-	 */
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject) {
-		try {
-			return invoke(subject);
-		} catch (ThrowableProxy exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-		}
-		return null;
-	}
-	/**
-	 * Invoke the method with argument.  The argument will be an IDEBeanProxy 
-	 * ( because we are an IDEMethodProxy ) so we can cast to it and get the actual bean
-	 * itself and use this to invoke against method which is the actual
-	 * java.lang.Reflect instance
-	 */
-	public IBeanProxy invoke(IBeanProxy subject, IBeanProxy argument) throws ThrowableProxy {
-		try {
-			Object result =
-				((Method) getBean()).invoke(
-					subject != null ? ((IIDEBeanProxy) subject).getBean() : null,
-					new Object[] { argument != null ? ((IIDEBeanProxy) argument).getBean() : null });
-			if (result == null) {
-				return null;
-			} else {
-				Class returnType = ((Method) getBean()).getReturnType();
-				return getBeanProxy(returnType, result);
-			}
-		} catch (InvocationTargetException e) {
-			// This is a wrappered exception. Return the wrappered one so it looks like
-			// it was the real one.
-			IBeanTypeProxy exceptionTypeProxy =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(
-					e.getTargetException().getClass());
-			throw new IDEThrowableProxy(e.getTargetException(), exceptionTypeProxy);
-		} catch (Exception exc) {
-			IBeanTypeProxy exceptionTypeProxy =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(exc.getClass());
-			throw new IDEThrowableProxy(exc, exceptionTypeProxy);
-		}
-	}
-	/**
-	 * Invoke without throwing an exception
-	 */
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy argument) {
-		try {
-			return invoke(subject, argument);
-		} catch (ThrowableProxy exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-		}
-		return null;
-	}
-	/**
-	 * Invoke the method with arguments.  The arguments will be IDEBeanProxy objects
-	 * ( because we are an IDEMethodProxy ) so we can cast to them and get the actual bean
-	 * objects themselves and use these to invoke against method which is the actual
-	 * java.lang.Reflect instance
-	 */
-	public IBeanProxy invoke(IBeanProxy subject, IBeanProxy[] arguments) throws ThrowableProxy {
-		Object[] beanArguments = new Object[arguments.length];
-		for (int i = 0; i < arguments.length; i++) {
-			if (arguments[i] != null) {
-				beanArguments[i] = ((IIDEBeanProxy) arguments[i]).getBean();
-			}
-		}
-		try {
-			Object result = ((Method) getBean()).invoke(subject != null ? ((IIDEBeanProxy) subject).getBean() : null, beanArguments);
-			if (result == null) {
-				return null;
-			} else {
-				Class returnType = ((Method) getBean()).getReturnType();
-				return getBeanProxy(returnType, result);
-			}
-		} catch (InvocationTargetException e) {
-			// This is a wrappered exception. Return the wrappered one so it looks like
-			// it was the real one.
-			IBeanTypeProxy exceptionTypeProxy =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(
-					e.getTargetException().getClass());
-			throw new IDEThrowableProxy(e.getTargetException(), exceptionTypeProxy);
-		} catch (Exception exc) {
-			IBeanTypeProxy exceptionTypeProxy =
-				((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(exc.getClass());
-			throw new IDEThrowableProxy(exc, exceptionTypeProxy);
-		}
-	}
-	/**
-	 * Invoke without throwing an exception
-	 */
-	public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy[] arguments) {
-		try {
-			return invoke(subject, arguments);
-		} catch (ThrowableProxy exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-		}
-		return null;
-	}
-	IBeanProxy getBeanProxy(Class returnType, Object bean) {
-		return fProxyFactoryRegistry.getBeanProxy(returnType, bean);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodProxyFactory.java
deleted file mode 100644
index ecf4f28..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodProxyFactory.java
+++ /dev/null
@@ -1,337 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * $RCSfile: IDEMethodProxyFactory.java,v $ $Revision: 1.12 $ $Date: 2005/08/24 20:39:06 $
- */
-package org.eclipse.jem.internal.proxy.ide;
-
-import java.lang.reflect.*;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;
-import org.eclipse.jem.internal.proxy.common.MethodHelper;
-import org.eclipse.jem.internal.proxy.core.*;
-
-public class IDEMethodProxyFactory implements IMethodProxyFactory {
-
-	final protected IDEProxyFactoryRegistry fProxyFactoryRegistry;
-
-	final protected static Map primLookup = new HashMap();
-
-	IDEBeanTypeProxy accessibleType, fieldType, methodType, constructorType;
-	// Cached copy of a few typical method type proxies.
-	static {
-		primLookup.put("int", Integer.TYPE); //$NON-NLS-1$
-		primLookup.put("char", Character.TYPE); //$NON-NLS-1$
-		primLookup.put("long", Long.TYPE); //$NON-NLS-1$
-		primLookup.put("short", Short.TYPE); //$NON-NLS-1$
-		primLookup.put("double", Double.TYPE); //$NON-NLS-1$
-		primLookup.put("boolean", Boolean.TYPE); //$NON-NLS-1$
-		primLookup.put("byte", Byte.TYPE); //$NON-NLS-1$
-		primLookup.put("float", Float.TYPE); //$NON-NLS-1$
-	}
-
-	IDEMethodProxyFactory(IDEProxyFactoryRegistry aRegistry) {
-		fProxyFactoryRegistry = aRegistry;
-		fProxyFactoryRegistry.registerMethodProxyFactory(this);
-		accessibleType = new IDEBeanTypeProxy(aRegistry, AccessibleObject.class);
-		fieldType = new IDEFieldTypeProxy(aRegistry);
-		methodType = new IDEMethodTypeProxy(aRegistry);
-		constructorType = new IDEConstructorTypeProxy(aRegistry);
-		fProxyFactoryRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(accessibleType, true);
-		fProxyFactoryRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(fieldType, true);
-		fProxyFactoryRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(methodType, true);
-		fProxyFactoryRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(constructorType, true);
-	}
-
-	/**
-	 * Return an instance of an IDEConstructorProxy This is package protected because the only people who can use this are priveledge objects that
-	 * have the aMethod instance. These are part of the idevm package only. If you have to make this method public you are doing things incorrectly.
-	 * To get a method proxy you must use the interface methods on IMethodProxyFactory to do lookup by string or else on IBeanTypeProxy that has
-	 * getMethod(String) as well
-	 */
-	IConstructorProxy getConstructorProxy(Constructor aConstructor) {
-
-		return (IConstructorProxy) constructorType.newBeanProxy(aConstructor);
-
-	}
-	
-	IConstructorProxy[] getConstructors(Class aClass) {
-		Constructor[] ctors = aClass.getConstructors();
-		IConstructorProxy[] ctorProxies = new IConstructorProxy[ctors.length];
-		for (int i = 0; i < ctors.length; i++) {
-			ctorProxies[i] = getConstructorProxy(ctors[i]);
-		}
-		return ctorProxies;
-	}
-
-	IConstructorProxy[] getDeclaredConstructors(Class aClass) {
-		Constructor[] ctors = aClass.getDeclaredConstructors();
-		IConstructorProxy[] ctorProxies = new IConstructorProxy[ctors.length];
-		for (int i = 0; i < ctors.length; i++) {
-			ctorProxies[i] = getConstructorProxy(ctors[i]);
-		}
-		return ctorProxies;
-	}
-
-	IConstructorProxy getConstructorProxy(Class aClass, Class[] args) {
-
-		try {
-			Constructor ctor = aClass.getConstructor(args);
-			return getConstructorProxy(ctor);
-		} catch (NoSuchMethodException exc) {
-			return null;
-		}
-	}
-
-	IConstructorProxy getDeclaredConstructorProxy(Class aClass, Class[] args) {
-
-		try {
-			Constructor ctor = aClass.getDeclaredConstructor(args);
-			return getConstructorProxy(ctor);
-		} catch (NoSuchMethodException exc) {
-			return null;
-		}
-	}
-
-	IFieldProxy[] getFields(Class aClass) {
-		Field[] fields = aClass.getFields();
-		IFieldProxy[] fieldProxies = new IFieldProxy[fields.length];
-		for (int i = 0; i < fields.length; i++) {
-			fieldProxies[i] = getFieldProxy(fields[i]);
-		}
-		return fieldProxies;
-	}
-
-	IFieldProxy[] getDeclaredFields(Class aClass) {
-		Field[] fields = aClass.getDeclaredFields();
-		IFieldProxy[] fieldProxies = new IFieldProxy[fields.length];
-		for (int i = 0; i < fields.length; i++) {
-			fieldProxies[i] = getFieldProxy(fields[i]);
-		}
-		return fieldProxies;
-	}
-
-	/**
-	 * Return an instance of an IDEFieldProxy This is package protected because the only people who can use this are priveledge objects that have the
-	 * aField instance. These are part of the idevm package only. If you have to make this method public you are doing things incorrectly. To get a
-	 * field proxy you must use the interface methods on IBeanTypeProxy that has getField(String) as well
-	 */
-	IFieldProxy getFieldProxy(Field aField) {
-
-		return (IFieldProxy) fieldType.newBeanProxy(aField);
-
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String)
-	 */
-	public IProxyField getFieldProxy(IExpression expression, String className, String fieldName) {
-		// We are getting the class resolved through the expression. Might as well because it probably will
-		// be needed again and this way when the expression is finished they will be resolved for later usage.
-		IStandardBeanTypeProxyFactory beanTypeProxyFactory = fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		IProxyBeanType beanType = beanTypeProxyFactory.getBeanTypeProxy(expression, className);
-		return beanType.getFieldProxy(expression, fieldName);
-	}
-
-	/**
-	 * Return an instance of an IDEMethodProxy This is package protected because the only people who can use this are priveledge objects that have the
-	 * aMethod instance. These are part of the idevm package only. If you have to make this method public you are doing things incorrectly. To get a
-	 * method proxy you must use the interface methods on IMethodProxyFactory to do lookup by string or else on IBeanTypeProxy that has
-	 * getMethod(String) as well
-	 */
-	IDEMethodProxy getMethodProxy(Method aMethod) {
-
-		return (IDEMethodProxy) methodType.newBeanProxy(aMethod);
-
-	}
-
-	public IMethodProxy getMethodProxy(String className, String methodName, String[] parameterTypes) {
-		try {
-			Class aClass = fProxyFactoryRegistry.loadClass(className);
-			return getMethodProxy(aClass, methodName, parameterTypes);
-		} catch (ClassNotFoundException exc) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-			return null;
-		}
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String, java.lang.String[])
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, String className, String methodName, String[] parameterTypes) {
-		// We are getting the class and parmtypes resolved through the expression. Might as well because they probably will
-		// be needed again and this way when the expression is finished they will be resolved for later usage.
-		IStandardBeanTypeProxyFactory beanTypeProxyFactory = fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		IProxyBeanType beanType = beanTypeProxyFactory.getBeanTypeProxy(expression, className);
-		IProxyBeanType[] parmTypes = getParameterTypes(expression, parameterTypes, beanTypeProxyFactory);
-		return beanType.getMethodProxy(expression, methodName, parmTypes);
-	}	
-	
-	/**
-	 * Helper method for Beantypes and Proxy bean types to get the proxy.
-	 * @param expression
-	 * @param classType
-	 * @param methodName
-	 * @param parameterTypes
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType classType, String methodName, String[] parameterTypes) {
-		// We are getting the parmtypes resolved through the expression. Might as well because they probably will
-		// be needed again and this way when the expression is finished they will be resolved for later usage.
-		IStandardBeanTypeProxyFactory beanTypeProxyFactory = fProxyFactoryRegistry.getBeanTypeProxyFactory();
-		IProxyBeanType[] parmTypes = getParameterTypes(expression, parameterTypes, beanTypeProxyFactory);
-		return classType.getMethodProxy(expression, methodName, parmTypes);
-	}
-
-	/**
-	 * @param expression
-	 * @param parameterTypes
-	 * @param beanTypeProxyFactory
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected IProxyBeanType[] getParameterTypes(IExpression expression, String[] parameterTypes, IStandardBeanTypeProxyFactory beanTypeProxyFactory) {
-		IProxyBeanType[] parmTypes;
-		if (parameterTypes == null || parameterTypes.length == 0)
-			parmTypes = null;
-		else {
-			parmTypes = new IProxyBeanType[parameterTypes.length];
-			for (int i = 0; i < parameterTypes.length; i++) {
-				parmTypes[i] = beanTypeProxyFactory.getBeanTypeProxy(expression, parameterTypes[i]);
-			}
-		}
-		return parmTypes;
-	}
-
-	public IMethodProxy getMethodProxy(Class cls, String methodName, String[] parameterTypes) {
-		try {
-			Class[] parmClasses = null;
-			if (parameterTypes != null) {
-				parmClasses = new Class[parameterTypes.length];
-				for (int i = 0; i < parmClasses.length; i++) {
-					Class temp = (Class) primLookup.get(parameterTypes[i]);
-					if (temp == null)
-						temp = fProxyFactoryRegistry.loadClass(parameterTypes[i]);
-					parmClasses[i] = temp;
-				}
-			}
-			return getMethodProxy(cls.getMethod(methodName, parmClasses));
-		} catch (ClassNotFoundException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		} catch (NoSuchMethodException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-		return null;
-	}
-	
-	IMethodProxy getDeclaredMethodProxy(Class cls, String methodName, String[] parameterTypes) {
-		try {
-			Class[] parmClasses = null;
-			if (parameterTypes != null) {
-				parmClasses = new Class[parameterTypes.length];
-				for (int i = 0; i < parmClasses.length; i++) {
-					Class temp = (Class) primLookup.get(parameterTypes[i]);
-					if (temp == null)
-						temp = fProxyFactoryRegistry.loadClass(parameterTypes[i]);
-					parmClasses[i] = temp;
-				}
-			}
-			return getMethodProxy(cls.getDeclaredMethod(methodName, parmClasses));
-		} catch (ClassNotFoundException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		} catch (NoSuchMethodException e) {
-			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-		}
-		return null;
-	}	
-
-	IDEMethodProxy getMethodProxy(Class aClass, String methodName, Class[] args) {
-		try {
-			Method method = aClass.getMethod(methodName, args);
-			return getMethodProxy(method);
-		} catch (NoSuchMethodException exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-					new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "Unable to find method " + aClass.getName() //$NON-NLS-1$
-							+ ":" + methodName + " args=" + args, exc)); //$NON-NLS-1$ //$NON-NLS-2$
-			return null;
-		}
-	}
-	
-	IMethodProxy getDeclaredMethodProxy(Class aClass, String methodName, Class[] args) {
-		try {
-			Method method = aClass.getDeclaredMethod(methodName, args);
-			return getMethodProxy(method);
-		} catch (NoSuchMethodException exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-					new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "Unable to find method " + aClass.getName() //$NON-NLS-1$
-							+ ":" + methodName + " args=" + args, exc)); //$NON-NLS-1$ //$NON-NLS-2$
-			return null;
-		}
-	}	
-
-	IMethodProxy getMethodProxy(IDEBeanTypeProxy aTypeProxy, String methodName, String[] parameterTypes) {
-		return getMethodProxy(aTypeProxy.fClass, methodName, parameterTypes);
-	}
-	
-	IMethodProxy[] getMethods(Class aClass) {
-		Method[] methods = aClass.getMethods();
-		IMethodProxy[] methodProxies = new IMethodProxy[methods.length];
-		for (int i = 0; i < methods.length; i++) {
-			methodProxies[i] = getMethodProxy(methods[i]);
-		}
-		return methodProxies;
-	}
-	
-	IMethodProxy getCompatibleMethod(Class aClass, String methodName, Class[] parmTypes) throws NoSuchMethodException, AmbiguousMethodException {
-		Method method = MethodHelper.findCompatibleMethod(aClass, methodName, parmTypes);
-		return getMethodProxy(method);
-	}
-	
-	IConstructorProxy getCompatibleConstructor(Class aClass, Class[] parmTypes) throws AmbiguousMethodException, NoSuchMethodException {
-		Constructor method = MethodHelper.findCompatibleConstructor(aClass, parmTypes);
-		return getConstructorProxy(method);
-	}
-	
-
-	IMethodProxy[] getDeclaredMethods(Class aClass) {
-		Method[] methods = aClass.getDeclaredMethods();
-		IMethodProxy[] methodProxies = new IMethodProxy[methods.length];
-		for (int i = 0; i < methods.length; i++) {
-			methodProxies[i] = getMethodProxy(methods[i]);
-		}
-		return methodProxies;
-	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getInvokable(java.lang.String, java.lang.String, java.lang.String[])
-	 */
-	public IInvokable getInvokable(String className, String methodName, String[] parameterTypes) {
-		return getMethodProxy(className, methodName, parameterTypes);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxyFactory#terminateFactory(boolean)
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodTypeProxy.java
deleted file mode 100644
index 8a6a372..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEMethodTypeProxy.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEMethodTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-/**
- * @version 	1.0
- * @author
- */
-public class IDEMethodTypeProxy extends IDEBeanTypeProxy {
-	
-	IDEMethodTypeProxy(IDEProxyFactoryRegistry registry) {
-		super(registry, java.lang.reflect.Method.class);
-	}
-
-	/*
-	 * @see IDEBeanTypeProxy#newBeanProxy(Object)
-	 */
-	protected IIDEBeanProxy newBeanProxy(Object anObject) {
-		return new IDEMethodProxy(fProxyFactoryRegistry, (java.lang.reflect.Method) anObject);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDENumberBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDENumberBeanProxy.java
deleted file mode 100644
index 9c8cc33..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDENumberBeanProxy.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDENumberBeanProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * IDE Implementation of INumberBeanProxy for any Number (i.e. the non-primitives)
- * It can answer all of the primitive number types (int, long, short, byte, double, float).
- * Creation date: (2/6/00 9:02:54 AM)
- * @author: Joe Winchester
- */
-public class IDENumberBeanProxy extends IDEBeanProxy implements INumberBeanProxy {
-	private final Number fNumberValue;
-	protected IBeanTypeProxy fBeanTypeProxy;
-	
-/**
- * It is package protected because they are created
- * in a special way and no one else should create them.
- * @param aBean java.lang.Object
- */
-IDENumberBeanProxy(IDEProxyFactoryRegistry aRegistry, Number aNumber , IBeanTypeProxy aBeanTypeProxy) {
-	super(aRegistry,aNumber);
-	fNumberValue = aNumber;
-	fBeanTypeProxy = aBeanTypeProxy;
-}
-/**
- * equals: Equal if:
- *         1) This proxy == (identity) to the other object
- *         2) Else if other is an IBeanProxy and not a constant one, then if
- *            equals on the server.
- *         3) If this is a constant proxy and the other is too or is a constant
- *            value (e.g. IStringBeanProxy.equals(String), then true if values are equals.
- */
-public boolean equals(Object anObject) {
-	if (this == anObject)
-		return true;	// Identity
-	if (anObject instanceof IDENumberBeanProxy)
-		return fNumberValue.equals(((IDENumberBeanProxy) anObject).numberValue());
-	if (anObject instanceof Number)
-		return fNumberValue.equals(anObject);
-	return false;
-}
-/**
- * byteValue method comment.
- */
-public byte byteValue() {
-	return fNumberValue.byteValue();
-}
-/**
- * doubleValue method comment.
- */
-public double doubleValue() {
-	return fNumberValue.doubleValue();
-}
-/**
- * floatValue method comment.
- */
-public float floatValue() {
-	return fNumberValue.floatValue();
-}
-/**
- * Return the int value
- */
-public int intValue() {
-	return fNumberValue.intValue();
-}
-/**
- * longValue method comment.
- */
-public long longValue() {
-	return fNumberValue.longValue();
-}
-/**
- * numberValue method comment.
- */
-public Number numberValue() {
-	return fNumberValue;
-}
-/**
- * shortValue method comment.
- */
-public short shortValue() {
-	return fNumberValue.shortValue();
-}
-
-/**
- * The bean's toString.
- */
-public String toBeanString() {
-	return fNumberValue.toString();
-}
-public IBeanTypeProxy getTypeProxy(){
-	return fBeanTypeProxy;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDENumberBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDENumberBeanTypeProxy.java
deleted file mode 100644
index ff1c1dd..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDENumberBeanTypeProxy.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDENumberBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Number BeanType Proxy.
- */
-public abstract class IDENumberBeanTypeProxy extends IDEBeanTypeProxy {
-	protected final IDENumberBeanProxy zeroProxy;
-/**
- * IDENumberBeanTypeProxy constructor comment.
- * @param aRegistry com.ibm.etools.vce.proxy.ProxyFactoryRegistry
- * @param aClass java.lang.Class
- */
-protected IDENumberBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass, Number zeroNumber) {
-	super(aRegistry, aClass);
-	// Cache a zero proxy of this type (though the number will be Long).
-	zeroProxy = new IDENumberBeanProxy(aRegistry, zeroNumber , this);
-}
-/**
- * Helper to create a bean proxy
- * Package protected because everyone should go through the factory API
- * that is defined as part of IBeanProxyFactory
- */
-INumberBeanProxy createNumberBeanProxy(Number aNumber) {
-	if (aNumber == null || zeroProxy.fBean.equals(aNumber))
-		return zeroProxy;
-	return new IDENumberBeanProxy(fProxyFactoryRegistry, aNumber, this);
-}
-/**
- * Specialized from IDEBeanTypeProxy to ensure INumberBeanProxies are created correctly.
- */
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return (IIDEBeanProxy)createNumberBeanProxy((Number) anObject);
-
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEObjectBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEObjectBeanProxy.java
deleted file mode 100644
index 2ff81cb..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEObjectBeanProxy.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEObjectBeanProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-public class IDEObjectBeanProxy extends IDEBeanProxy {
-
-	protected IBeanTypeProxy fBeanTypeProxy; // Cache the type proxy for speed
-	
-protected IDEObjectBeanProxy(IDEProxyFactoryRegistry aRegistry){
-	super(aRegistry);
-}
-/**
- * Constructor that lets the bean type be set on creation.
- * This saves the overhead of it being looked up the first time it is asked for.
- *
- * This is protected because the only person
- * who should use it is the IDEBeanTypeProxy or a subclass.  Making it package protected stops people from
- * writing bogus code and doing casts and slamming new beans in without going through the proper API
- * that is based around any kind of VM artifact being proxied to support target VMs and pluggable JDK
- * levels 
- */
-protected IDEObjectBeanProxy(IDEProxyFactoryRegistry aRegistry, Object aBean, IBeanTypeProxy aBeanTypeProxy){
-	
-	this(aRegistry, aBean);
-	fBeanTypeProxy = aBeanTypeProxy;
-	
-}
-/**
- * Set the bean we are proxying.  We are a proxy for a bean running on the same IDE
- * so we hold the bean directly and can return it. 
- */
-protected IDEObjectBeanProxy(IDEProxyFactoryRegistry aRegistry, Object aBean){
-	this(aRegistry);
-	
-	fBean = aBean;
-	
-}
-/**
- * The type proxy is got from our class name
- * If we have the type return it, otherwise go the factory for it
- * Don't new it up because the factory must be responsible for creating type proxies as it
- * has to perform instance management on them
- */
-public IBeanTypeProxy getTypeProxy() {
-
-	if ( fBeanTypeProxy == null ) {	
-		fBeanTypeProxy = fProxyFactoryRegistry.getBeanTypeProxyFactory().getBeanTypeProxy( fBean.getClass().getName() );
-	}
-	return fBeanTypeProxy;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEPrimitiveBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEPrimitiveBeanTypeProxy.java
deleted file mode 100644
index 72ea50a..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEPrimitiveBeanTypeProxy.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEPrimitiveBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-
-public abstract class IDEPrimitiveBeanTypeProxy extends IDEBeanTypeProxy {
-	
-	static final int BOOLEAN = 1;
-	static final int BYTE = 2;
-	static final int CHAR = 3;
-	static final int DOUBLE = 4;
-	static final int FLOAT = 5;
-	static final int INTEGER = 6;
-	static final int LONG = 7;
-	static final int SHORT = 8;
-	
-public IDEPrimitiveBeanTypeProxy(IDEProxyFactoryRegistry aRegistry,Class aClass){
-	super(aRegistry,aClass);
-}
-public boolean isPrimitive() {
-	return true;
-}
-abstract int getPrimitiveType();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEProxyFactoryRegistry.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEProxyFactoryRegistry.java
deleted file mode 100644
index 80493d5..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEProxyFactoryRegistry.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEProxyFactoryRegistry.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.*;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.core.runtime.Platform;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.proxy.common.IVMServer;
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * This implementation runs the Beans inside the Eclipse IDE
- * It should only be used by plugins that can guarantee their their beans do
- * not change during the lifetime of the IDE and can run at the same JDK level
- * that the Eclipse IDE is running
- */
-
-public class IDEProxyFactoryRegistry extends BaseProxyFactoryRegistry implements IVMServer {
-
-	public static final String IDE_REGISTRY_TYPE_ID = "org.eclipse.jem.IDE";	//$NON-NLS-1$
-	protected String fName;
-	protected ClassLoader fClassLoader;
-	protected IDECallbackRegistry fCallbackRegistry;
-	
-	/*
-	 * Special classloader that firsts tries to load from bundle then tries from url paths so
-	 * that bundle is treated as being at the head of the url paths.
-	 * 
-	 * @since 1.0.0
-	 */
-	private static class IDESpecialClassLoader extends URLClassLoader {
-		
-		private Bundle bundle;
-		// This is the bundle that contains the IDE Eclipse code.
-		// This must be checked first because there are IDE specific stuff that is used on the "remote vm" too and
-		// so must be common.
-		private Bundle ideBundle;	 
-
-		public IDESpecialClassLoader(URL[] urls, Bundle bundle) {
-			super(urls, null);
-			ideBundle = ProxyPlugin.getPlugin().getBundle();
-			this.bundle = bundle;
-		}
-		
-		public IDESpecialClassLoader(URL[] urls) {
-			this(urls, null);
-		}
-		
-		/* (non-Javadoc)
-		 * @see java.lang.ClassLoader#findClass(java.lang.String)
-		 */
-		protected Class findClass(String name) throws ClassNotFoundException {
-			try {
-				return ideBundle.loadClass(name);
-			} catch (ClassNotFoundException e) {
-				if (bundle != null) {
-					try {
-						return bundle.loadClass(name);
-					} catch (ClassNotFoundException e1) {
-					}
-				}
-				return super.findClass(name);
-			}
-		}
-		
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see java.lang.ClassLoader#findResource(java.lang.String)
-		 */
-		public URL findResource(String name) {
-			URL r = ideBundle.getResource(name);
-			if (r == null && bundle != null)
-				r = bundle.getResource(name);
-			return r != null ? r : super.findResource(name);
-		}
-}
-
-/**
- * Create a special loader that has the plugin classloader of the passed in plugin
- * as the parent loader, plus all of the urls, plus the remotevm.jar file that is
- * needed by IDE Proxy to work.
- */	
-public static ClassLoader createSpecialLoader(String pluginName, URL[] otherURLs) {
-	Bundle bundle = pluginName != null ? Platform.getBundle(pluginName) : null;
-	
-	URL[] mustHaveUrls = ProxyPlugin.getPlugin().urlLocalizeAllFromBundleAndFragments(ProxyPlugin.getPlugin().getBundle(), "vm/remotevm.jar"); //$NON-NLS-1$
-	
-	URL[] urls = null;
-	if (otherURLs != null) {
-		urls = new URL[otherURLs.length+mustHaveUrls.length];
-		System.arraycopy(mustHaveUrls, 0, urls, 0, mustHaveUrls.length);
-		System.arraycopy(otherURLs, 0, urls, mustHaveUrls.length, otherURLs.length);
-	} else 
-		urls = mustHaveUrls;
-		
-	return bundle != null ? new IDESpecialClassLoader(urls, bundle) : new IDESpecialClassLoader(urls);
-}
-
-public IDEProxyFactoryRegistry(String aName, ClassLoader loader) {
-	super(IDE_REGISTRY_TYPE_ID);
-	fName = aName;
-	fClassLoader = loader;
-}
-
-ClassLoader getPluginClassLoader(){
-	return fClassLoader;
-}
-
-protected void registryTerminated(boolean wait){
-	List runnables = null;
-	synchronized (this) {
-		runnables = shutdownRunnables;
-		shutdownRunnables = null;
-	}
-	if (runnables != null) {
-		for (Iterator itr = runnables.iterator(); itr.hasNext();) {
-			try {
-				((Runnable) itr.next()).run();
-			} catch (RuntimeException e) {
-				e.printStackTrace();
-			}
-		}
-	}
-}
-
-Class loadClass(String aClassName) throws ClassNotFoundException, ExceptionInInitializerError, LinkageError {
-	return fClassLoader.loadClass(aClassName);
-}
-
-public ICallbackRegistry getCallbackRegistry(){
-	if ( fCallbackRegistry == null ){
-		fCallbackRegistry = new IDECallbackRegistry(this);
-	}
-	return fCallbackRegistry;
-}
-
-
-/**
- * Get a bean proxy from the bean of the correct type.
- * 
- * @param returnType
- * @param bean
- * @return
- * 
- * @since 1.0.0
- */
-IBeanProxy getBeanProxy(Class returnType, Object bean) {
-	IDEStandardBeanTypeProxyFactory proxyFactory = (IDEStandardBeanTypeProxyFactory) this.getBeanTypeProxyFactory();
-	if (!returnType.isPrimitive()) {
-		return IDEStandardBeanProxyFactory.createBeanProxy(this, bean);
-	} else if (returnType == Integer.TYPE) {
-		return proxyFactory.intType.newBeanProxy(bean);
-	} else if (returnType == Boolean.TYPE) {
-		return proxyFactory.booleanType.newBeanProxy(bean);
-	} else if (returnType == Float.TYPE) {
-		return proxyFactory.floatType.newBeanProxy(bean);
-	} else if (returnType == Long.TYPE) {
-		return proxyFactory.longType.newBeanProxy(bean);
-	} else if (returnType == Short.TYPE) {
-		return proxyFactory.shortType.newBeanProxy(bean);
-	} else if (returnType == Double.TYPE) {
-		return proxyFactory.doubleType.newBeanProxy(bean);
-	} else if (returnType == Byte.TYPE) {
-		return proxyFactory.byteType.newBeanProxy(bean);
-	} else if (returnType == Character.TYPE) {
-		return proxyFactory.charType.newBeanProxy(bean);
-	} else {
-		throw new RuntimeException("Unknown primitive type " + returnType.getName()); //$NON-NLS-1$
-	}
-}
-
-List shutdownRunnables;
-
-public synchronized void addShutdownListener(Runnable runnable) {
-	if (shutdownRunnables == null) {
-		shutdownRunnables = new ArrayList();
-	} else if (shutdownRunnables.contains(runnable))
-		return;
-	shutdownRunnables.add(runnable);
-}
-
-public synchronized void removeShutdownListener(Runnable runnable) {
-	if (shutdownRunnables != null)
-		shutdownRunnables.remove(runnable);
-}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDERegistration.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDERegistration.java
deleted file mode 100644
index 43cc661..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDERegistration.java
+++ /dev/null
@@ -1,154 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDERegistration.java,v $
- *  $Revision: 1.11 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.net.URL;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.*;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.launching.JavaRuntime;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.ide.awt.IDERegisterAWT;
-import org.eclipse.jem.internal.proxy.remote.LocalFileConfigurationContributorController;
-/**
- * This is the registration class for starting an IDERemote VM.
- */
-
-public class IDERegistration {
-	
-	public static ProxyFactoryRegistry startAnImplementation(
-		IConfigurationContributor[] contributors,
-		boolean attachAWT,
-		IProject project,
-		String vmName,
-		String pluginName,
-		IProgressMonitor pm) throws CoreException {
-			IDERegistration idereg = new IDERegistration(pluginName);
-			return idereg.startImplementation(contributors, attachAWT, project, vmName, pm); 
-		}
-	
-	public IDERegistration() {
-	}
-	
-	private IDERegistration(String pluginName) {
-		this.pluginName = pluginName;
-	}
-	private String pluginName;	
-
-	/**
-	 * This will create a remote VM and return an initialized REMProxyFactoryRegistry.
-	 * Passed in are:
-	 *      project: The project this is being started on. Must not be null and must be a JavaProject. (Currently ignored for IDE).
-	 *      attachAWT: Should AWT be attached to this implementation.
-	 *      contributors: Contributors to the configuration. Can be null.
-	 *      pm: ProgressMonitor to use. Must not be null.
-	 *      vmName: Name for the vm. Can be null.
-	 */
-	public ProxyFactoryRegistry startImplementation(
-		IConfigurationContributor[] contributors,
-		boolean attachAWT,
-		IProject project,
-		String vmName,
-		IProgressMonitor pm)
-		throws CoreException {
-
-		URL[] classPaths = null;
-		IJavaProject javaProject = null;
-		if (project != null) {
-			javaProject = JavaCore.create(project);
-			// Add in the paths for the project	 	
-			classPaths = ProxyLaunchSupport.convertStringPathsToURL(JavaRuntime.computeDefaultRuntimeClassPath(javaProject));
-		} else
-			classPaths = new URL[0];
-
-		final IJavaProject jp = javaProject;
-
-		final ProxyLaunchSupport.LaunchInfo launchInfo = new ProxyLaunchSupport.LaunchInfo();
-		contributors = ProxyLaunchSupport.fillInLaunchInfo(contributors == null ? ProxyLaunchSupport.EMPTY_CONFIG_CONTRIBUTORS : contributors, launchInfo, jp != null ? jp.getElementName() : null);
-		final LocalFileConfigurationContributorController controller = new LocalFileConfigurationContributorController(classPaths, new URL[3][], launchInfo);
-		final IConfigurationContributor[] contribs = contributors;
-		for (int i = 0; i < contributors.length; i++) {
-			final int ii = i;
-			// Run in safe mode so that anything happens we don't go away.
-			Platform.run(new ISafeRunnable() {
-				public void handleException(Throwable exception) {
-					// Don't need to do anything. Platform.run logs it for me.
-				}
-
-				public void run() throws Exception {
-					contribs[ii].initialize(launchInfo.getConfigInfo());
-				}
-			});				
-		}			
-		for (int i = 0; i < contributors.length; i++) {
-			final int ii = i;
-			// Run in safe mode so that anything happens we don't go away.
-			Platform.run(new ISafeRunnable() {
-				public void handleException(Throwable exception) {
-					// Don't need to do anything. Platform.run logs it for me.
-				}
-
-				public void run() throws Exception {
-					contribs[ii].contributeClasspaths(controller);
-				}
-			});				
-		}
-		classPaths = controller.getFinalClasspath();
-
-		final BaseProxyFactoryRegistry registry = (BaseProxyFactoryRegistry) createIDEProxyFactoryRegistry(vmName, pluginName, classPaths);
-		ProxyLaunchSupport.performExtensionRegistrations(registry, launchInfo);
-		for (int i = 0; i < contribs.length; i++) {
-			final int ii = i;
-			// Run in safe mode so that anything happens we don't go away.
-			Platform.run(new ISafeRunnable() {
-				public void handleException(Throwable exception) {
-					// Don't need to do anything. Platform.run logs it for me.
-				}
-
-				public void run() throws Exception {
-					contribs[ii].contributeToRegistry(registry);
-				}
-			});	
-		}
-
-		return registry;
-	}
-
-	public static ProxyFactoryRegistry createIDEProxyFactoryRegistry(String aName, String aPluginName, URL[] otherURLs) {
-		// Create the registry.
-		IDEProxyFactoryRegistry registry =
-			new IDEProxyFactoryRegistry(aName, IDEProxyFactoryRegistry.createSpecialLoader(aPluginName, otherURLs));
-		initRegistry(registry);
-		return registry;
-	}
-
-	public static ProxyFactoryRegistry createIDEProxyFactoryRegistry(String aName, ClassLoader loader) {
-		// Create the registry.
-		IDEProxyFactoryRegistry registry = new IDEProxyFactoryRegistry(aName, loader);
-		initRegistry(registry);
-		return registry;
-	}
-
-	private static void initRegistry(IDEProxyFactoryRegistry registry) {
-		new IDEStandardBeanTypeProxyFactory(registry);
-		new IDEStandardBeanProxyFactory(registry);
-		new IDEMethodProxyFactory(registry);
-		// Always support AWT for now
-		IDERegisterAWT.registerAWT(registry);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEShortClassBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEShortClassBeanTypeProxy.java
deleted file mode 100644
index 46042c5..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEShortClassBeanTypeProxy.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEShortClassBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * Short BeanType Proxy.
- */
-final class IDEShortClassBeanTypeProxy extends IDENumberBeanTypeProxy {
-protected IDEShortClassBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass, new Short((short)0));
-}
-INumberBeanProxy createShortBeanProxy(Short aShort){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,aShort,this);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEShortTypeBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEShortTypeBeanTypeProxy.java
deleted file mode 100644
index 5bf42ab..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEShortTypeBeanTypeProxy.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEShortTypeBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-/**
- * Short BeanType Proxy.
- */
-final class IDEShortTypeBeanTypeProxy extends IDEPrimitiveBeanTypeProxy {
-protected IDEShortTypeBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-}
-INumberBeanProxy createShortBeanProxy(short aShort){
-	return new IDENumberBeanProxy(fProxyFactoryRegistry,new Short(aShort),this);
-}
-int getPrimitiveType(){
-	return SHORT;
-}
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-	Number n = anObject instanceof Character ? new Short((short) ((Character) anObject).charValue()) : (Number) anObject;
-	return new IDENumberBeanProxy(fProxyFactoryRegistry, n, this);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStandardBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStandardBeanProxyFactory.java
deleted file mode 100644
index 85a852b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStandardBeanProxyFactory.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- * $RCSfile: IDEStandardBeanProxyFactory.java,v $ $Revision: 1.11 $ $Date: 2005/08/24 20:39:06 $
- */
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.IVMServer;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.initParser.InitializationStringParser;
-
-public class IDEStandardBeanProxyFactory implements IStandardBeanProxyFactory {
-
-
-	protected IDEProxyFactoryRegistry fRegistry;
-	protected IDEStandardBeanTypeProxyFactory fBeanTypeProxyFactory;
-	private IBeanProxy ivmServerProxy;
-	
-	/*
-	 * Return a bean proxy for the argument. To do this create through the correct BeanTypeProxy
-	 * Which ensures that special subclasses of IDEBeanProxy are created. This is just a local
-	 * helper method.
-	 */
-	static IIDEBeanProxy createBeanProxy(ProxyFactoryRegistry aRegistry, Object anObject) {
-
-		return ((IDEStandardBeanProxyFactory) aRegistry.getBeanProxyFactory()).createIDEBeanProxyWith(anObject);
-	}
-	
-	IDEStandardBeanProxyFactory(IDEProxyFactoryRegistry aRegistry) {
-		fRegistry = aRegistry;
-		fRegistry.registerBeanProxyFactory(this);
-		fBeanTypeProxyFactory = (IDEStandardBeanTypeProxyFactory) aRegistry.getBeanTypeProxyFactory();
-		ivmServerProxy = fRegistry.getBeanProxy(IVMServer.class, fRegistry);
-	}
-	
-	public IStringBeanProxy createBeanProxyWith(String aString) {
-		return fBeanTypeProxyFactory.stringClass.createStringBeanProxy(aString);
-	}
-	
-	public INumberBeanProxy createBeanProxyWith(float aFloat) {
-		return fBeanTypeProxyFactory.floatType.createFloatBeanProxy(aFloat);
-	}
-	
-	public INumberBeanProxy createBeanProxyWith(short aShort) {
-		return fBeanTypeProxyFactory.shortType.createShortBeanProxy(aShort);
-	}
-	
-	public ICharacterBeanProxy createBeanProxyWith(char aChar) {
-		return fBeanTypeProxyFactory.charType.createCharBeanProxy(aChar);
-	}
-	
-	public ICharacterBeanProxy createBeanProxyWith(Character aCharacter) {
-		return fBeanTypeProxyFactory.charClass.createCharacterBeanProxy(aCharacter);
-	}
-	
-	public IIntegerBeanProxy createBeanProxyWith(int anInt) {
-		return fBeanTypeProxyFactory.intType.createIntegerBeanProxy(anInt);
-	}
-	
-	public IIntegerBeanProxy createBeanProxyWith(Integer anInteger) {
-		return fBeanTypeProxyFactory.integerClass.createIntegerBeanProxy(anInteger);
-	}
-	
-	public INumberBeanProxy createBeanProxyWith(long aLong) {
-		return fBeanTypeProxyFactory.longType.createLongBeanProxy(aLong);
-	}
-	
-	public INumberBeanProxy createBeanProxyWith(Number aNumber) {
-		IDENumberBeanTypeProxy numberTypeProxy = (IDENumberBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(aNumber.getClass());
-		return numberTypeProxy.createNumberBeanProxy(aNumber);
-	}
-	
-	public IBooleanBeanProxy createBeanProxyWith(boolean aBoolean) {
-		return fBeanTypeProxyFactory.booleanType.createBooleanBeanProxy(aBoolean);
-	}
-	
-	public IBooleanBeanProxy createBeanProxyWith(Boolean aBoolean) {
-		return fBeanTypeProxyFactory.booleanClass.createBooleanBeanProxy(aBoolean);
-	}
-	
-	public INumberBeanProxy createBeanProxyWith(byte aByte) {
-		return fBeanTypeProxyFactory.byteType.createByteBeanProxy(aByte);
-	}
-	
-	public INumberBeanProxy createBeanProxyWith(double aDouble) {
-		return fBeanTypeProxyFactory.doubleType.createDoubleBeanProxy(aDouble);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#convertToPrimitiveBeanProxy(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public IBeanProxy convertToPrimitiveBeanProxy(IBeanProxy nonPrimitiveProxy) {
-		if (nonPrimitiveProxy == null)
-			return null;
-		if (!nonPrimitiveProxy.isValid())
-			return nonPrimitiveProxy;
-		IDEBeanTypeProxy type = (IDEBeanTypeProxy) nonPrimitiveProxy.getTypeProxy();
-		if (type.getClass() == Boolean.class)
-			return this.createBeanProxyWith(((IBooleanBeanProxy) nonPrimitiveProxy).booleanValue());
-		else if (type.getClass() == Byte.class)
-			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).byteValue());
-		else if (type.getClass() == Character.class)
-			return this.createBeanProxyWith(((ICharacterBeanProxy) nonPrimitiveProxy).charValue());
-		else if (type.getClass() == Double.class)
-			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).doubleValue());
-		else if (type.getClass() == Float.class)
-			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).floatValue());
-		else if (type.getClass() == Integer.class)
-			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).intValue());
-		else if (type.getClass() == Long.class)
-			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).longValue());
-		else if (type.getClass() == Short.class)
-			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).shortValue());
-		else
-			return nonPrimitiveProxy;
-	}
-
-	/**
-	 * Create a one-dimensional array. The result will be the same as calling
-	 * createBeanProxyWith(IBeanTypeProxy type, new int[1] {x}) where 'x' is the value passed in as
-	 * the dimension.
-	 */
-	public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int dimension) throws ThrowableProxy {
-		return createBeanProxyWith(type, new int[] { dimension });
-	}
-	
-	/**
-	 * Create an array bean proxy.
-	 *  - (int, new int[2] {3, 4}) will create: int [3] [4]
-	 *  - (int[], new int[1] {1}) int [1]
-	 *  - (int[], new int[2] {2,3}) int [2] [3]
-	 * 
-	 *  - (int[], null) or (int[], new int[0]) or (int, null) or (int, new int[0]) int [0]... or
-	 * (int[][]..., null) or (int[][]..., new int[0]) int[0][]... This is because an array instance
-	 * with no specified dimensions is not valid.
-	 *  - (int[][], new int[1] {3}) int[3][]
-	 */
-	public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int[] dimensions) throws ThrowableProxy {
-		if (type.isArray())
-			return ((IDEArrayBeanTypeProxy) type).createBeanProxyWith(dimensions); // Already an
-																				   // array type,
-																				   // just pass it
-																				   // on.
-		else {
-			// It is not an array type, so we need to get an array of this type and dimensions.
-			IDEArrayBeanTypeProxy arrayType =
-				(IDEArrayBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(type.getTypeName(), dimensions.length);
-			return arrayType.createBeanProxyWith(dimensions);
-		}
-	}
-	
-	public void releaseProxy(IBeanProxy aProxy) {
-		// Do nothing. This is more for remote proxies
-	}
-	
-	/**
-	 * createIDEBeanProxyWith method comment. This is not part of the IStandardBeanProxyFactory
-	 * interface. It is available only from IDEBeanProxyFactory so that IDE registered extensions
-	 * can wrapper a bean. They will need to get current and explicitly cast to
-	 * IDEBeanProxyFactory, so they should only be IDE types themselves.
-	 */
-	public IIDEBeanProxy createIDEBeanProxyWith(Object anObject) {
-		if (anObject == null)
-			return null;
-		return ((IDEBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(anObject.getClass())).newBeanProxy(anObject);
-	}
-	
-	/**
-	 * For the IDE Factory we will create an IDEBeanProxy using the initializationString. If the
-	 * format of the string is not one we understand, pass it onto the evaluator. The
-	 * initStringParser is passed to allow shortcut evaluation. Package protected so only
-	 * IDEBeanTypeProxies can create instances.
-	 */
-	IBeanProxy createBeanProxy(IDEBeanTypeProxy aTypeProxy, String initializationString) {
-		if (initializationString.equals("null")) //$NON-NLS-1$
-			return null; // Value is initialized as null.
-		// We have to evaluate the result of the initializationString
-		try {
-			ClassLoader pluginClassLoader = fRegistry.getPluginClassLoader();
-			Object newValue = InitializationStringParser.evaluate(initializationString, pluginClassLoader);
-			return newValue != null ? aTypeProxy.newBeanProxy(newValue) : null;
-		} catch (Exception exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-			return null;
-		}
-	}
-	
-	/**
-	 * For the IDE Factory we will create an IDEBeanProxy using the null constructor Package
-	 * protected so only IDEBeanTypeProxies can create instances.
-	 */
-	IBeanProxy createBeanProxy(IDEBeanTypeProxy aTypeProxy) {
-
-		Class beanType = aTypeProxy.fClass;
-
-		// If the beanType is a primitive, the creation will fail because you can't
-		// create a primitive without a value.
-		try {
-			return aTypeProxy.newBeanProxy(!(aTypeProxy.isPrimitive()) ? beanType.newInstance() : null);
-		} catch (Exception exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-			return null;
-		}
-	}
-	
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxyFactory#terminateFactory(boolean)
-	 */
-	public void terminateFactory(boolean wait) {
-		// Nothing really to do here - more applicable to remote proxy factories
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createExpression()
-	 */
-	public IExpression createExpression() {
-		return new IDEExpression(this.fRegistry);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createBeanProxyFrom(java.lang.String)
-	 */
-	public IBeanProxy createBeanProxyFrom(String initializationString) throws ThrowableProxy {
-		if (initializationString.equals("null")) //$NON-NLS-1$
-			return null; // Value is initialized as null.
-		// We have to evaluate the result of the initializationString
-		try {
-			ClassLoader pluginClassLoader = fRegistry.getPluginClassLoader();
-			InitializationStringParser parser = InitializationStringParser.createParser(initializationString, pluginClassLoader);
-			Object newValue = parser.evaluate();
-			if (newValue != null) {
-				return fRegistry.getBeanProxy(parser.getExpectedType(), newValue);
-			} else 
-				return null;
-		} catch (Exception exc) {
-			ProxyPlugin.getPlugin().getLogger().log(
-					new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$
-			return null;
-		}
-	}
-
-	public IBeanProxy getIVMServerProxy() {
-		return ivmServerProxy;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStandardBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStandardBeanTypeProxyFactory.java
deleted file mode 100644
index 2dfd7fb..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStandardBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,465 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-
-/*
- * $RCSfile: IDEStandardBeanTypeProxyFactory.java,v $ $Revision: 1.12 $ $Date: 2005/08/24 20:39:06 $
- */
-
-import java.lang.reflect.Array;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.text.MessageFormat;
-import java.util.*;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.proxy.common.MapTypes;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
-
-public class IDEStandardBeanTypeProxyFactory implements IStandardBeanTypeProxyFactory {
-
-	protected final IDEProxyFactoryRegistry fFactoryRegistry;
-
-	// Hashtable to cache proxies for classes so they are found on second and subsequent lookups
-	protected Map beanProxies;
-
-	public static Map MAP_SHORTSIG_TO_TYPE = new HashMap(8);
-
-	public static Map MAP_TYPENAME_TO_SHORTSIG = new HashMap(8);
-
-	static {
-		MAP_SHORTSIG_TO_TYPE.put("B", Byte.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("C", Character.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("D", Double.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("F", Float.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("I", Integer.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("J", Long.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("S", Short.TYPE); //$NON-NLS-1$
-		MAP_SHORTSIG_TO_TYPE.put("Z", Boolean.TYPE); //$NON-NLS-1$
-
-		MAP_TYPENAME_TO_SHORTSIG.put("byte", "B"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("char", "C"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("double", "D"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("float", "F"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("int", "I"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("long", "J"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("short", "S"); //$NON-NLS-1$ //$NON-NLS-2$
-		MAP_TYPENAME_TO_SHORTSIG.put("boolean", "Z"); //$NON-NLS-1$ //$NON-NLS-2$
-	}
-
-	// Cached copy of a few typical bean type proxies.
-	IDEBeanTypeProxy objectClass;
-
-	IDEBooleanTypeBeanTypeProxy booleanType;
-
-	IDEBooleanClassBeanTypeProxy booleanClass;
-
-	IDEIntegerTypeBeanTypeProxy intType;
-
-	IDEIntegerClassBeanTypeProxy integerClass;
-
-	IDEFloatTypeBeanTypeProxy floatType;
-
-	IDEFloatClassBeanTypeProxy floatClass;
-
-	IDELongTypeBeanTypeProxy longType;
-
-	IDELongClassBeanTypeProxy longClass;
-
-	IDEShortTypeBeanTypeProxy shortType;
-
-	IDEShortClassBeanTypeProxy shortClass;
-
-	IDEByteTypeBeanTypeProxy byteType;
-
-	IDEByteClassBeanTypeProxy byteClass;
-
-	IDECharTypeBeanTypeProxy charType;
-
-	IDECharacterClassBeanTypeProxy charClass;
-
-	IDEDoubleTypeBeanTypeProxy doubleType;
-
-	IDEDoubleClassBeanTypeProxy doubleClass;
-
-	IDEStringBeanTypeProxy stringClass;
-
-	IDEClassBeanTypeProxy classClass;
-
-	IDEBeanTypeProxy voidType;
-
-	public IDEStandardBeanTypeProxyFactory(IDEProxyFactoryRegistry aRegistry) {
-		fFactoryRegistry = aRegistry;
-		aRegistry.registerBeanTypeProxyFactory(this);
-
-		// Now initialize the cache.
-		objectClass = new IDEBeanTypeProxy(fFactoryRegistry, Object.class);
-		booleanType = new IDEBooleanTypeBeanTypeProxy(fFactoryRegistry, Boolean.TYPE);
-		booleanClass = new IDEBooleanClassBeanTypeProxy(fFactoryRegistry, Boolean.class);
-		intType = new IDEIntegerTypeBeanTypeProxy(fFactoryRegistry, Integer.TYPE);
-		integerClass = new IDEIntegerClassBeanTypeProxy(fFactoryRegistry, Integer.class);
-		floatType = new IDEFloatTypeBeanTypeProxy(fFactoryRegistry, Float.TYPE);
-		floatClass = new IDEFloatClassBeanTypeProxy(fFactoryRegistry, Float.class);
-		longType = new IDELongTypeBeanTypeProxy(fFactoryRegistry, Long.TYPE);
-		longClass = new IDELongClassBeanTypeProxy(fFactoryRegistry, Long.class);
-		shortType = new IDEShortTypeBeanTypeProxy(fFactoryRegistry, Short.TYPE);
-		shortClass = new IDEShortClassBeanTypeProxy(fFactoryRegistry, Short.class);
-		byteType = new IDEByteTypeBeanTypeProxy(fFactoryRegistry, Byte.TYPE);
-		byteClass = new IDEByteClassBeanTypeProxy(fFactoryRegistry, Byte.class);
-		charType = new IDECharTypeBeanTypeProxy(fFactoryRegistry, Character.TYPE);
-		charClass = new IDECharacterClassBeanTypeProxy(fFactoryRegistry, Character.class);
-		doubleType = new IDEDoubleTypeBeanTypeProxy(fFactoryRegistry, Double.TYPE);
-		doubleClass = new IDEDoubleClassBeanTypeProxy(fFactoryRegistry, Double.class);
-		stringClass = new IDEStringBeanTypeProxy(fFactoryRegistry, String.class);
-		classClass = new IDEClassBeanTypeProxy(fFactoryRegistry, java.lang.Class.class);
-		voidType = new IDEBeanTypeProxy(fFactoryRegistry, Void.TYPE);
-
-		// Initialize the hashtable with the primitives, their lang equivalents, and also common classes like String
-		beanProxies = new HashMap(20);
-
-		// Primitives
-		beanProxies.put(intType.getTypeName(), intType);
-		beanProxies.put(booleanType.getTypeName(), booleanType);
-		beanProxies.put(charType.getTypeName(), charType);
-		beanProxies.put(byteType.getTypeName(), byteType);
-		beanProxies.put(shortType.getTypeName(), shortType);
-		beanProxies.put(longType.getTypeName(), longType);
-		beanProxies.put(floatType.getTypeName(), floatType);
-		beanProxies.put(doubleType.getTypeName(), doubleType);
-
-		// java.lang primitive peers
-		// Note that special classes are used for some of these which allow the IDE to get the
-		// lang objects from the objects that are holding proxies
-		beanProxies.put(integerClass.getTypeName(), integerClass);
-		beanProxies.put(booleanClass.getTypeName(), booleanClass);
-		beanProxies.put(charClass.getTypeName(), charClass);
-		beanProxies.put(byteClass.getTypeName(), byteClass);
-		beanProxies.put(shortClass.getTypeName(), shortClass);
-		beanProxies.put(longClass.getTypeName(), longClass);
-		beanProxies.put(floatClass.getTypeName(), floatClass);
-		beanProxies.put(doubleClass.getTypeName(), doubleClass);
-		beanProxies.put(BigDecimal.class.getName(), new IDEBigDecimalBeanTypeProxy(fFactoryRegistry, BigDecimal.class));//$NON-NLS-1$
-		beanProxies.put(BigInteger.class.getName(), new IDEBigIntegerBeanTypeProxy(fFactoryRegistry, BigInteger.class));//$NON-NLS-1$		
-		beanProxies.put(stringClass.getTypeName(), stringClass);
-
-		beanProxies.put(classClass.getTypeName(), classClass);
-		beanProxies.put(voidType.getTypeName(), voidType);
-	}
-
-	/**
-	 * We are an IDE proxy and know that the type is in the same VM as the IDE. the IDEBeanTypeProxy object NOTE This is package protected because the
-	 * only person who can call it are priveledged classes that are also creating things in an IDEProxy environment. If anyone needs to make this
-	 * method public they are doing the wrong thing as they should use the public method getBeanTypeProxy(String) that is on the interface. The only
-	 * other object that can guarantee that they have the class for the argument are those that are part of the idevm package
-	 */
-	IBeanTypeProxy getBeanTypeProxy(Class anIDEClass) {
-		return getBeanTypeProxy(anIDEClass.getName());
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(java.lang.String)
-	 */
-	public synchronized IBeanTypeProxy getBeanTypeProxy(String typeName) {
-		typeName = MapTypes.getJNIFormatName(typeName);
-
-		// See whether we already have the proxy for the argument name
-		IProxyBeanType beanTypeProxy = (IProxyBeanType) beanProxies.get(typeName);
-		// See if there and resolved, if so, return it. If not resolved, that means we need it NOW
-		// so we must go for it. When finally resolved the original ExpressionProxy will be deregistered and
-		// the resolved beantypeproxy will be in its place.
-		if (beanTypeProxy != null && beanTypeProxy.isBeanProxy()) {
-			return (IBeanTypeProxy) beanTypeProxy;
-		}
-
-		// If not an array, then see if the package extension mechanism can find it.
-		// Do this here so that if it is found in the package extension we won't necessarily create an
-		// extra connection when not needed.
-		if (typeName.charAt(0) != '[') {
-			// It is not an array
-			// First check with the factory for the package of the class.
-			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
-			// the package ended and the class started.
-			int packageIndex = typeName.lastIndexOf('.');
-			if (packageIndex != -1) {
-				String packageName = typeName.substring(0, packageIndex);
-				IDEExtensionBeanTypeProxyFactory packageFactory = (IDEExtensionBeanTypeProxyFactory) fFactoryRegistry
-						.getBeanTypeProxyFactoryExtension(packageName);
-				if (packageFactory != null) {
-					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName);
-					if (beanTypeProxy != null) {
-						registerBeanTypeProxy((IBeanTypeProxy) beanTypeProxy, false);
-						return (IBeanTypeProxy) beanTypeProxy;
-					}
-				}
-			}
-			// There was not a registered factory that dealt with the class. Load it using the factory
-			// registry which has the plugin's class loader
-			try {
-				Class ideClass = fFactoryRegistry.loadClass(typeName);
-				IDEBeanTypeProxy superTypeProxy = null;
-				if (ideClass.getSuperclass() != null) {
-					// Get the beantype proxy of the superclass.
-					superTypeProxy = (IDEBeanTypeProxy) getBeanTypeProxy(ideClass.getSuperclass());
-				}
-
-				// Ask the supertype
-				// to create a beantype proxy of the same beantype proxy class.
-				// This is so that any subclasses will get the same beantype proxy class
-				// for it if it is special.
-				if (superTypeProxy != null)
-					beanTypeProxy = superTypeProxy.newBeanTypeForClass(ideClass);
-
-				if (beanTypeProxy == null)
-					beanTypeProxy = new IDEBeanTypeProxy(fFactoryRegistry, ideClass);
-			} catch (ClassNotFoundException e) {
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.INFO, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-				String msg = MessageFormat.format("{0}({1})", new Object[] { e.getClass(), e.getMessage()}); //$NON-NLS-1$
-				beanTypeProxy = new IDEInitErrorBeanTypeProxy(fFactoryRegistry, typeName, msg, e);
-			} catch (ExceptionInInitializerError e) {
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-				String msg = MessageFormat.format("{0}({1})", new Object[] { e.getClass(), e.getMessage()}); //$NON-NLS-1$
-				beanTypeProxy = new IDEInitErrorBeanTypeProxy(fFactoryRegistry, typeName, msg, e.getCause());
-			} catch (LinkageError e) {
-				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
-				String msg = MessageFormat.format("{0}({1})", new Object[] { e.getClass(), e.getMessage()}); //$NON-NLS-1$
-				beanTypeProxy = new IDEInitErrorBeanTypeProxy(fFactoryRegistry, typeName, msg, e);
-			}
-
-			// Cache the instance so we can re-use it again
-			beanProxies.put(typeName, beanTypeProxy);
-			return (IBeanTypeProxy) beanTypeProxy;
-		} else {
-			// need to create a array of this many dimensions so that we can get the appropriate class for it.
-			int dims = typeName.lastIndexOf('[') + 1;
-			Class finalComponentType = null;
-			if (typeName.charAt(dims) == 'L') {
-				// It is a class.
-				// Strip off up to the 'L', and the trailing ';'. That is the class name.
-				IDEBeanTypeProxy finalType = (IDEBeanTypeProxy) getBeanTypeProxy(typeName.substring(dims + 1, typeName.length() - 1));
-				if (finalType != null)
-					finalComponentType = finalType.fClass;
-			} else {
-				// It is a type. Need to map it.
-				finalComponentType = (Class) IDEStandardBeanTypeProxyFactory.MAP_SHORTSIG_TO_TYPE.get(typeName.substring(dims, dims + 1));
-			}
-
-			if (finalComponentType != null) {
-				Object dummyArray = Array.newInstance(finalComponentType, new int[dims]);
-				beanTypeProxy = new IDEArrayBeanTypeProxy(fFactoryRegistry, typeName, dummyArray.getClass());
-				beanProxies.put(typeName, beanTypeProxy);
-			}
-			return (IBeanTypeProxy) beanTypeProxy;
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IExpression,
-	 *      java.lang.String)
-	 */
-	public synchronized IProxyBeanType getBeanTypeProxy(IExpression expression, String typeName) {
-		typeName = MapTypes.getJNIFormatName(typeName);
-
-		// See whether we already have the proxy for the argument name
-		IProxyBeanType beanTypeProxy = (IProxyBeanType) beanProxies.get(typeName);
-		if (beanTypeProxy != null) { return beanTypeProxy; }
-		
-		// Now see if an expression proxy cached.
-		beanTypeProxy = ((IDEExpression) expression).getBeanType(typeName);
-		if (beanTypeProxy != null)
-			return beanTypeProxy;		
-
-
-		// If not an array, then see if the package extension mechanism can find it.
-		// Do this here so that if it is found in the package extension we won't necessarily create an
-		// extra connection when not needed.
-		if (typeName.charAt(0) != '[') {
-			// It is not an array
-			// First check with the factory for the package of the class.
-			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
-			// the package ended and the class started.
-			int packageIndex = typeName.lastIndexOf('.');
-			if (packageIndex != -1) {
-				String packageName = typeName.substring(0, packageIndex);
-				IDEExtensionBeanTypeProxyFactory packageFactory = (IDEExtensionBeanTypeProxyFactory) fFactoryRegistry
-						.getBeanTypeProxyFactoryExtension(packageName);
-				if (packageFactory != null) {
-					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName, expression);
-					if (beanTypeProxy != null) {
-						registerBeanTypeProxy(beanTypeProxy, false);
-						return beanTypeProxy;
-					}
-				}
-			}
-		}
-
-		// There was not a registered factory that dealt with the class. So create the expression proxy.
-		beanTypeProxy = ((Expression) expression).createBeanTypeExpressionProxy(typeName);
-		registerBeanTypeProxy(beanTypeProxy, false);
-		return beanTypeProxy;
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(java.lang.String, int)
-	 */
-	public IBeanTypeProxy getBeanTypeProxy(String componentClassName, int dimensions) {
-		return getBeanTypeProxy(getArrayClassname(componentClassName, dimensions));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IExpression,
-	 *      java.lang.String, int)
-	 */
-	public IProxyBeanType getBeanTypeProxy(IExpression expression, String componentClassName, int dimensions) {
-		return getBeanTypeProxy(expression, getArrayClassname(componentClassName, dimensions));
-	}
-
-	/**
-	 * @param componentClassName
-	 * @param dimensions
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	protected String getArrayClassname(String componentClassName, int dimensions) {
-		String jniComponentTypeName = MapTypes.getJNIFormatName(componentClassName);
-		String compType = jniComponentTypeName;
-		if (jniComponentTypeName.charAt(0) != '[') {
-			// We're not already an array, so create correct template.
-			compType = (String) MAP_TYPENAME_TO_SHORTSIG.get(componentClassName);
-			if (compType == null) {
-				// It is a class, and not a type.
-				compType = "L" + jniComponentTypeName + ";"; //$NON-NLS-1$ //$NON-NLS-2$
-			}
-		}
-		// Now create it with the appropriate number of '[' in front.
-		StringBuffer buffer = new StringBuffer(dimensions + compType.length());
-		for (int i = 0; i < dimensions; i++)
-			buffer.append('[');
-		buffer.append(compType);
-		return buffer.toString();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxyFactory#terminateFactory(boolean)
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registerBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy,
-	 *      boolean)
-	 */
-	public synchronized void registerBeanTypeProxy(IBeanTypeProxy aBeanTypeProxy, boolean permanent) {
-		beanProxies.put(aBeanTypeProxy.getTypeName(), aBeanTypeProxy);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registerBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType,
-	 *      boolean)
-	 */
-	public void registerBeanTypeProxy(IProxyBeanType aProxyBeanType, boolean permanent) {
-		if (aProxyBeanType.isBeanProxy())
-			registerBeanTypeProxy((IBeanTypeProxy) aProxyBeanType, permanent); // A regular kind, do regular registration.
-		else {
-			ExpressionProxy beanExpressionProxy = ((ExpressionProxy) aProxyBeanType);
-			final String typeName = aProxyBeanType.getTypeName();
-			((IDEExpression) beanExpressionProxy.getExpression()).addBeanType(typeName, aProxyBeanType);
-			beanExpressionProxy.addProxyListener(new ExpressionProxy.ProxyAdapter() {
-
-				public void proxyResolved(ProxyEvent event) {
-					String typeName = ((IProxyBeanType) event.getSource()).getTypeName();
-					synchronized (IDEStandardBeanTypeProxyFactory.this) {
-						if (!beanProxies.containsKey(typeName)) {
-							// It hasn't been resolved through some other means. So this is good. Actually this should never
-							// occur because upon resolution we've already registered the bean type proxy through the
-							// normal mechanisms. But to be safe, we'll do it here.
-							beanProxies.put(typeName, event.getProxy());
-						}
-					}
-				}
-				
-				public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
-					((IDEExpression) ((ExpressionProxy) event.getSource()).getExpression()).removeBeanType(typeName);
-				}
-			});
-		}
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeRegistered(String)
-	 */
-	public synchronized boolean isBeanTypeRegistered(String className) {
-		return beanProxies.containsKey(MapTypes.getJNIFormatName(className));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registeredTypes()
-	 */
-	public Set registeredTypes() {
-		return beanProxies.keySet();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeNotFound(String)
-	 */
-	public boolean isBeanTypeNotFound(String className) {
-		// Do nothing. No need for it in IDE system because there will always be a proxy, even when not found.
-		// In that case an IDEInitErrorBeanTypeProxy will be created.
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isMaintainNotFoundTypes()
-	 */
-	public boolean isMaintainNotFoundTypes() {
-		// Do nothing. No need for it in IDE system because there will always be a proxy, even when not found.
-		// In that case an IDEInitErrorBeanTypeProxy will be created.
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#setMaintainNotFoundTypes(boolean)
-	 */
-	public void setMaintainNotFoundTypes(boolean maintain) {
-		// Do nothing. No need for it in IDE system because there will always be a proxy, even when not found.
-		// In that case an IDEInitErrorBeanTypeProxy will be created.
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStringBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStringBeanProxy.java
deleted file mode 100644
index e2d3fff..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStringBeanProxy.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEStringBeanProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-/**
- * IDE Implementation of IStringBeanProxy
- * Creation date: (2/6/00 9:02:42 AM)
- * @author: Joe Winchester
- */
-final class IDEStringBeanProxy extends IDEObjectBeanProxy implements IStringBeanProxy {
-	protected String fString;
-/**
- * Store the bean in the string field to save re-casting each time it is asked for.
- * It is package protected because they are created
- * in a special way and no one else should create them.
- */
-IDEStringBeanProxy(IDEProxyFactoryRegistry aRegistry, Object aBean, IBeanTypeProxy aBeanTypeProxy) {
-	super(aRegistry, aBean,aBeanTypeProxy);
-	fString = (String)aBean;
-}
-/**
- * Return the cache'd string that is a java.lang.String that the IDE can use
- */
-public String stringValue() {
-	return fString;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStringBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStringBeanTypeProxy.java
deleted file mode 100644
index 9dd1630..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEStringBeanTypeProxy.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEStringBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.IStringBeanProxy;
-/**
- * IDE Implementation of the BeanType proxy for java.lang.String
- */
-final class IDEStringBeanTypeProxy extends IDEBeanTypeProxy {
-	// Cache a proxy to an empty string for speed
-	protected final IDEStringBeanProxy emptyStringProxy;
-
-IDEStringBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class aClass) {
-	super(aRegistry, aClass);
-	// Cache a proxy to an empty string for speed
-	emptyStringProxy = new IDEStringBeanProxy(aRegistry, "",this);	//$NON-NLS-1$
-}
-/**
- * Helper to create string beans
- * Package protected because no-one else outside the package should use this, they
- * must go through the API where you look up a factory first.
- */
-IStringBeanProxy createStringBeanProxy(String aString){
-	if ( aString.equals("") ) {//$NON-NLS-1$
-		return emptyStringProxy;
-	} else {
-		return new IDEStringBeanProxy(fProxyFactoryRegistry,aString,this);
-	}
-}
-/* Specialized from IDEBeanTypeProxy to ensure IStringBeanProxies are created correctly
- */
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return (IIDEBeanProxy)createStringBeanProxy( (String)anObject );
-
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEThrowableProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEThrowableProxy.java
deleted file mode 100644
index 5830d1b..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEThrowableProxy.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEThrowableProxy.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.*;
-
-public class IDEThrowableProxy extends ThrowableProxy implements IIDEBeanProxy {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = 7162757961175978338L;
-	protected IBeanTypeProxy fBeanTypeProxy;
-
-	protected IDEThrowableProxy(Throwable exc, IBeanTypeProxy aBeanTypeProxy) {
-		super(exc);
-		fBeanTypeProxy = aBeanTypeProxy;
-	}
-
-	public boolean equals(Object obj) {
-		if (super.equals(obj))
-			return true;
-		if (obj instanceof IIDEBeanProxy) {
-			return getCause().equals(((IIDEBeanProxy) obj).getBean());
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxy#sameAs(org.eclipse.jem.internal.proxy.core.IBeanProxy)
-	 */
-	public boolean sameAs(IBeanProxy aBeanProxy) {
-		if (this == aBeanProxy)
-			return true;
-		if (aBeanProxy instanceof IIDEBeanProxy)
-			return getCause() == ((IIDEBeanProxy) aBeanProxy).getBean();
-		return false;
-	}
-
-	public String getProxyLocalizedMessage() {
-		return getCause().getLocalizedMessage();
-	}
-	public String getProxyMessage() {
-		return getCause().getMessage();
-	}
-	public void printProxyStackTrace(java.io.PrintWriter writer) {
-		getCause().printStackTrace(writer);
-	}
-	public void printProxyStackTrace(java.io.PrintStream stream) {
-		getCause().printStackTrace(stream);
-	}
-	public void printProxyStackTrace() {
-		getCause().printStackTrace();
-	}
-	public IBeanTypeProxy getTypeProxy() {
-		return fBeanTypeProxy;
-	}
-	public ProxyFactoryRegistry getProxyFactoryRegistry() {
-		return fBeanTypeProxy.getProxyFactoryRegistry();
-	}
-	public String toBeanString() {
-		return getCause().toString();
-	}
-	public boolean isValid() {
-		return true;
-	}
-	/**
-	 * Return the exception which is the live bean
-	 */
-	public Object getBean() {
-		return getCause();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
-	 */
-	public final boolean isBeanProxy() {
-		return true;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
-	 */
-	public final boolean isExpressionProxy() {
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEVMServer.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEVMServer.java
deleted file mode 100644
index afc29a4..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEVMServer.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IDEVMServer.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import java.io.OutputStream;
-
-import org.eclipse.jem.internal.proxy.common.*;
-
-public class IDEVMServer implements IVMCallbackServer {
-	
-	IDECallbackRegistry fCallbackRegistry;
-	IDEStandardBeanProxyFactory fBeanProxyFactory;
-	
-IDEVMServer(IDECallbackRegistry aCallbackRegistry){
-	fCallbackRegistry = aCallbackRegistry;
-	fBeanProxyFactory = (IDEStandardBeanProxyFactory)fCallbackRegistry.fProxyFactoryRegistry.getBeanProxyFactory();
-	
-}	
-public Object doCallback(ICallbackRunnable aRunnable){
-	try {
-		return aRunnable.run(new ICallbackHandler(){
-			public Object callbackWithParms(int callbackID, int msgID, Object[] parms){
-				// We are running in the same IDE so just call the registry directly
-				// although we must convert the parms to bean proxies
-				Object[] proxyParms = null;
-				// If we have any parms then convert them to bean proxies
-				if ( parms != null ) {
-					proxyParms = new Object[parms.length];
-					for ( int i=0;i<parms.length;i++){
-						Object p = parms[i];
-						proxyParms[i] = createNextParm(p);
-					}
-				}
-				return fCallbackRegistry.vmCallback(callbackID,msgID,proxyParms);
-			}
-
-			private Object createNextParm(Object p) {
-				if (!(p instanceof ICallbackHandler.TransmitableArray)) {
-					return fBeanProxyFactory.createIDEBeanProxyWith(p);
-				} else {
-					Object[] array = ((ICallbackHandler.TransmitableArray) p).getArray();
-					Object[] parm = new Object[array.length];
-					for (int i = 0; i < array.length; i++) {
-						parm[i] = createNextParm(array[i]);
-					}
-					return parm;
-				}
-			}
-			
-			/* (non-Javadoc)
-			 * @see org.eclipse.jem.internal.proxy.common.ICallbackHandler#callbackAsConstants(int, int, java.lang.Object)
-			 */
-			public Object callbackAsConstants(int callbackID, int msgID, Object parm) throws CommandException {
-				return fCallbackRegistry.vmCallback(callbackID,msgID,parm);
-			}
-		});
-		
-	} catch ( CommandException exc ) {
-		return null;	
-	}
-}
-
-public OutputStream requestStream(int callbackID, int msgID) throws CommandException {
-	return fCallbackRegistry.requestStream(callbackID,msgID);
-}
-public IVMServer getIVMServer() {
-	return fCallbackRegistry.fProxyFactoryRegistry;
-}
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IIDEBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IIDEBeanProxy.java
deleted file mode 100644
index fb2bae5..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IIDEBeanProxy.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide;
-/*
- *  $RCSfile: IIDEBeanProxy.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:06 $ 
- */
-
-import org.eclipse.jem.internal.proxy.core.IBeanProxy;
-
-
-/**
- * Interface that allows the IDE VM to get the actual bean.
- */
-public interface IIDEBeanProxy extends IBeanProxy {
-/**
- * Get the actual live bean. 
- * USE with extreme care.
- */
-public Object getBean();
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEDimensionBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEDimensionBeanProxy.java
deleted file mode 100644
index 1ceb065..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEDimensionBeanProxy.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDEDimensionBeanProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.awt.Dimension;
-
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-import org.eclipse.jem.internal.proxy.core.IDimensionBeanProxy;
-import org.eclipse.jem.internal.proxy.ide.IDEObjectBeanProxy;
-import org.eclipse.jem.internal.proxy.ide.IDEProxyFactoryRegistry;
-
-public class IDEDimensionBeanProxy extends IDEObjectBeanProxy implements IDimensionBeanProxy {
-	
-	protected Dimension fDimension;
-
-IDEDimensionBeanProxy(IDEProxyFactoryRegistry aRegistry,Object aDimension, IBeanTypeProxy aBeanTypeProxy){
-	super(aRegistry,aDimension,aBeanTypeProxy);
-	fDimension = (Dimension)aDimension;
-}
-public int getWidth(){
-	return fDimension.width;
-}
-public void setWidth(int aWidth){
-	fDimension.width = aWidth;
-}
-public int getHeight(){
-	return fDimension.height;
-}
-public void setHeight(int aHeight){
-	fDimension.height = aHeight;
-}
-public void setSize(IDimensionBeanProxy aBeanProxy){
-	fDimension.setSize(new Dimension(aBeanProxy.getWidth(),aBeanProxy.getHeight()));
-}
-public void setSize(int width, int height){
-	fDimension.width = width;
-	fDimension.height = height;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEDimensionBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEDimensionBeanTypeProxy.java
deleted file mode 100644
index ca38a85..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEDimensionBeanTypeProxy.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDEDimensionBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.awt.Dimension;
-
-import org.eclipse.jem.internal.proxy.ide.*;
-
-public class IDEDimensionBeanTypeProxy extends IDEBeanTypeProxy {
-
-IDEDimensionBeanTypeProxy(IDEProxyFactoryRegistry aRegistry){
-	this(aRegistry,Dimension.class);
-}
-
-private IDEDimensionBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class type){
-	super(aRegistry, type);
-}
-
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return new IDEDimensionBeanProxy(fProxyFactoryRegistry, anObject, this);
-
-}
-IDEDimensionBeanProxy createDimensionBeanProxy(int width, int height){
-	return new IDEDimensionBeanProxy(fProxyFactoryRegistry,new Dimension(width,height),this);
-}
-	/*
-	 * @see IDEBeanTypeProxy#newBeanTypeForClass(Class)
-	 */
-	public IDEBeanTypeProxy newBeanTypeForClass(Class type) {
-		return new IDEDimensionBeanTypeProxy(fProxyFactoryRegistry, type);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEPointBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEPointBeanProxy.java
deleted file mode 100644
index 6b074cd..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEPointBeanProxy.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDEPointBeanProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.awt.Point;
-
-import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
-import org.eclipse.jem.internal.proxy.core.IPointBeanProxy;
-import org.eclipse.jem.internal.proxy.ide.IDEObjectBeanProxy;
-import org.eclipse.jem.internal.proxy.ide.IDEProxyFactoryRegistry;
-
-public class IDEPointBeanProxy extends IDEObjectBeanProxy implements IPointBeanProxy {
-	
-	protected Point fPoint;
-
-IDEPointBeanProxy(IDEProxyFactoryRegistry aRegistry,Object aPoint, IBeanTypeProxy aBeanTypeProxy){
-	super(aRegistry,aPoint,aBeanTypeProxy);
-	fPoint = (Point)aPoint;
-}
-public int getX(){
-	return fPoint.x;
-}
-public void setX(int anX){
-	fPoint.x = anX;
-}
-public int getY(){
-	return fPoint.y;
-}
-public void setY(int aY){
-	fPoint.y = aY;
-}
-public void setLocation(IPointBeanProxy aBeanProxy){
-	fPoint.setLocation(new Point(aBeanProxy.getX(),aBeanProxy.getY()));
-}
-public void setLocation(int anX, int aY){
-	fPoint.x = anX;
-	fPoint.y = aY;
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEPointBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEPointBeanTypeProxy.java
deleted file mode 100644
index 3d2426d..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEPointBeanTypeProxy.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDEPointBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.awt.Point;
-
-import org.eclipse.jem.internal.proxy.ide.*;
-
-public class IDEPointBeanTypeProxy extends IDEBeanTypeProxy {
-
-IDEPointBeanTypeProxy(IDEProxyFactoryRegistry aRegistry){
-	this(aRegistry,Point.class);
-}
-private IDEPointBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class type){
-	super(aRegistry,type);
-}
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return new IDEPointBeanProxy(fProxyFactoryRegistry, anObject, this);
-
-}
-IDEPointBeanProxy createPointBeanProxy(int x, int y){
-	return new IDEPointBeanProxy(fProxyFactoryRegistry,new Point(x,y),this);
-}
-	/*
-	 * @see IDEBeanTypeProxy#newBeanTypeForClass(Class)
-	 */
-	public IDEBeanTypeProxy newBeanTypeForClass(Class type) {
-		return new IDEPointBeanTypeProxy(fProxyFactoryRegistry, type);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERectangleBeanProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERectangleBeanProxy.java
deleted file mode 100644
index 27ad5e3..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERectangleBeanProxy.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDERectangleBeanProxy.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.awt.Rectangle;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.ide.IDEObjectBeanProxy;
-import org.eclipse.jem.internal.proxy.ide.IDEProxyFactoryRegistry;
-
-public class IDERectangleBeanProxy extends IDEObjectBeanProxy implements IRectangleBeanProxy {
-	
-	protected Rectangle fRectangle;
-
-IDERectangleBeanProxy(IDEProxyFactoryRegistry aRegistry,Object aRectangle, IBeanTypeProxy aBeanTypeProxy){
-	super(aRegistry,aRectangle,aBeanTypeProxy);
-	fRectangle = (Rectangle)aRectangle;
-}
-public int getX(){
-	return fRectangle.x;
-}
-public void setX(int anX){
-	fRectangle.x = anX;
-}
-public int getY(){
-	return fRectangle.y;
-}
-public void setY(int aY){
-	fRectangle.y = aY;
-}
-public int getHeight(){
-	return fRectangle.height;
-}
-public void setHeight(int aHeight){
-	fRectangle.height = aHeight;
-}
-public void setWidth(int aWidth){
-	fRectangle.width = aWidth;
-}
-public int getWidth(){
-	return fRectangle.width;
-}
-public void setBounds(IRectangleBeanProxy aBeanProxy){
-	fRectangle.setBounds(aBeanProxy.getX(),aBeanProxy.getY(),aBeanProxy.getWidth(),aBeanProxy.getHeight());
-}
-public void setBounds(int x, int y, int width, int height){
-	fRectangle.setBounds(x,y,width,height);
-}
-public void setSize(IDimensionBeanProxy aBeanProxy){
-	fRectangle.setSize(aBeanProxy.getWidth(),aBeanProxy.getWidth());
-}
-public void setLocation(IPointBeanProxy aBeanProxy){
-	fRectangle.setLocation(aBeanProxy.getX(),aBeanProxy.getY());
-}
-public void setLocation(int x, int y){
-	fRectangle.setLocation(x,y);
-}
-public void setSize(int width, int height){
-	fRectangle.setSize(width,height);
-}
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERectangleBeanTypeProxy.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERectangleBeanTypeProxy.java
deleted file mode 100644
index f076870..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERectangleBeanTypeProxy.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDERectangleBeanTypeProxy.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-import java.awt.Rectangle;
-
-import org.eclipse.jem.internal.proxy.ide.*;
-
-public class IDERectangleBeanTypeProxy extends IDEBeanTypeProxy {
-
-IDERectangleBeanTypeProxy(IDEProxyFactoryRegistry aRegistry){
-	this(aRegistry,Rectangle.class);
-}
-
-private IDERectangleBeanTypeProxy(IDEProxyFactoryRegistry aRegistry, Class type){
-	super(aRegistry,type);
-}
-protected IIDEBeanProxy newBeanProxy(Object anObject){
-
-	return new IDERectangleBeanProxy(fProxyFactoryRegistry, anObject, this);
-
-}
-IDERectangleBeanProxy createRectangleBeanProxy(int x, int y, int width, int height){
-	return new IDERectangleBeanProxy(fProxyFactoryRegistry,new Rectangle(x,y,width,height),this);
-}
-	/*
-	 * @see IDEBeanTypeProxy#newBeanTypeForClass(Class)
-	 */
-	public IDEBeanTypeProxy newBeanTypeForClass(Class type) {
-		return new IDERectangleBeanTypeProxy(fProxyFactoryRegistry, type);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERegisterAWT.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERegisterAWT.java
deleted file mode 100644
index c2fb0e8..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDERegisterAWT.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDERegisterAWT.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.ide.IDEProxyFactoryRegistry;
-/**
- * This class is used to register the AWT factories.
- */
-public final class IDERegisterAWT {
-	public static void registerAWT(IDEProxyFactoryRegistry registry) {
-		new IDEStandardAWTBeanTypeProxyFactory(registry);
-		new IDEStandardAWTBeanProxyFactory(registry);
-	}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEStandardAWTBeanProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEStandardAWTBeanProxyFactory.java
deleted file mode 100644
index bb48c8c..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEStandardAWTBeanProxyFactory.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.ide.awt;
-/*
- *  $RCSfile: IDEStandardAWTBeanProxyFactory.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-
-
-import org.eclipse.jem.internal.proxy.awt.*;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.ide.IDEProxyFactoryRegistry;
-/**
- * Standard AWT Bean Proxy Factory.
- * Package protected because it should not referenced
- * outside of the package other than through the interface.
- */
-class IDEStandardAWTBeanProxyFactory implements IStandardAwtBeanProxyFactory {
-
-	final IDEStandardAWTBeanTypeProxyFactory fAWTBeanTypeFactory;
-	
-public IDEStandardAWTBeanProxyFactory(IDEProxyFactoryRegistry factory) {
-	factory.registerBeanProxyFactory(IStandardAwtBeanProxyFactory.REGISTRY_KEY, this);
-	fAWTBeanTypeFactory = (IDEStandardAWTBeanTypeProxyFactory)factory.getBeanTypeProxyFactoryExtension(IDEStandardAWTBeanTypeProxyFactory.BEAN_TYPE_FACTORY_KEY);
-}
-public IDimensionBeanProxy createDimensionBeanProxyWith(int width, int height){
-	return fAWTBeanTypeFactory.dimensionType.createDimensionBeanProxy(width,height);
-}
-
-public IPointBeanProxy createPointBeanProxyWith(int x, int y){
-	return fAWTBeanTypeFactory.pointType.createPointBeanProxy(x,y);
-}
-public IRectangleBeanProxy createBeanProxyWith(int x, int y, int width, int height){
-	return fAWTBeanTypeFactory.rectangleType.createRectangleBeanProxy(x,y,width,height);
-}
-public void terminateFactory(boolean wait) {
-}
-}
-
diff --git a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEStandardAWTBeanTypeProxyFactory.java b/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEStandardAWTBeanTypeProxyFactory.java
deleted file mode 100644
index 686709f..0000000
--- a/plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/awt/IDEStandardAWTBeanTypeProxyFactory.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IDEStandardAWTBeanTypeProxyFactory.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:07 $ 
- */
-package org.eclipse.jem.internal.proxy.ide.awt;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.ide.*;
-
-/**
- * BeanType factory standard AWT bean types. This is package protected because it shouldn't be referenced outside the package. It should only be
- * accessed through the interface.
- */
-class IDEStandardAWTBeanTypeProxyFactory implements IDEExtensionBeanTypeProxyFactory {
-
-	static final String BEAN_TYPE_FACTORY_KEY = "java.awt"; //$NON-NLS-1$
-
-	protected final IDEProxyFactoryRegistry fFactoryRegistry;
-
-	protected final IDEDimensionBeanTypeProxy dimensionType;
-
-	protected final IDEPointBeanTypeProxy pointType;
-
-	protected final IDERectangleBeanTypeProxy rectangleType;
-
-	IDEStandardAWTBeanTypeProxyFactory(IDEProxyFactoryRegistry aRegistry) {
-		fFactoryRegistry = aRegistry;
-		fFactoryRegistry.registerBeanTypeProxyFactory(BEAN_TYPE_FACTORY_KEY, this);
-		dimensionType = new IDEDimensionBeanTypeProxy(fFactoryRegistry);
-		pointType = new IDEPointBeanTypeProxy(fFactoryRegistry);
-		rectangleType = new IDERectangleBeanTypeProxy(fFactoryRegistry);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.ide.IDEExtensionBeanTypeProxyFactory#getExtensionBeanTypeProxy(java.lang.String)
-	 */
-	public IDEBeanTypeProxy getExtensionBeanTypeProxy(String className) {
-
-		if ("java.awt.Dimension".equals(className)) //$NON-NLS-1$
-			return dimensionType;
-		else if ("java.awt.Point".equals(className)) //$NON-NLS-1$
-			return pointType;
-		else if ("java.awt.Rectangle".equals(className)) //$NON-NLS-1$
-			return rectangleType;
-		else
-			return null;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.ide.IDEExtensionBeanTypeProxyFactory#getExtensionBeanTypeProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IBeanTypeProxy)
-	 */
-	public IDEBeanTypeProxy getExtensionBeanTypeProxy(String className, IBeanTypeProxy beanTypeProxy) {
-
-		return getExtensionBeanTypeProxy(className);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.proxy.ide.IDEExtensionBeanTypeProxyFactory#getExtensionBeanTypeProxy(java.lang.String,
-	 *      org.eclipse.jem.internal.proxy.core.IExpression)
-	 */
-	public IProxyBeanType getExtensionBeanTypeProxy(String typeName, IExpression expression) {
-		return getExtensionBeanTypeProxy(typeName);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxyFactory#terminateFactory(boolean)
-	 */
-	public void terminateFactory(boolean wait) {
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/CommandErrorException.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/CommandErrorException.java
deleted file mode 100644
index fe2b142..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/CommandErrorException.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common.remote;
-/*
- *  $RCSfile: CommandErrorException.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-/**
- * An error return from a command. This is clean return in that
- * the connection is still valid and alive.
- * After it has been processed the data will be the value retrieved
- * out of the valueobject and made into a proxy.
- */
-public class CommandErrorException extends CommandException {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = 1701752035606593305L;
-	private final Object fErrorObject;
-	private final int fErrorCode;
-	
-	public CommandErrorException(int errorCode, Commands.ValueObject errorData) {
-		super(errorData.clone());	// Clone it because typically these get reused and cleared out. This way we have our own.
-		fErrorObject = null;
-		fErrorCode = errorCode;
-	}
-	
-	public CommandErrorException(String msg, int errorCode, Commands.ValueObject errorData, Object errorObject) {
-		super(msg, errorData.clone());
-		fErrorObject = errorObject;
-		fErrorCode = errorCode;		
-	}
-	
-	public Commands.ValueObject getValue() {
-		return (Commands.ValueObject) getExceptionData();
-	}
-		
-	public boolean isRecoverable() {
-		return true;	// Command errors are recoverable.
-	}
-	
-	/**
-	 * Return the error code.
-	 */
-	public int getErrorCode() {
-		return fErrorCode;
-	}
-	
-	/**
-	 * Return the error object after conversion to proxy format.
-	 */
-	public Object getErrorObject() {
-		return fErrorObject;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		return super.toString() + "-- Error code:"+getErrorCode() + (getValue() != null ? " Value data:\"" + getValue().getAsObject() + "\"" : " ") + (fErrorObject != null ? " Error object:\""+fErrorObject.toString()+"\"" : " "); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/Commands.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/Commands.java
deleted file mode 100644
index 9850f31..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/Commands.java
+++ /dev/null
@@ -1,1450 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common.remote;
-/*
- *  $RCSfile: Commands.java,v $
- *  $Revision: 1.15 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import java.io.*;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-/**
- * The commands that can be passed back and forth between
- * client and server. And other constants.
- *
- * - Contains helper methods for reading/writing commands.
- */
-public class Commands {
-	// The commands will be written in writeByte format .
-	public final static byte
-		GET_CLASS = 1,		// Get the class object,
-		VALUE = 2,		// Returning a value
-		QUIT_CONNECTION = 4,	// Close this connection
-		TERMINATE_SERVER = 5,	// Terminate the entire server.
-		ERROR = 6,		// Returning an error
-		RELEASE_OBJECT = 7,	// An object is no longer needed on the client side, so
-					// it can be removed from the server id table and released.
-		GET_CLASS_RETURN = 8,	// The return command from GET_CLASS
-		// Obsolete, not used anymore GET_METHOD = 9,	// Return the id for a method
-		// Obsolete, not used anymore GET_CTOR = 10,		// Return the id for a constructor		
-		NEW_INIT_STRING = 11,	// Create a new bean using the init string
-		GET_CLASS_FROM_ID = 12,	// We have an ID, return the class info for this id.
-		GET_CLASS_ID_RETURN = 13,	// The return command from GET_CLASS_FROM_ID
-		GET_OBJECT_DATA = 14,	// We have an ID, but we don't have the info, return it. This is a 
-					// corrective command only. This would happen if for some strange
-					// reason the proxy has been removed but has not been released. This
-					// really shouldn't happen except as a possible race condition between
-					// GC and returning id from the server.
-		INVOKE = 15,		// Invoke a method.
-	
-	
-		// These commands are to the Master Server thread in the IDE.
-		ALIVE = 16,	// Are you alive?
-		REMOTE_STARTED = 17,	// Remote VM has started.
-		ATTACH_CALLBACK = 18,	// Attach to a callback thread on the IDE side. The remote vm will use its socket as the callback socket.
-								// it will return boolean <code>true</code> if attach worked or <code>false</code> if it failed.
-
-		// These are more regular commands. They were historically added after the master server thread commands, so
-		// they are shown here after them and with numbers greater than them.
-		EXPRESSION_TREE_COMMAND = 19,	// An expression tree subcommand has come in.
-		INVOKE_WITH_METHOD_PASSED = 20,	// Invoke where the description of the method is passed in with the command.
-		GET_ARRAY_CONTENTS = 21;	// Get the first dimension contents as an array of ids and send them back.
-	
-		
-	// Callback commands
-	public final static byte
-		CALLBACK = (byte) 255,	// A callback has come in.
-		CALLBACK_DONE = (byte) 254,	// A callback done command, sent to the remote vm upon callback completion.
-		CALLBACK_STREAM = (byte) 253,	// A callback for a byte stream has come in.
-								// This is a special callback. When this comes in a special
-								// input stream will be created that will take over control of
-								// the connection until the stream is terminated on the remote
-								// side. At this time the connection will be returned.
-		CALLBACK_STREAM_TERMINATE = (byte) 252;	// A callback stream is asked to terminate early.
-		
-	// The error values from the command on the server.
-	public final static int
-		NO_ERROR = 0,				// No error status.
-		UNKNOWN_COMMAND_SENT = 1,	// An unknown command was sent to the server. Value is void.
-		GET_CLASS_NOT_FOUND = 2,	// The class was not found in GetClass. Value is void.
-		CANNOT_EVALUATE_STRING = 3,	// Evaluator couldn't evaluate the init string. Too complicated. Value is a throwable of the wrappered Init string error.
-		CLASS_CAST_EXCEPTION = 4,	// The result is not assignable to the expected type. Value is void.
-		GET_METHOD_NOT_FOUND = 5,	// Method requested wasn't found. Value is void.
-		THROWABLE_SENT = 6,			// A Throwable is being sent back as the error, not as just data for the error. Value is the Throwable.
-		CALLBACK_RUNTIME_EXCEPTION = 7,	// A runtime exception occurred during a callback. The data is the message.
-		CALLBACK_NOT_REGISTERED = 8,
-		MAX_ERROR_CODE = CALLBACK_NOT_REGISTERED;	// This is just the max code. Not actually sent. Used as a flag.
-		
-	// Predefined standard id's for standard classes/objects. Both sides will assume these id's have been assigned
-	// to these classes/types/objects
-	public final static int
-		NOT_AN_ID = -1,	// This value means it is not an id. It is never a valid id.
-		VOID_TYPE = 0,
-		BOOLEAN_TYPE = 1,
-		BOOLEAN_CLASS = 2,
-		INTEGER_TYPE = 3,
-		INTEGER_CLASS = 4,
-		BYTE_TYPE = 5,
-		BYTE_CLASS = 6,
-		CHARACTER_TYPE = 7,
-		CHARACTER_CLASS = 8,
-		DOUBLE_TYPE = 9,
-		DOUBLE_CLASS = 10,
-		FLOAT_TYPE = 11,
-		FLOAT_CLASS = 12,
-		SHORT_TYPE = 13,
-		SHORT_CLASS = 14,
-		LONG_TYPE = 15,
-		LONG_CLASS = 16,
-		STRING_CLASS = 17,
-		BIG_DECIMAL_CLASS = 18,
-		BIG_INTEGER_CLASS = 19,
-		NUMBER_CLASS = 20,
-		THROWABLE_CLASS = 21,
-		CLASS_CLASS = 22,
-		OBJECT_CLASS = 23,
-		ACCESSIBLEOBJECT_CLASS = 24,
-		METHOD_CLASS = 25,
-		FIELD_CLASS = 26,
-		CONSTRUCTOR_CLASS = 27,
-		GET_METHOD_ID = 28,	// Class.getMethod(...) predefined id.
-		IVMSERVER_CLASS = 29,	// IVMServer.class
-		ICALLBACK_CLASS = 30,	// ICallback.class
-		REMOTESERVER_ID = 31,	// id of RemoteVMServerThread instance.
-		REMOTEVMSERVER_CLASS = 32,	// RemoteVMServer.class
-		INITIALIZECALLBACK_METHOD_ID = 33,	// ICallback.initializeCallback method.
-		THREAD_CLASS = 34,
-		EXPRESSIONPROCESSERCONTROLLER_CLASS = 35,
-		FIRST_FREE_ID = 36;
-				
-	// The type flags written in writeByte format
-	public final static byte
-		VOID = VOID_TYPE,	// null - nothing follows
-		BYTE = BYTE_TYPE,	// byte - writeByte
-		L_BYTE = BYTE_CLASS,	// java.lang.Byte - writeByte
-		CHAR = CHARACTER_TYPE,	// char - writeChar
-		L_CHAR = CHARACTER_CLASS,	// java.lang.Character - writeChar
-		DOUBLE = DOUBLE_TYPE,	// double - writeDouble
-		L_DOUBLE = DOUBLE_CLASS,	// java.lang.Double - writeDouble
-		FLOAT = FLOAT_TYPE,	// float - writeFloat
-		L_FLOAT = FLOAT_CLASS,	// java.lang.Float - writeFloat
-		INT = INTEGER_TYPE,	// int - writeInt
-		L_INT = INTEGER_CLASS,	// java.lang.Integer - writeInt
-		LONG = LONG_TYPE,	// long - writeLong
-		L_LONG = LONG_CLASS,	// java.lang.Long - writeLong
-		SHORT = SHORT_TYPE,	// short - writeShort
-		L_SHORT = SHORT_CLASS,	// java.lang.Short - writeShort
-		BOOL = BOOLEAN_TYPE,	// boolean - writeBoolean
-		L_BOOL = BOOLEAN_CLASS,	// java.lang.Boolean - writeBoolean
-		STRING = STRING_CLASS,	// java.lang.String - writeUTF
-		OBJECT = OBJECT_CLASS,	// Object - special, see below (Object can be used to return an array (except if the array contains any object_ids, that has a special type)
-		OBJECT_ID = 50,	// Object identity key - writeInt
-		NEW_OBJECT_ID = 51,	// New Object identity (this is a new object that didn't exist before)
-		THROW = 52,	// An exception occured. The value is a throwable, it is of the same format as NEW_OBJECT_ID.
-		ARRAY_IDS = 53,	// An array of values, where there are at least one ID in the array. If there were no
-						// ID's (i.e. all just values), then use OBJECT type intead and have it written as
-						// writeObject.
-		FLAG = 54;	// The value is a flag int. If this is allowed on a read, the anInt field will contain the flag value.
-				
-		
-		
-	// Unless specified below, the commands are one byte long.
-	// Also, unless specified below, the commands do not return a confirmation response.
-	//
-	// NOTE: VERY IMPORTANT, after every command, flush() should be used so that the
-	// the data is immediately sent to the server. 	
-	//
-	// n means int (e.g. 1)
-	// nb means byte (e.g. 1b)
-	// 'x' means Unicode char (i.e. writeChar())
-	// "xxx" means UTF8 string (i.e. writeUTF)
-	// bool means a one byte boolean value
-	//
-	// The commas aren't actually written, they are used as separaters in the comments below
-	//
-	// GET_CLASS: 1b, "classname"
-	//		Will return on the output stream GET_CLASS_RETURN command:
-	//		8b, n1, bool1, bool2, "superclassname"
-	//		The "n1" is the class id.
-	//		The bool1 is whether this class is an interface (true if it is).
-	//		The bool2 is whether this class is abstract (true if it is).	
-	//		The "superclassname" is the class name of the super class (0 length if no superclass)
-	//		If the class is not found, then it will return an error with a value for the error.
-	//
-	// GET_CLASS_FROM_ID: 12b, n
-	//		Where "n" is the class id.
-	//		Will return on the output stream GET_CLASS_ID_RETURN command:	
-	//		13b, "classname", bool1, bool2, "superclassname"
-	//		The bool1 is whether this class is an interface (true if it is).
-	//		The bool2 is whether this class is abstract (true if it is).	
-	//
-	// VALUE: 2b, tb, value
-	//		Where tb is the type in byte, and value is the appropriate value shown in
-	//		table above.
-	//		OBJECT_ID: 50b, n
-	//			Where "n" is the object id.
-	//		NEW_OBJECT_ID: 51b, n1, n2
-	//			Where "n1" is class ObjectID of the object that the object_id ("n2") is made of.
-	//		OBJECT: 19b, n, writeObject
-	//			Where "n" is the classObjectID of the class of the type of the object.
-	//			NOTE: Object should be used only very rarely. Identity is lost, i.e.
-	//			a copy is made each time and it can't be referenced back on the remote
-	//			VM.
-	//		ARRAY_IDS: 52b, id, n, [tb, value, ...]
-	//			This is a very special array. It contains at least one ID. Therefor all of the 
-	//			First level entries are value objects. 
-	//			"id" is the id of the component type of the array(e.g. id for Object, or if multi-dimensional String[] (this will produce String[][]).
-	//			"n" is the number of entries in the array. Followed by the values, one of the
-	//			values could be an ARRAY_IDS too. The reading/writing of these are special because
-	//			there is a callback mechanism to process the individual entries. This is so that
-	//			temp arrays of ValueObjects won't need to be created to handle this, so it can
-	//			go directly from the array to/from the stream.
-	//		
-	// RELEASE_OBJECT: 7b, n
-	//		Where the n is the object id to release. There is no confirmation to read back.
-	//
-	// ERROR: 6b, n, tb, ...
-	//      n is the error code for this error.
-	//		tb is a type flag, followed by the value. The value is dependent upon
-	//		the command that this is error is from. If a THROW, then the THROW is ALWAYS a new
-	//		ID, it can never be an existing id.
-	//      
-	//
-	// TO_BEAN_STRING: 9b, n
-	//		Where n is the object id to produce the bean string for.
-	//		It will return a VALUE command where the type is String.
-	//
-	// NEW_INSTANCE: 10b, n
-	//		Where n is the class object id of the class to create a new instance of using the default ctor.
-	//		It will return either a VALUE command containing the new value (of type OBJECT_ID/NEW_OBJECT_ID if not
-	//		one of the constant types with the true classID in it) or an ERROR command. (The ERROR could
-	//		be a THROW type). If the object created is not assignable to the type passed in, then
-	//		an ERROR is returned with CLASS_CAST_EXCEPTION flag.
-	//
-	// NEW_INIT_STRING: 11b, n, "initstring"
-	//		Where n is the class object id of the class this initstring is supposed to create for.
-	//		It will return either a VALUE command containing the new value (of type OBJECT_ID/NEW_OBJECT_ID if not
-	//		one of the constant types with the true classID in it) or an ERROR command. (The ERROR could
-	//		be a THROW type). The error could also be CANNOT_EVALUATE_STRING. This means that the string was too
-	//		complicated for the evaluator and needs to be compiled and tried again. (TBD)
- 	//		If the object created is not assignable to the type passed in, then
-	//		an ERROR is returned with CLASS_CAST_EXCEPTION flag.
-	//
-	// GET_OBJECT_DATA: 14b, n
-	//		Where n is the id of the object being requested. It will return a NEW_OBJECT_ID value with the info.
-	//
-	// GET_METHOD: 9b, classId, "methodName", n1, [n2]...
-	//		Where classID is the id of the class the method should be found in.
-	//		Where n1 is the number of parm types following, and n2 is replicated that many times,
-	//		each entry is the id of class for the parm type. (0 is valid which means there are no parms).
-	//		The return will be a VALUE command containing the OBJECT_ID of the method.
-	//
-	// GET_CTOR: 10b, classId, n1, [n2]...
-	//		Where classID is the id of the class the method should be found in.
-	//		Where n1 is the number of parm types following, and n2 is replicated that many times,
-	//		each entry is the id of class for the parm type. (0 is valid which means there are no parms).
-	//		The return will be a VALUE command containing the OBJECT_ID of the method.
-	//	
-	// GET_FIELD:
-	//
-	// GET_CTOR:
-	//
-	// INVOKE: 15b, n1, tb, value1, value2
-	//		Where "n1" is the id of the method to invoke.
-	//		tb, value1 is the value of who to invoke against (it is usually an OBJECT_ID for tb)
-	//      value2 is an ARRAY_IDS type or an OBJECT array of values if all constants.
-	//		What is returned is a VALUE command containing the return value, (the value will be null (VOID) if
-	//		there is no return type (i.e. the method was void). So null can be returned either if the value
-	//		was null or if the return type was void.
-	//
-	// EXPRESSION_TREE_COMMAND: 20b, n, b
-	//		Receiving an expression tree subcommand. Where "n" is a unique id number of the
-	//		expression being processed. Where "b" is byte code, defined in ExpressionCommands, that
-	//		determines the type of expression tree commands.
-	//		There can be more data following, but it is read by the 
-	//		ExpressionProcesserController, not by the connection. See the controller for the subcommands.
-	//
-	//		The id number is the id of the expression being processed. This allows more than one expression
-	//		to be processed at a time from this connection.
-	//
-	//		@see ExpressionCommands
-	//		@see ExpressionProcessController
-	//
-	// INVOKE_WITH_METHOD_PASSED: 20b,  classId, "methodName", value0, tb, value1, value2
-	//		Where classID is the id of the class the method should be found in.
-	//		value0 is an ARRAY_IDS type for the type of the parms, or null type for no parms.  
-	//		tb, value1 is the value of who to invoke against (it is usually an OBJECT_ID for tb)
-	//      value2 is an ARRAY_IDS type or an OBJECT array of values if all constants.
-	//		What is returned is a VALUE command containing the return value, (the value will be null (VOID) if
-	//		there is no return type (i.e. the method was void). So null can be returned either if the value
-	//		was null or if the return type was void.
-	//
-	// GET_ARRAY_CONTENTS: 21b, arrayId
-	//		Where arrayID is the id of the array to get the contents of. What is returned is a value command
-	//		containing an array of ids of the first dimension contents.
-	//
-	// Callback commands:
-	//
-	// CALLBACK: 255b, n1, n2, value1
-	//      Where
-	//        "n1" is the id of callback type (these are registered with the callback server)
-	//        "n2" is the msgId for the callback (These are entirely callback dependent and are maintained by the callback developer)
-	//        value1 is an ARRAY_IDS type or an OBJECT array of values if all constants. These are
-	//          parms to send to the callback msg.
-	//      It will return a CALLBACK_DONE.
-	//
-	// CALLBACK_DONE: 254b, value command.
-	//		What comes back is a value command (i.e. Commands.VALUE followed by value). This allows
-	//		ERRORS to be sent back too.
-	//
-	// CALLBACK_STREAM: 253b, n1, n2
-	//      Where
-	//        "n1" is the id of callback type (these are registered with the callback server)
-	//        "n2" is the msgId for the callback (These are entirely callback dependent and are maintained by the callback developer)
-	//		It will create a CallbackInputStream and notify the registered callback that the
-	//		stream is available. It will send a callback_done when it has accepted the request
-	//		but before it notifies the registered callback with the stream. This lets the remote
-	//		vm know that it can start sending data.
-	
-
-	// To the MasterServer socket:
-	// The MasterServer socket will expect input in DataInputStream format, and DataOutputStream for return.
-	// The socket will be short-lived. It will be for one transaction only. Each request will return a new socket.
-	//
-	// ALIVE: 16b, n1
-	//      Where
-	//        "n1" is the id of the registry this is asking to test for aliveness
-	//      Will return bool, where false if registry is not alive, true if it is alive.
-	// REMOTE_STARTED: 17b, n1, n2
-	//      Where
-	//        "n1" is the id of the registry this is telling that it is started
-	//        "n2" is the serversocket port number of the server socket in this remote vm.
-	//      Will return bool, where false if registry is not alive, true if it is alive. If false, then terminate the server because nothing to talk to.
-	// GET_CALLBACK_PORT: 18b, n1
-	//      Where
-	//        "n1" is the id of the registry this is asking for the callback server port.
-	//      Will return int, where the value is the callback server port number. -1 if there is no callback server port.		
-	
-	/**
-	 * This class is the return from a read value. It contains the
-	 * type of the value and the value itself. Since primitives can be
-	 * returned also, there is a slot for each one and the type should
-	 * be checked to see which one is set.
-	 *
-	 * Also, if the type is OBJECT, then the anObject has the object in it, AND
-	 * the classID field has the object_id of the class of the object so that the
-	 * appropriate beantypeproxy can be found to use that object. Also, only
-	 * IREMConstantBeanTypeProxies can be of type OBJECT. That is because those
-	 * are the only ones that know how to take the value object and interpret it.
-	 *
-	 * If the type is OBJECT_ID or NEW_OBJECT_ID, then the objectID field will be set with
-	 * the id.
-	 * If the type is NEW_OBJECT_ID, then the classID field will
-	 * have the class objectID of the class of the object for which object_id proxies.
-	 *
-	 * THROW is treated like NEW_OBJECT_ID in what fields are set since it is a new object.
-	 *
-	 * Note: so as not to create unnecessary objects, if the Object type of the primitive is being
-	 * sent, then the primitive field will be set instead, though the type
-	 * will still be the Object type (i.e. if type = L_BYTE, the aByte will
-	 * have the value in it).
-	 * 
-	 * Note: Also flags can be send back. The type will be FLAG and the anInt field will be the
-	 * flag value. This is used to indicate special things that aren't values. Most useful in
-	 * arrays where one of the entries is not a value. This can only be used if readValue
-	 * is passed a flag indicating flags are valid, otherwise it will be treated as not valie.
-	 */
-	public static class ValueObject implements Cloneable {
-		public byte type;	// Same as the types above
-		public byte aByte;
-		public char aChar;
-		public double aDouble;
-		public float aFloat;
-		public int anInt;
-		public short aShort;
-		public long aLong;
-		public boolean aBool;
-		public int objectID;	// The object id for either OBJECT_ID or NEW_OBJECT_ID.
-		public int classID;		// The class object id of the value in Object if the type is Object
-		public Object anObject;	// String also will be in here
-		
-		public ValueObject() {
-			type = VOID;
-		}
-		
-		public Object clone() {
-			try {
-				return (ValueObject) super.clone();
-			} catch (CloneNotSupportedException e) {
-				return null;
-			}
-		}
-		
-		/**
-		 * Return whether the value stored here is a primitive.
-		 * 
-		 * @return <code>true</code> if value is a primitive type.
-		 * 
-		 * @since 1.0.0
-		 */
-		public boolean isPrimitive() {
-			return getPrimitiveType().isPrimitive();
-		}
-		
-		/**
-		 * Get the primitive type of the value. 
-		 * @return The primitive type, or if not primitive, it returns simply <code>Object.class</code>.
-		 * 
-		 * @since 1.0.0
-		 */
-		public Class getPrimitiveType() {
-			switch (type) {
-				case BYTE:
-					return Byte.TYPE;
-				case CHAR:
-					return Character.TYPE;
-				case DOUBLE:
-					return Double.TYPE;
-				case FLOAT:
-					return Float.TYPE;
-				case INT:
-					return Integer.TYPE;
-				case SHORT:
-					return Short.TYPE;
-				case LONG:
-					return Long.TYPE;
-				case BOOL:
-					return Boolean.TYPE;
-				default:
-					return Object.class;
-			}	
-			
-		}
-		
-		/**
-		 * Get the type as one of the valid Commands.Types. VOID, BYTE, L_BYTE, etc.
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public int getType() {
-			return type;
-		}
-		
-		/**
-		 * Special getter to get the type as an Object, this is used by invoke for example.
-		 */
-		public Object getAsObject() {
-			switch (type) {
-				case VOID:
-					return null;
-				case BYTE:
-				case L_BYTE:
-					return new Byte(aByte);
-				case CHAR:
-				case L_CHAR:
-					return new Character(aChar);
-				case DOUBLE:
-				case L_DOUBLE:
-					return new Double(aDouble);
-				case FLOAT:
-				case L_FLOAT:
-					return new Float(aFloat);
-				case INT:
-				case L_INT:
-					return new Integer(anInt);
-				case SHORT:
-				case L_SHORT:
-					return new Short(aShort);
-				case LONG:
-				case L_LONG:
-					return new Long(aLong);
-				case BOOL:
-				case L_BOOL:
-					return aBool ? Boolean.TRUE : Boolean.FALSE;
-				case STRING:
-					return (String) anObject;
-				case OBJECT:
-					return anObject;
-				
-				default: 
-					return null;	// Can't handle others. Those need to be checked before calling.
-			}
-		}
-		
-		/**
-		 * Special setter to set the value depending upon the type.
-		 */
-		public void setAsObject(Object value, int valueClassID) {
-			switch (valueClassID) {
-				case VOID:
-					set();
-					break;
-				case BYTE_CLASS:
-					set((Byte) value);
-					break;
-				case CHARACTER_CLASS:
-					set((Character) value);
-					break;
-				case DOUBLE_CLASS:
-					set((Double) value);
-					break;
-				case FLOAT_CLASS:
-					set((Float) value);
-					break;
-				case INTEGER_CLASS:
-					set((Integer) value);
-					break;
-				case SHORT_CLASS:
-					set((Short) value);
-					break;
-				case LONG_CLASS:
-					set((Long) value);
-					break;
-				case BOOLEAN_CLASS:
-					set((Boolean) value);
-					break;
-				case STRING_CLASS:
-					set((String) value);
-					break;
-				default:
-					set(value, valueClassID);
-					break;
-			}
-		}
-			
-		public void set() {
-			type = VOID;
-			anObject = null;
-		}
-		
-		public void setFlag(int flag) {
-			type = FLAG;
-			anInt = flag;
-		}
-		
-		public void set(byte value) {
-			type = BYTE;
-			aByte = value;
-			anObject = null;
-		}
-		public void set(Byte value) {
-			if (value != null) {
-				type = L_BYTE;
-				aByte = value.byteValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(char value) {
-			type = CHAR;
-			aChar = value;
-			anObject = null;
-		}
-		public void set(Character value) {
-			if (value != null) {
-				type = L_CHAR;
-				aChar = value.charValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(double value) {
-			type = DOUBLE;
-			aDouble = value;
-			anObject = null;
-		}
-		public void set(Double value) {
-			if (value != null) {
-				type = L_DOUBLE;
-				aDouble = value.doubleValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(float value) {
-			type = FLOAT;
-			aFloat = value;
-			anObject = null;
-		}
-		public void set(Float value) {
-			if (value != null) {
-				type = L_FLOAT;
-				aFloat = value.floatValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(int value) {
-			type = INT;
-			anInt = value;
-			anObject = null;
-		}
-		public void set(Integer value) {
-			if (value != null) {
-				type = L_INT;
-				anInt = value.intValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(short value) {
-			type = SHORT;
-			aShort = value;
-			anObject = null;
-		}
-		public void set(Short value) {
-			if (value != null) {
-				type = L_SHORT;
-				aShort = value.shortValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(long value) {
-			type = LONG;
-			aLong = value;
-			anObject = null;
-		}
-		public void set(Long value) {
-			type = L_LONG;
-			aLong = value.longValue();
-			anObject = null;
-		}
-		public void set(boolean value) {
-			type = BOOL;
-			aBool = value;
-			anObject = null;
-		}
-		public void set(Boolean value) {
-			if (value != null) {
-				type = L_BOOL;
-				aBool = value.booleanValue();
-				anObject = null;
-			} else
-				set();
-		}
-		public void set(String value) {
-			if (value != null) {
-				type = STRING;
-				anObject = value;
-			} else
-				set();
-		}				
-		public void set(Object value, int classObjectID) {
-			if (value != null) {
-				type = OBJECT;
-				classID = classObjectID;
-				anObject = value;
-			} else
-				set();
-		}
-		public void setObjectID(int value) {
-			type = OBJECT_ID;
-			objectID = value;
-			anObject = null;
-		}
-		
-		// Use this if the object is an array containing IDs. The retriever
-		// will be used to get the next value to write to the stream.
-		public void setArrayIDS(ValueRetrieve retriever, int arraySize, int componentType) {
-			type = ARRAY_IDS;
-			classID = componentType;
-			anInt = arraySize;
-			anObject = retriever;
-		}
-		
-		
-		// Use this if this is a new object so that we can get the correct class type.
-		public void setObjectID(int value, int classObjectID) {
-			type = NEW_OBJECT_ID;
-			objectID = value;
-			classID = classObjectID;
-			anObject = null;
-		}									
-		
-		// Use this to indicate an exception occured.
-		public void setException(int throwID, int throwClassID) {
-			type = THROW;
-			objectID = throwID;
-			classID = throwClassID;
-			anObject = null;
-		}
-	}
-	
-	/************************
-	 * Helpful commands.
-	 * - If a command throws any exception except CommandErrorException, or
-	 *   UnexpectedCommandException with recoverable true, then the connection is in a bad state
-	 *   and needs to be closed.
-	 ************************/
-	
-	/**
-	 * Use this to read a value (inputstream should be pointing to the type byte as the next byte to read).
-	 * The primitive fields of "value" will not be changed if they are not the
-	 * type of the value being read. However, anObject will be set to null.
-	 */
-	 
-	/**
-	 * Error flags for UnexpectedCommandExceptions that can be thrown.
-	 */
-	public static final Object UNKNOWN_READ_TYPE = "UNKNOWN_READ_TYPE";		// The read type byte was not a valid type //$NON-NLS-1$
-	public static final Object UNKNOWN_WRITE_TYPE = "UNKNOWN_WRITE_TYPE";		// The write type byte was not a valid type	 //$NON-NLS-1$
-	public static final Object TYPE_INVALID_FOR_COMMAND = "TYPE_INVALID_FOR_COMMAND";		// The data type read is not valid for this command //$NON-NLS-1$
-	public static final Object UNKNOWN_COMMAND = "UNKNOWN_COMMAND";			// The command flag is unknown //$NON-NLS-1$
-	public static final Object SOME_UNEXPECTED_EXCEPTION = "SOME_UNEXPECTED_EXCEPTION";	// There was some kind of exception that wasn't expected. The data will be the exception. //$NON-NLS-1$
-	public static final Object TOO_MANY_BYTES = "TOO_MANY_BYTES";			// Too many bytes were sent on a writeBytes. It was //$NON-NLS-1$
-																		// more than could be read into the buffer. The data will be the size sent.
-
-	/**
-	 * Read a value from the stream into the value object. It will not allow values of type FLAG.
-	 * 
-	 * @param is
-	 * @param value
-	 * @param allowFlag
-	 * @return the value object sent in. This allows <code>value = Commands.readValue(is, new Commands.ValueObject());</code> 
-	 * @throws CommandException
-	 * 
-	 * 
-	 * @since 1.0.0
-	 */
-	public static ValueObject readValue(DataInputStream is, ValueObject value) throws CommandException {
-		readValue(is, value, false);
-		return value;
-	}
-
-	/**
-	 * Read a value from the stream into the value object. It will allow values of type FLAG if allowFlag is true.
-	 * @param is
-	 * @param value
-	 * @param allowFlag <code>true</code> if values of type flag are allow.
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void readValue(DataInputStream is, ValueObject value, boolean allowFlag) throws CommandException {
-		try {
-			value.anObject = null;
-			value.type = is.readByte();
-			switch (value.type) {
-				case BYTE:
-				case L_BYTE:
-					value.aByte = is.readByte();
-					break;
-				case CHAR:
-				case L_CHAR:
-					value.aChar = is.readChar();
-					break;
-				case DOUBLE:
-				case L_DOUBLE:
-					value.aDouble = is.readDouble();
-					break;
-				case FLOAT:
-				case L_FLOAT:
-					value.aFloat = is.readFloat();
-					break;
-				case INT:
-				case L_INT:
-					value.anInt = is.readInt();
-					break;
-				case OBJECT_ID:
-					value.objectID = is.readInt();
-					break;					
-				case NEW_OBJECT_ID:
-					value.classID = is.readInt();
-					value.objectID = is.readInt();
-					break;
-				case THROW:
-					value.classID = is.readInt();
-					value.objectID = is.readInt();
-					break;				
-				case SHORT:
-				case L_SHORT:
-					value.aShort = is.readShort();
-					break;
-				case LONG:
-				case L_LONG:
-					value.aLong = is.readLong();
-					break;
-				case BOOL:
-				case L_BOOL:
-					value.aBool = is.readBoolean();
-					break;
-				case STRING:
-					value.anObject = readStringData(is);
-					break;
-				case OBJECT:
-					value.classID = is.readInt();	// Read the class id
-					ObjectInputStream oi = new ObjectInputStream(is);
-					value.anObject = oi.readObject();	// Read the object itself
-					oi = null;	// Don't close it, that would close the stream itself.
-					break;
-				case ARRAY_IDS:
-					// The header for an array of ids.
-					value.classID = is.readInt();	// The component type of the array
-					value.anInt = is.readInt();	// The size of the array.
-					// At this point, it is the responsibility of the caller to use readArray to read in the array.
-					break;
-				case VOID:
-					break;
-				case FLAG:
-					if (allowFlag) {
-						value.anInt = is.readInt();
-						break;
-					}
-					// Flags not allowed, so drop into default.
-				default:
-					throw new UnexpectedCommandException(UNKNOWN_READ_TYPE, false, new Byte(value.type));
-			}
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}
-	}
-	
-	/**
-	 * Special interface used to read back arrays. It will be called when 
-	 */
-	public static interface ValueSender {
-		/**
-		 * This is called for each entry from the array. It is assumed that the ValueSender has
-		 * the array that is being built.
-		 * @param value
-		 * 
-		 * @since 1.1.0
-		 */
-		public void sendValue(ValueObject value);
-
-		/**
-		 * This is called when an ARRAY_IDS is found within the reading of the array (i.e. nested arrays)
-		 * It is asking for a new ValueSender to use while this nested array. The arrayValue contains
-		 * the valueobject for the array header (i.e. the class id of the array and the number of elements).
-		 * It is the responsibility of the ValueSender to store this array in the array that is being built.
-		 * @param arrayValue
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public ValueSender nestedArray(ValueObject arrayValue);
-		
-		/**
-		 * Called to initialize the sender with the given array header. This is not always called, each usage
-		 * knows whether it can be called or not. For example the implementation of nestedArray may not need to call initialize.
-		 * @param arrayHeader
-		 * 
-		 * @since 1.1.0
-		 */
-		public void initialize(ValueObject arrayHeader);
-		
-	}	
-	
-	/*
-	 * NOTE: It is important that on the IDE side that this is called within a transaction. 
-	 * If not, there could be some corruption if proxy cleanup occurs in the middle.
-	 */
-	public static void readArray(DataInputStream is, int arraySize, ValueSender valueSender, ValueObject value, boolean allowFlag) throws CommandException {
-		// Anything exception other than a CommandException, we will try to flush the input so that
-		// it can continue with the next command and not close the connection.
-		RuntimeException exception = null;
-		for (int i=0; i<arraySize; i++) {
-			readValue(is, value, allowFlag);
-			if (exception == null) 
-				try {
-					if (value.type != ARRAY_IDS)
-						valueSender.sendValue(value);
-					else {
-						// We have a nested array.
-						ValueSender nestedSender = null;
-						try {
-							nestedSender = valueSender.nestedArray(value);
-						} catch (RuntimeException e) {
-							// We still need to read in the array to flush. Create
-							// a dummy sender that accepts everything sent to it.
-							exception = e;
-							nestedSender = new ValueSender() {
-								public void sendValue(ValueObject value) {
-								}
-								public ValueSender nestedArray(ValueObject arrayValue) {
-									return this;
-								}
-								public void initialize(ValueObject arrayHeader) {
-								}
-							};
-						}
-						readArray(is, value.anInt, nestedSender, value, allowFlag);
-						if (exception != null)
-							throw exception;	// An exception ocurred in new sender request.
-					}
-				} catch (RuntimeException e) {
-					// We want to flush the queue, so save the exception for later.
-					exception = e;
-				}
-		}
-		if (exception != null)
-			throw exception;
-	}
-				
-
-	/**
-	 * Special interface to handle writing the ARRAY_IDS type.
-	 * An instance of this object will be in the valueObject sent to writeValue when the type of the value
-	 * is ARRAY_IDS. Then write value will know to call this interface to write out the values.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static interface ValueRetrieve {
-		/**
-		 * Returns the next value object to send. It will be called the number of times that the size of 
-		 * the array was set to be send. 
-		 * @return The value object to send.
-		 * @throws EOFException
-		 * 
-		 * @since 1.1.0
-		 */
-		public ValueObject nextValue() throws EOFException;
-	}	
-
-	public static void writeValue(DataOutputStream os, ValueObject value, boolean asValueCommand) throws CommandException  {
-		writeValue(os, value, asValueCommand, asValueCommand ? true : false);
-	}
-	
-	public static void writeValue(DataOutputStream os, ValueObject value, boolean asValueCommand, boolean flush) throws CommandException  {
-		try {
-			if (asValueCommand)
-				os.writeByte(VALUE);
-			switch (value.type) {
-				case BYTE:
-				case L_BYTE:
-					os.writeByte(value.type);
-					os.writeByte(value.aByte);
-					break;
-				case CHAR:
-				case L_CHAR:
-					os.writeByte(value.type);			
-					os.writeChar(value.aChar);
-					break;
-				case DOUBLE:
-				case L_DOUBLE:
-					os.writeByte(value.type);			
-					os.writeDouble(value.aDouble);
-					break;
-				case FLOAT:
-				case L_FLOAT:
-					os.writeByte(value.type);			
-					os.writeFloat(value.aFloat);
-					break;
-				case INT:
-				case L_INT:
-					os.writeByte(value.type);			
-					os.writeInt(value.anInt);
-					break;
-				case OBJECT_ID:
-					os.writeByte(value.type);
-					os.writeInt(value.objectID);
-					break;					
-				case NEW_OBJECT_ID:
-					os.writeByte(value.type);
-					os.writeInt(value.classID);
-					os.writeInt(value.objectID);
-					break;
-				case THROW:
-					os.writeByte(value.type);
-					os.writeInt(value.classID);
-					os.writeInt(value.objectID);
-					break;
-				case SHORT:
-				case L_SHORT:
-					os.writeByte(value.type);			
-					os.writeShort(value.aShort);
-					break;
-				case LONG:
-				case L_LONG:
-					os.writeByte(value.type);			
-					os.writeLong(value.aLong);
-					break;
-				case BOOL:
-				case L_BOOL:
-					os.writeByte(value.type);			
-					os.writeBoolean(value.aBool);
-					break;
-				case STRING:
-					os.writeByte(value.type);			
-					sendStringData(os, (String) value.anObject);
-					break;
-				case OBJECT:
-					os.writeByte(value.type);
-					os.writeInt(value.classID);	// Write the class ID.
-					ObjectOutputStream oos = new ObjectOutputStream(os);
-					oos.writeObject(value.anObject);
-					oos.flush();
-					oos = null;	// Don't close it, that would close the stream itself.
-					break;					
-				case ARRAY_IDS:
-					// We are writing out an array with ID's in it. The fields of the vale object will be:
-					// 	classID: The class id of the component type of the array.
-					//  anObject: Contains the ValueRetriever to get the next value.
-					os.writeByte(ARRAY_IDS);	
-					os.writeInt(value.classID);
-					os.writeInt(value.anInt);	// The size of the array.
-					// Now comes the kludgy part, writing the values.
-					ValueRetrieve retriever = (ValueRetrieve) value.anObject;
-					int len = value.anInt;
-					while (len-- > 0)
-						writeValue(os, retriever.nextValue(), false);
-					break;
-				case VOID:
-					os.writeByte(value.type);			
-					break;
-				case FLAG:
-					os.writeByte(FLAG);
-					os.writeInt(value.anInt);
-					break;
-				default:
-					os.writeByte(VOID);
-					throw new UnexpectedCommandException(UNKNOWN_WRITE_TYPE, true, value);					
-			}
-			if (flush)
-				os.flush();
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}	
-	
-	/**
-	 * For reading a large number of bytes. This is a value type, not a command. The command 
-	 * needs to be handled separately. It returns the number of bytes read. -1 if there
-	 * is no more data to send and the stream should closed. If read something but not all,
-	 * then just what it could read will be returned. The next read will return -1 for EOF.
-	 *
-	 * It will read from the format:
-	 *   int - number of bytes to read (retrieved from the stream).
-	 *   bytes - the actual bytes.
-	 *
-	 * Note: A command exception will be thrown if the number of bytes to read
-	 *       is larger than the size of the byte array.
-	 */
-	public static int readBytes(DataInputStream is, byte[] bytes) throws CommandException  {
-		try {
-			int bytesToRead = -1;
-			try {
-				bytesToRead = is.readInt();
-			} catch (EOFException e) {
-			}
-			if (bytesToRead == -1)
-				return -1;
-			if (bytesToRead > bytes.length)
-				throw new UnexpectedCommandException(TOO_MANY_BYTES, false, new Integer(bytesToRead));
-			int start = 0;
-			int toRead = bytesToRead;
-			while (toRead > 0) {
-				int bytesRead = is.read(bytes, start, toRead);
-				if (bytesRead == -1)
-					return bytesToRead != toRead ? bytesToRead-toRead : -1;	// Actual number read, or if none read, then EOF
-				start+=bytesRead;
-				toRead-=bytesRead;
-			}
-			return bytesToRead;
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-		
-	/**
-	 * For writing a large number of bytes. This is a value type, not a command. The command 
-	 * needs to be handled separately.
-	 *
-	 * It will write it in the format:
-	 *   int - number of bytes
-	 *   bytes - the actual bytes.
-	 *
-	 */
-	public static void writeBytes(DataOutputStream os, byte[] bytes, int bytesToWrite) throws CommandException  {
-		try {
-			os.writeInt(bytesToWrite);
-			os.write(bytes, 0, bytesToWrite);
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}	
-		
-	/************************
-	 * Send command helpers
-	 ************************/
-	 
-	public static void sendQuitCommand(DataOutputStream os) throws IOException {
-		os.writeByte(QUIT_CONNECTION);
-		os.flush();
-			
-	}
-	
-	public static void sendTerminateCommand(DataOutputStream os) throws IOException {
-		os.writeByte(TERMINATE_SERVER);
-		os.flush();
-	}
-	
-	
-	public static void releaseObjectCommand(DataOutputStream os, int id) throws IOException {
-		os.writeByte(Commands.RELEASE_OBJECT);
-		os.writeInt(id);
-		os.flush();
-	}
-
-	/**
-	 * Send a callback request. The value is to be send separately.
-	 */
-	public static void sendCallbackCommand(DataOutputStream os, int callbackID, int msgID) throws CommandException {
-		try {
-			os.writeByte(CALLBACK);
-			os.writeInt(callbackID);
-			os.writeInt(msgID);
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-		
-	public static void sendCallbackDoneCommand(DataOutputStream os, ValueObject value, int errorCode) throws CommandException {
-		try {
-			os.writeByte(CALLBACK_DONE);
-			if (errorCode == NO_ERROR) {
-				writeValue(os, value, true);
-				os.flush();
-			} else
-				sendErrorCommand(os, errorCode, value);
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-	
-	/**
-	 * Send a start callback stream request. The data will be written separately.
-	 * There will not be a callback done command. It will return as soon as the command
-	 * is sent.
-	 */
-	public static void sendCallbackStreamCommand(DataOutputStream os, int callbackID, int msgID) throws CommandException {
-		try {
-			os.writeByte(CALLBACK_STREAM);
-			os.writeInt(callbackID);
-			os.writeInt(msgID);
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-	
-	protected static final byte STRING_NOT_CHUNKED = 0;
-	protected static final byte STRING_CHUNKED = 1;
-	protected static final byte MORE_CHUNKS = 2;
-	protected static final byte LAST_CHUNK = 3;
-	protected static final int CHUNK_SIZE = 65000/3; 
-	
-	/**
-	 * Send string data. This is for general string data. It makes sure that if the string is too big (there is a UTF-8 limit)
-	 * that it will send it in chunks. Use the corresponding <code>readStringData</code> to read such data in.
-	 * @param os
-	 * @param string
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendStringData(DataOutputStream os, String string) throws IOException {
-		// UTF-8 can take up to three bytes for each char. To be on safe side we will
-		// not send a string larger than 65K/3 as one chunk.
-		if (string.length() <= CHUNK_SIZE) {
-			// Less than the limit, send byte to indicate not chunked.
-			os.writeByte(STRING_NOT_CHUNKED);
-			os.writeUTF(string);
-		} else {
-			// Over limit, need to chunk it.
-			// send byte to indicate chunked, then send true length so that other side knows how big to create.
-			os.writeByte(STRING_CHUNKED);
-			os.writeInt(string.length());
-			// Now send first chunk
-			for(int i=0; i<string.length(); i+=CHUNK_SIZE) {
-				int endIndex = i+CHUNK_SIZE;
-				if (i == 0) {
-					// The first chunk is just written as is. We know endIndex will be ok because we wouldn't get here unless LARGER than chunksize.
-					os.writeUTF(string.substring(i, endIndex));
-				} else {
-					// Following chunks have either byte MORE_CHUNKS or LAST_CHUNK
-					if (endIndex >= string.length()) {
-						// This is last chunk.
-						os.writeByte(LAST_CHUNK);
-						os.writeUTF(string.substring(i));
-					} else {
-						// This is an intermediate chunk.
-						os.writeByte(MORE_CHUNKS);
-						os.writeUTF(string.substring(i, endIndex));
-					}
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Read a string that was sent using the sendStringData command.
-	 * @param in
-	 * @return
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static String readStringData(DataInputStream is) throws IOException {
-		byte chunked = is.readByte();
-		if (chunked == STRING_NOT_CHUNKED)
-			return is.readUTF();	// Not chunk, just read it.
-		else {
-			// It is chunked.
-			int totalLength = is.readInt();	// Get the total length.
-			StringBuffer sbr = new StringBuffer(totalLength);
-			while(true) {
-				sbr.append(is.readUTF());
-				if (chunked != LAST_CHUNK)
-					chunked = is.readByte();
-				else
-					break;
-			}
-			return sbr.toString();
-		}
-	}
-	
-	/**
-	 * Read back command, expecting either a VALUE or an ERROR. You can request that
-	 * it be of a specific type (if any type can be accepted then enter -1 for the type).
-	 */
-	public static final byte NO_TYPE_CHECK = -1;
-	public static void readBackValue(DataInputStream is, ValueObject value, byte expectedType) throws CommandException {
-		try {		
-			byte v = is.readByte();
-			switch (v) {
-				case VALUE:
-					readValue(is, value);
-					if (expectedType != NO_TYPE_CHECK && 
-							!(expectedType == value.type || (expectedType == Commands.OBJECT_ID && value.type == NEW_OBJECT_ID)))
-						throw new UnexpectedCommandException(TYPE_INVALID_FOR_COMMAND, true, value);
-					break;
-				case ERROR:
-					int code = is.readInt();
-					readValue(is, value);
-					throw new CommandErrorException(code, value);
-				default:
-					throw new UnexpectedCommandException(UNKNOWN_COMMAND, false, new Byte(v));
-			}
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}				
-	}
-		
-	
-	/**
-	 * GetClass command returns a GetClassReturn object.
-	 */
-	public static class GetClassReturn {
-		public int classID;
-		public boolean isInterface;
-		public boolean isAbstract;
-		public String superClassname;
-	}
-	
-	public static GetClassReturn sendGetClassCommand(DataOutputStream os, DataInputStream is, String className) throws CommandException {
-		try {
-			os.writeByte(GET_CLASS);
-			os.writeUTF(className);
-			os.flush();
-			
-			GetClassReturn ret = new GetClassReturn();
-			byte v = is.readByte();
-			switch (v) {
-				case GET_CLASS_RETURN:
-					ret.classID = is.readInt();	// Get the new class id.
-					ret.isInterface = is.readBoolean();	// Get the isInterface flag
-					ret.isAbstract = is.readBoolean();	// Get the isAbstract flag.					
-					ret.superClassname = is.readUTF();	// Get the super class name.
-					return ret;
-				case ERROR:
-					int code = is.readInt();
-					ValueObject value = new ValueObject();
-					readValue(is, value);
-					throw new CommandErrorException(code, value);
-				default:
-					throw new UnexpectedCommandException(UNKNOWN_COMMAND, false, new Byte(v));
-			}
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-	
-	/**
-	 * GetClassFromID command returns a GetClassIDReturn object.
-	 */
-	public static class GetClassIDReturn {
-		public String className;
-		public boolean isInterface;
-		public boolean isAbstract;
-		public String superClassname;
-	}
-		
-	public static GetClassIDReturn sendGetClassFromIDCommand(DataOutputStream os, DataInputStream is, int classID) throws CommandException {
-		try {
-			os.writeByte(GET_CLASS_FROM_ID);
-			os.writeInt(classID);
-			os.flush();
-			
-			GetClassIDReturn ret = new GetClassIDReturn();
-			byte v = is.readByte();
-			switch (v) {
-				case GET_CLASS_ID_RETURN:
-					ret.className = is.readUTF();	// Get the new class name.
-					ret.isInterface = is.readBoolean();	// Get the isInterface flag
-					ret.isAbstract = is.readBoolean();	// Get the isAbstract flag.
-					ret.superClassname = is.readUTF();	// Get the super class name.
-					return ret;
-				case ERROR:
-					int code = is.readInt();
-					ValueObject value = new ValueObject();
-					readValue(is, value);
-					throw new CommandErrorException(code, value);
-				default:
-					throw new UnexpectedCommandException(UNKNOWN_COMMAND, false, new Byte(v));
-			}
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-		
-	public static void sendGetObjectData(DataOutputStream os, DataInputStream is, int objectID, ValueObject valueReturn) throws CommandException {
-		try {
-			os.writeByte(GET_OBJECT_DATA);
-			os.writeInt(objectID);
-			os.flush();
-			readBackValue(is, valueReturn, NEW_OBJECT_ID);
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}		
-	
-	public static void sendErrorCommand(DataOutputStream os, int code, ValueObject errorValue) throws CommandException {
-		try {
-			os.writeByte(ERROR);
-			os.writeInt(code);
-			writeValue(os, errorValue, false);
-			os.flush();
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}		
-	
-	public static void sendNewInstance(DataOutputStream os, DataInputStream is, int classId, String initializationString, ValueObject newValueReturn) throws CommandException {
-		try {
-			os.writeByte(NEW_INIT_STRING);
-			os.writeInt(classId);
-			os.writeUTF(initializationString);
-			os.flush();
-			readBackValue(is, newValueReturn, NO_TYPE_CHECK);
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}	
-	
-	
-	public static void sendInvokeMethodCommand(DataOutputStream os, DataInputStream is, int methodID, ValueObject invokeOn, ValueObject parms, ValueObject valueReturn) throws CommandException {
-		try {
-			os.writeByte(INVOKE);
-			os.writeInt(methodID);
-			writeValue(os, invokeOn, false);
-			writeValue(os, parms, false);
-			os.flush();
-			readBackValue(is, valueReturn, NO_TYPE_CHECK);
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-
-	public static void sendInvokeMethodCommand(DataOutputStream os, DataInputStream is, ValueObject classType, String methodName, ValueObject parmTypes, ValueObject invokeOn, ValueObject parms, ValueObject valueReturn) throws CommandException {
-		try {
-			os.writeByte(INVOKE_WITH_METHOD_PASSED);
-			writeValue(os, classType, false);
-			os.writeUTF(methodName);
-			writeValue(os, parmTypes, false);
-			writeValue(os, invokeOn, false);
-			writeValue(os, parms, false);
-			os.flush();
-			readBackValue(is, valueReturn, NO_TYPE_CHECK);
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-	
-	public static void sendGetArrayContentsCommand(DataOutputStream os, DataInputStream is, int arrayID, ValueObject valueReturn) throws CommandException {
-		try {
-			os.writeByte(GET_ARRAY_CONTENTS);
-			os.writeInt(arrayID);
-			os.flush();
-			readBackValue(is, valueReturn, NO_TYPE_CHECK);
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-	
-	private Commands() {
-		// Never intended to be instantiated.
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/ExpressionCommands.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/ExpressionCommands.java
deleted file mode 100644
index 4879d24..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/ExpressionCommands.java
+++ /dev/null
@@ -1,345 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ExpressionCommands.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:39:08 $ 
- */
-package org.eclipse.jem.internal.proxy.common.remote;
-
-import java.io.*;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-
- 
-/**
- * 
- * @since 1.0.0
- */
-public class ExpressionCommands {
-
-	// These are the sub-commands under EXPRESSION_TREE_COMMANDS that can be send.
-	public static final byte
-		START_EXPRESSION_TREE_PROCESSING = 0,
-		PUSH_EXPRESSION = 1,
-		END_EXPRESSION_TREE_PROCESSING = 2,
-		SYNC_REQUEST = 3,
-		PULL_VALUE_REQUEST = 4,
-		TRANSFER_EXPRESSION_REQUEST = 5,
-		RESUME_EXPRESSION_REQUEST = 6;
-		
-	// These are the expression specific error codes (it can also send back general ones. See SYNC_REQUEST docs lower down).
-	public static final int
-		EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION = Commands.MAX_ERROR_CODE+1;	// No expression value occurred.
-	
-	// These are the flag values sent in proxy resolution when doesn't resolve to proxy.
-	public static final int
-		EXPRESSIONPROXY_VOIDTYPE = 0,	// Expression proxy resolves to void type.
-		EXPRESSIONPROXY_NOTRESOLVED = 1;	// Expression proxy not resolved.
-	
-	// These are the trace values sent in START_EXPRESSION_TREE_PROCESSING
-	public static final byte
-		TRACE_DEFAULT = -1,
-		TRACE_OFF = 0,
-		TRACE_ON = 1;
-
-	public static final String EXPRESSIONTRACE = "proxyvm.expressionTrace";	// The system property for turning on expression tracing. //$NON-NLS-1$
-	public static final String EXPRESSIONTRACE_TIMER_THRESHOLD = "proxyvm.expressionTraceTimerThreshold";	// The system property for timer threshold. //$NON-NLS-1$
-	
-	/*
-	 * The format of the commands are:
-	 * 		Note: Most of the commands will not being doing a os.flush() at the end. We are just going to
-	 * 		be streaming the data over the line. At the end we will flush and then catch up. That way
-	 * 		we aren't waiting for the other side as we send the data.
-	 * 
-	 * START_EXPRESSION_TREE_PROCESSING: 0b, trace
-	 * 	Start processing.
-	 *  byte(trace): -1 : do default
-	 *                0 : no trace
-	 *                1 : do trace
-	 * 
-	 * PUSH_EXPRESSION: 1b, b
-	 * 	Push an expression. Where "b" is the expression type from IInternalExpressionConstants. 
-	 * 	The actual data that follows is expression type dependent and will be
-	 * 	sent in a following call to ExpressionCommands as it builds up the actual command.
-	 * 	See REMExpression and each type of push call method within it to see the actual
-	 * 	sent data.
-	 * 
-	 * END_EXPRESSION_TREE_PROCESSING: 2b
-	 * 	End the processing and clean up.
-	 * 
-	 * SYNC_REQUEST: 3b
-	 * 	This will return the current status. The reason it is called sync is because the
-	 * 	IDE will wait for it to complete and read back the value. It will send back:
-	 * 		1: VALUE command with boolean true as the value.
-	 * 		2: ERROR command with code of ExpressionClassNotFound, with value of String with message from exception.
-	 * 		3: ERROR command with code of EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION, with value of String with message from exception.
-	 * 		4: THROWABLE command with the actual exception that occurred.
-	 * 
-	 *
-	 * PULL_VALUE_REQUEST: 4b
-	 * 	This will do a sync up and return the value from the expression.
-	 * 	IDE will wait for it to compleate and read back the value. It will send back:
-	 * 		1: VALUE command with the result as the value.
-	 * 		2: ERROR or EXCEPTION if there were errors, see SYNC_REQUEST with the format they are sent back.
-	 * 
-	 * TRANSFER_EXPRESSION_REQUEST: 5b
-	 *  This will do a sync up, and return the ExpressionProcessorController that the request is for. And remove
-	 *  the controller from its list of active expression controllers. 
-	 *  
-	 * RESUME_EXPRESSION_REQUEST: 6b, anExpressionProcessorController
-	 *  This will take the given controller and add it to the list of controllers this connection is handling. It returns nothing.  
-	 *  
-	 * @see org.eclipse.jem.internal.proxy.initParser.tree.IInternalExpressionConstants
-	 * @see org.eclipse.jem.internal.proxy.remote.REMExpression
-	 * 
-	 */
-	
-	/**
-	 * Send the start expression processing command.
-	 * @param expressionID
-	 * @param trace 
-	 * @param os
-	 * 
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendStartExpressionProcessingCommand(int expressionID, byte trace, DataOutputStream os) throws IOException {
-		os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-		os.writeInt(expressionID);
-		os.writeByte(START_EXPRESSION_TREE_PROCESSING);
-		os.writeByte(trace);
-	}
-	
-	/**
-	 * Send the end expression processing command.
-	 * @param expressionID 
-	 * @param os
-	 * 
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendEndExpressionProcessingCommand(int expressionID, DataOutputStream os) throws IOException {
-		os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-		os.writeInt(expressionID);
-		os.writeByte(END_EXPRESSION_TREE_PROCESSING);
-		os.flush();	// Flushing because we are done and want to make sure everything goes out.
-	}
-	
-	/**
-	 * Send an expression subcommand.
-	 * @param expressionID 
-	 * @param os
-	 * @param subcommand
-	 * 
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendExpressionCommand(int expressionID, DataOutputStream os, byte subcommand) throws IOException {
-		os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-		os.writeInt(expressionID);
-		os.writeByte(PUSH_EXPRESSION);
-		os.writeByte(subcommand);
-	}
-	
-	/**
-	 * Send just a byte.
-	 * 
-	 * @param os
-	 * @param aByte
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendByte(DataOutputStream os, byte aByte) throws IOException {
-		os.writeByte(aByte);
-	}
-	
-	/**
-	 * Send just an int.
-	 * 
-	 * @param os
-	 * @param anInt
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendInt(DataOutputStream os, int anInt) throws IOException {
-		os.writeInt(anInt);
-	}
-	
-	/**
-	 * Send just a string.
-	 * 
-	 * @param os
-	 * @param aString
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendString(DataOutputStream os, String aString) throws IOException {
-		Commands.sendStringData(os, aString);
-	}
-	
-	/**
-	 * Send just a boolean.
-	 * 
-	 * @param os
-	 * @param aBool
-	 * @throws IOException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendBoolean(DataOutputStream os, boolean aBool) throws IOException {
-		os.writeBoolean(aBool);
-	}
-	
-	/**
-	 * Send the pull value command. After processing the proxies, caller should call getFinalValue() to get the value.
-	 * @param expressionID 
-	 * @param os
-	 * @param is
-	 * @param proxyids if not <code>null</code>, then this is the list of expression proxy ids that need to be returned as rendered.
-	 * @param sender sender used to process the resolved proxy ids, or <code>null</code> if no proxy ids.
-	 * @throws CommandException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendPullValueCommand(int expressionID, DataOutputStream os, DataInputStream is, Commands.ValueObject proxyids, Commands.ValueSender sender) throws CommandException {
-		try {
-			os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-			os.writeInt(expressionID);
-			os.writeByte(PULL_VALUE_REQUEST);
-			sendProxyIDs(os, proxyids);
-			os.flush();
-			if (proxyids != null) {
-				Commands.readBackValue(is, proxyids, Commands.ARRAY_IDS);	// Read the array header.
-				sender.initialize(proxyids);
-				Commands.readArray(is, proxyids.anInt, sender, proxyids, true);	// Read the array.
-			}
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (IOException e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}
-	
-	/**
-	 * Send a sync command. This does a synchronize with the remote expression processor. It makes sure that the
-	 * stream is caught and doesn't return until everything on the stream has been processed. Should then call
-	 * getFinalValue() to verify the expression is valid.
-	 * @param expressionID 
-	 * @param os
-	 * @param is
-	 * @param proxyids if not <code>null</code>, then this is the list of expression proxy ids that need to be returned as rendered.
-	 * @param sender the sender used for reading back the proxyid resolutions, or <code>null</code> if no proxy ids.
-	 * 
-	 * @throws CommandException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void sendSyncCommand(int expressionID, DataOutputStream os, DataInputStream is, Commands.ValueObject proxyids, Commands.ValueSender sender) throws CommandException {
-		try {
-			os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-			os.writeInt(expressionID);
-			os.writeByte(SYNC_REQUEST);
-			sendProxyIDs(os, proxyids);
-			os.flush();
-			if (proxyids != null) {
-				Commands.readBackValue(is, proxyids, Commands.ARRAY_IDS);	// Read the array header.
-				sender.initialize(proxyids);
-				Commands.readArray(is, proxyids.anInt, sender, proxyids, true);	// Read the array.
-			}
-		} catch (CommandException e) {
-			// rethrow this exception since we want these to go on out.
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}		
-	}	
-	
-	/**
-	 * Send the proxyids (if not null) as part of a command. Used by sync and pullValue.
-	 * @param os
-	 * @param proxyids <code>null</code> if not requesting proxy ids.
-	 * @throws IOException
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	private static void sendProxyIDs(DataOutputStream os, Commands.ValueObject proxyids) throws IOException, CommandException {
-		if (proxyids != null) {
-			os.writeBoolean(true);	// Indicates proxy ids being sent.
-			Commands.writeValue(os, proxyids, false, false);
-		} else
-			os.writeBoolean(false);	// No proxyids being sent.
-	}
-	
-	/**
-	 * Send the transfer expression command and receive back the expression processor controller.
-	 * 
-	 * @param expressionID
-	 * @param os
-	 * @param is
-	 * @param expressionProcesserController
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void sendTransferExpressionCommand(int expressionID, DataOutputStream os, DataInputStream is, Commands.ValueObject expressionProcesserController) throws CommandException {
-		try {
-			os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-			os.writeInt(expressionID);
-			os.writeByte(TRANSFER_EXPRESSION_REQUEST);
-			os.flush();
-			Commands.readBackValue(is, expressionProcesserController, Commands.NO_TYPE_CHECK); // Read the expression processor controller
-		} catch (CommandException e) {
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}
-	}
-
-	/**
-	 * Send the resume expression command with given expression processor controller.
-	 * 
-	 * @param expressionID
-	 * @param os
-	 * @param expressionProcessorController
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	public static void sendResumeExpressionCommand(int expressionID, DataOutputStream os, Commands.ValueObject expressionProcessorController) throws CommandException {
-		try {
-			os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
-			os.writeInt(expressionID);
-			os.writeByte(RESUME_EXPRESSION_REQUEST);
-			Commands.writeValue(os, expressionProcessorController, false, false);
-		} catch (CommandException e) {
-			throw e;
-		} catch (Exception e) {
-			// Wrapper this one.
-			throw new UnexpectedExceptionCommandException(false, e);
-		}			
-	}
-	
-	private ExpressionCommands() {
-		// Never intended to be instantiated.
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/IOCommandException.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/IOCommandException.java
deleted file mode 100644
index 947dcef..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/IOCommandException.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common.remote;
-/*
- *  $RCSfile: IOCommandException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import java.io.IOException;
-import org.eclipse.jem.internal.proxy.common.CommandException;
-
-/**
- * A command exception occured while processing an io request
- * in a callback stream. This exception wrappers the command exception.
- */
-
-public class IOCommandException extends IOException {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -2308947195164382779L;
-	protected CommandException fException;
-	
-	public IOCommandException(CommandException e) {
-		fException = e;
-	}
-	
-	public CommandException getException() {
-		return fException;
-	}
-	
-	public String getMessage() {
-		return fException.getMessage();
-	}
-	
-	public void printStackTrace() {
-		fException.printStackTrace();
-	}
-	
-	public void printStackTrace(java.io.PrintStream p) {
-		fException.printStackTrace(p);
-	}
-
-	public void printStackTrace(java.io.PrintWriter p) {
-		fException.printStackTrace(p);
-	}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/TransmitableArray.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/TransmitableArray.java
deleted file mode 100644
index 60b078f..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/TransmitableArray.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common.remote;
-/*
- *  $RCSfile: TransmitableArray.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-/**
- * A value can be a TransmitableArray. This means this value is an array that
- * needs to have a ValueRetriever created for it. This is used if the array has ID's in
- * it and is not an existing array on the server or all constant values.
- *
- * NOTE: It is assumed that all IBeanTypeProxies of the parms have already been retrieved.
- *       It should still work, but it could be asking for them in the middle of the request
- *       if they are not first gotton. And this could throw a non-recoverable exception if not found.
- */
-public final class TransmitableArray {
-	public int componentTypeID;	// The id of the type of the component type of the array.
-	public Object[] array;	// The array it self.
-	public TransmitableArray(int typeID, Object[] anArray) {
-		componentTypeID = typeID;
-		array = anArray;
-	}
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/UnexpectedCommandException.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/UnexpectedCommandException.java
deleted file mode 100644
index d9e137a..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/UnexpectedCommandException.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common.remote;
-/*
- *  $RCSfile: UnexpectedCommandException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-/**
- * This is an exception that is thrown when the processing
- * of data was invalid for the command. 
- * There will be a flag indicting error type, and a flag
- * indicating whether the connection is recoverable or not.
- * If not recoverable, then the connection needs to be closed.
- *
- */
-public class UnexpectedCommandException extends CommandException {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = 7097693384453243113L;
-	private final Object fErrorType;
-	private final boolean fRecoverable;
-	
-	public UnexpectedCommandException(Object errorType, boolean recoverable) {
-		fErrorType = errorType;
-		fRecoverable = recoverable;
-	}		
-	
-	public UnexpectedCommandException(Object errorType, boolean recoverable, Object data) {
-		super(data);
-		fErrorType = errorType;
-		fRecoverable = recoverable;
-	}
-	
-	public UnexpectedCommandException(Object errorType, boolean recoverable, String msg, Object data) {
-		super(msg, data);
-		fErrorType = errorType;
-		fRecoverable = recoverable;
-	}
-
-	public Object getErrorType() {
-		return fErrorType;
-	}
-	
-	public boolean isRecoverable() {
-		return fRecoverable;
-	}
-	
-	public String getMessage() {
-		String m = super.getMessage();
-		if (fErrorType != null) {
-			String dataMsg = getExceptionData() != null ? " Errordata="+getExceptionData().toString() : "";	//$NON-NLS-1$ //$NON-NLS-2$
-			if (m == null)
-				return "Errortype="+fErrorType.toString() + dataMsg; //$NON-NLS-1$
-			else
-				return m + ':' + "Errortype="+fErrorType.toString() + dataMsg; //$NON-NLS-1$
-		} else
-			return m;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/UnexpectedExceptionCommandException.java b/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/UnexpectedExceptionCommandException.java
deleted file mode 100644
index 8467fee..0000000
--- a/plugins/org.eclipse.jem.proxy/remoteCommon/org/eclipse/jem/internal/proxy/common/remote/UnexpectedExceptionCommandException.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.common.remote;
-/*
- *  $RCSfile: UnexpectedExceptionCommandException.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-/**
- * Wrapper an unexpected exception in a Command Exception.
- */
-public class UnexpectedExceptionCommandException extends UnexpectedCommandException {
-
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -1654134370115650969L;
-
-	public UnexpectedExceptionCommandException(boolean recoverable, Throwable data) {
-		super(Commands.SOME_UNEXPECTED_EXCEPTION, recoverable, data);
-	}
-	
-	public UnexpectedExceptionCommandException(boolean recoverable, String msg, Throwable data) {
-		super(Commands.SOME_UNEXPECTED_EXCEPTION, recoverable, msg, data);
-	}
-	
-	public Throwable getException() {
-		return (Throwable) getExceptionData();
-	}
-	
-	public String getMessage() {
-		String localMsg = super.getMessage();
-		if (getException() != null)
-			if (localMsg == null || localMsg.length() == 0)
-				return getException().getLocalizedMessage();
-			else
-				return localMsg + ": " + getException().getLocalizedMessage(); //$NON-NLS-1$
-		return
-			localMsg;
-	}
-	
-	public void printExceptionStackTrace() {
-		getException().printStackTrace();
-	}
-	
-	public void printStackTrace() {
-		printExceptionStackTrace();
-	}
-	
-	public void printStackTrace(java.io.PrintStream p) {
-		getException().printStackTrace(p);
-	}
-
-	public void printStackTrace(java.io.PrintWriter p) {
-		getException().printStackTrace(p);
-	}	
-}
diff --git a/plugins/org.eclipse.jem.proxy/schema/contributors.exsd b/plugins/org.eclipse.jem.proxy/schema/contributors.exsd
deleted file mode 100644
index 4d014f3..0000000
--- a/plugins/org.eclipse.jem.proxy/schema/contributors.exsd
+++ /dev/null
@@ -1,149 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jem.proxy">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jem.proxy" id="contributors" name="Proxy Configuration Contributors"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to supply configuration contributors for proxy support. You can supply a contributor for a specific classpath container or for a plugin.
-&lt;p&gt;
-The way configuration contributors work is that when a proxy vm is started, it first runs through all of the explicit contributors that were given to it. It then goes through the classpath of the project and finds the containers. If the container implements IConfigurationContributor, it will be called as a contributor. Then all of the extensions of this extension point will be searched for those have the same container id, and if so they will be called as a contributor.
-&lt;p&gt;
-The extensions will be called in plugin order. In other words if plugin A depends on plugin B, the contribution in plugin A will not be called before the contribution in plugin B.
-&lt;p&gt;
-If a plugin is in the classpath of the project (in other words the project is PDE plugin development project and requires a plugin) then the contributor with the given plugin id will be called.
-&lt;p&gt;
-Both container and plugin can be specified, but at least one of them must be specified. If both are specified, then this entry will be used if either the container or the plugin is found in the classpath.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="contributor" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="contributor">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="class"/>
-         </appInfo>
-         <documentation>
-            A contributor. Either the container and/or the plugin attributes must be set.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="container" type="string">
-            <annotation>
-               <documentation>
-                  contributor is for a container. The value is the container id (e.g. &lt;b&gt;&quot;JRE_CONTAINER&quot;&lt;/b&gt;). This will match &quot;/JRE_CONTAINER&quot; or &quot;/JRE_CONTAINER/...&quot;. Or &lt;b&gt;&quot;JRE_CONTAINER/XYZ&quot;&lt;/b&gt; would match &quot;/JRE_CONTAINER/XYZ/...&quot;.
-&lt;p&gt;
-You can also use a regular expression. An expression such as &lt;b&gt;&quot;SWT_CONTAINER/.*/JFACE&quot;&lt;/b&gt; will match &quot;/SWT_CONTAINER/PDE/JFACE&quot; but will not match &quot;/SWT_CONTAINER&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="plugin" type="string">
-            <annotation>
-               <documentation>
-                  contributor is for a plugin. The value is the plugin id (e.g. &quot;org.eclipse.swt&quot;).
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the class that implements this contributor. The class must implement IConfigurationContributor.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.jem.internal.proxy.core.IConfigurationContributor"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         1.0.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a contributor: 
-
-&lt;p&gt;
-&lt;pre&gt;
- &lt;extension point=&quot;org.eclipse.jem.proxy.contributors&quot;&gt;
-  &lt;contributor
-   class=&quot;com.example.ContributorImplementation&quot;
-   container=&quot;MY_CONTAINER&quot;&gt;
-  &lt;/contributor&gt;
- &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The &lt;samp&gt;class&lt;/samp&gt; attribute must be a fully-qualified class that implements the &lt;samp&gt;org.eclipse.jem.internal.proxy.core.IConfigurationContributor&lt;/samp&gt; interface for contributor.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         There is &lt;samp&gt;org.eclipse.jem.internal.proxy.core.ConfigurationContributorAdapter&lt;/samp&gt; available to subclass to provide specific overrides. The default for the adapter is that it doesn&apos;t do anything.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004 IBM Corporation and others.&lt;br&gt;
-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 
-&lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/plugins/org.eclipse.jem.proxy/schema/extensions.exsd b/plugins/org.eclipse.jem.proxy/schema/extensions.exsd
deleted file mode 100644
index 38dc8db..0000000
--- a/plugins/org.eclipse.jem.proxy/schema/extensions.exsd
+++ /dev/null
@@ -1,157 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jem.proxy">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jem.proxy" id="extensions" name="Proxy Extension Registration Contributors"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to supply extension registrations for proxy support. You can supply an extension registration for a specific classpath container or for a plugin.
-&lt;p&gt;
-Just after the registry has been started and before any contributions to the registry can be made, the extension registrations for the given registry type (such as &quot;org.eclipse.jem.REMOTE&quot;) for any paths/plugins/containers that have that match will be executed. These are used to do extension registrations (such as BaseProxyFactroyRegistry.registerBeanTypeProxyFactory(String packageName, IBeanTypeProxyFactory aFactory)). These registrations shouldn&apos;t do any actual proxy calls because at this time not all of the extensions had been run yet and it may accidently reference a package that should have an extension factory on it, but that factory has not yet been registered. Instead the contributor extension point should be used for that because at that time all of the extensions will be registered.
-&lt;p&gt;
-The way extension registrations work is that when a proxy vm is started, it finds all of the extensions of this extension point will be searched for those have the same container id and registry type id, and if so they will be called as an extension registration.
-&lt;p&gt;
-If a plugin is in the classpath of the project (in other words the project is PDE plugin development project and requires a plugin) then the extension registration with the given plugin id will be called.
-&lt;p&gt;
-Both container and plugin can be specified, but at least one of them must be specified. If both are specified, then this entry will be used if either the container or the plugin is found in the classpath.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="registration" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="registration">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="class"/>
-         </appInfo>
-         <documentation>
-            Proxy Extension factories registration contributor. Used to contribute the factory extensions based upon the registry type (e.g. &quot;org.eclipse.jem.REMOTE&quot; for remote vm registries) depending upon the container or plugin path.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="registryType" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The type of the registry this extensionRegistration is for, such as &quot;org.eclipse.jem.REMOTE&quot; for the remote vm registry type.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="container" type="string">
-            <annotation>
-               <documentation>
-                  extension registration is for a container. The value is the container id (e.g. &lt;b&gt;&quot;JRE_CONTAINER&quot;&lt;/b&gt;). This will match &quot;/JRE_CONTAINER&quot; or &quot;/JRE_CONTAINER/...&quot;. Or &lt;b&gt;&quot;JRE_CONTAINER/XYZ&quot;&lt;/b&gt; would match &quot;/JRE_CONTAINER/XYZ/...&quot;.
-&lt;p&gt;
-You can also use a regular expression. An expression such as &lt;b&gt;&quot;SWT_CONTAINER/.*/JFACE&quot;&lt;/b&gt; will match &quot;/SWT_CONTAINER/PDE/JFACE&quot; but will not match &quot;/SWT_CONTAINER&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="plugin" type="string">
-            <annotation>
-               <documentation>
-                  extension registration is for a plugin. The value is the plugin id (e.g. &quot;org.eclipse.swt&quot;).
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the class that implements this extension registration. The class must implement IExtensionRegistration.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.jem.internal.proxy.core.IExtensionRegistration"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         1.1.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a contributor: 
-
-&lt;p&gt;
-&lt;pre&gt;
- &lt;extension point=&quot;org.eclipse.jem.proxy.extensions&quot;&gt;
-  &lt;contributor
-   registryType=&quot;org.eclipse.jem.REMOTE&quot;
-   class=&quot;com.example.ExtensionRegistrationImplementation&quot;
-   container=&quot;MY_CONTAINER&quot;&gt;
-  &lt;/contributor&gt;
- &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The &lt;samp&gt;class&lt;/samp&gt; attribute must be a fully-qualified class that implements the &lt;samp&gt;org.eclipse.jem.internal.proxy.core.IExtensionRegistration&lt;/samp&gt; interface for extension registration.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004 IBM Corporation and others.&lt;br&gt;
-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 
-&lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/AWTStarter.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/AWTStarter.java
deleted file mode 100644
index 761f48e..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/AWTStarter.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: AWTStarter.java,v $
- *  $Revision: 1.1 $  $Date: 2005/05/11 19:01:12 $ 
- */
-package org.eclipse.jem.internal.proxy.vm.remote;
-
-import java.awt.Toolkit;
- 
-
-/**
- * This class is used to do start the AWT eventqueue ahead of time to try to parallel process it.
- * @since 1.1.0
- */
-public class AWTStarter {
-
-	public static void startAWT() {
-		Thread t = new Thread() {
-			public void run() {
-				Thread.yield();	// So as not to possibly hold up the guy doing the starting.
-				Toolkit.getDefaultToolkit();
-			}
-		};
-		t.start();
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ArrayHelper.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ArrayHelper.java
deleted file mode 100644
index 9442223..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ArrayHelper.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: ArrayHelper.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-/**
- * This class provides similiar function as the java.lang.reflect.Array class but
- * it handles multi-dimensional arrays. Without this helper, the client would have
- * to walk down through each dimension executing a get command. This would mean
- * many transactions instead of one provided by this helper.
- *
- * It also provides some other helper functions for arrays that Array doesn't provide.
- */
-
-public final class ArrayHelper {
-	// It can never be instantiated.
-	private ArrayHelper() {
-	}
-	
-	public static Object get(Object array, int[] indexes) {
-		Object answer = array;
-		for (int i=0; i<indexes.length; i++)
-			answer = java.lang.reflect.Array.get(answer, indexes[i]);
-		return answer;
-	}
-	
-	public static byte getByte(Object array, int[] indexes) {
-		return ((Byte) get(array, indexes)).byteValue();
-	}
-	public static boolean getBoolean(Object array, int[] indexes) {
-		return ((Boolean) get(array, indexes)).booleanValue();
-	}
-	public static char getChar(Object array, int[] indexes) {
-		return ((Character) get(array, indexes)).charValue();
-	}	
-	public static double getDouble(Object array, int[] indexes) {
-		return ((Double) get(array, indexes)).doubleValue();
-	}
-	public static float getFloat(Object array, int[] indexes) {
-		return ((Float) get(array, indexes)).floatValue();
-	}
-	public static int getInt(Object array, int[] indexes) {
-		return ((Integer) get(array, indexes)).intValue();
-	}
-	public static long getLong(Object array, int[] indexes) {
-		return ((Long) get(array, indexes)).longValue();
-	}
-	public static short getShort(Object array, int[] indexes) {
-		return ((Short) get(array, indexes)).shortValue();
-	}
-	
-	public static void set(Object array, int[] indexes, Object value) {
-		Object subArray = array;
-		int upTo = indexes.length-1;
-		for (int i=0; i<upTo; i++)
-			subArray = java.lang.reflect.Array.get(subArray, indexes[i]);
-		java.lang.reflect.Array.set(subArray, indexes[upTo], value);
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/CallbackHandler.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/CallbackHandler.java
deleted file mode 100644
index 4d96656..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/CallbackHandler.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: CallbackHandler.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import java.net.Socket;
-import java.io.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.UnexpectedExceptionCommandException;
-import org.eclipse.jem.internal.proxy.common.*;
-/**
- * This is a handler for doing callbacks to the
- * client.
- *
- * This is package protected because no one should
- * use it from the outside. It is too critical that
- * callback's work only in this specified way.
- */
-class CallbackHandler extends ConnectionHandler implements ICallbackHandler {
-	public CallbackHandler(Socket sc, RemoteVMServerThread svr) {
-		super(sc, svr, null);
-	}		
-	
-	/**
-	 * Initiate a stream callback request.
-	 */
-	public void initiateCallbackStream(int callbackID, int msgID) throws CommandException {
-		try {
-			Commands.sendCallbackStreamCommand(out, callbackID, msgID);
-			out.flush();
-		} catch (CommandException e) {
-			throw e;
-		} catch (Exception e) {
-			throw new UnexpectedExceptionCommandException(false, e);
-		}
-		run();	// Now run and wait for return. If no command exeception thrown, then it signals to continue.
-	}
-	
-	/**
-	 * Write bytes to the client. If bytesToWrite is -1, then this is end and
-	 * no bytes are being written. Just write the -1 then.
-	 */
-	public void writeBytes(byte[] bytes, int bytesToWrite) throws CommandException {
-		try {
-			if (bytesToWrite != -1)
-				Commands.writeBytes(out, bytes, bytesToWrite);
-			else
-				out.writeInt(-1);
-		} catch (CommandException e) {
-			throw e;
-		} catch (Exception e) {
-			throw new UnexpectedExceptionCommandException(false, e);
-		}
-	}
-
-		
-	/**
-	 * Callback, but send the parm as an object, ie. it must
-	 * be nothing but constants, e.g. String, Integer, or an
-	 * array of constants. Constants should not be things like
-	 * regular objects. This is because only standard java.lang
-	 * type constants can be assured to be available on the other
-	 * client. Also you don't want to send big objects, except
-	 * maybe something like an array of bytes or strings. It must
-	 * be constants that don't need to be sent back for any reason
-	 * since their identity will be lost in the transfer.
-	 *
-	 * This should be used if there are no parms (i.e. it is null).
-	 */
-	public Object callbackAsConstants(int callbackID, int msgID, Object parm) throws CommandException {
-
-		try {
-			Commands.sendCallbackCommand(out, callbackID, msgID);
-			Commands.ValueObject v = new Commands.ValueObject();
-			sendObject(parm, SEND_AS_IS, v, out, false);
-			out.flush();
-		} catch (CommandException e) {
-			throw e;
-		} catch (Exception e) {
-			throw new UnexpectedExceptionCommandException(false, e);
-		}
-		return run();	// Now run and wait for return.
-	}
-	
-	
-	// A retriever is what handles the array part.
-	private class Retriever implements Commands.ValueRetrieve {
-		int index=0;
-		Object[] array;
-		Commands.ValueObject worker = new Commands.ValueObject();
-		
-		
-		public Retriever(Object[] anArray) {
-			array = anArray;
-		}
-		
-		public Commands.ValueObject nextValue() {
-			Object parm = array[index++];
-			if (parm != null) {
-				if (parm instanceof ICallbackHandler.TransmitableArray) {
-					// It is another array, create a new retriever.
-					worker.setArrayIDS(new Retriever(((ICallbackHandler.TransmitableArray) parm).getArray()), ((ICallbackHandler.TransmitableArray) parm).getArray().length, Commands.OBJECT_CLASS);
-				} else {
-					// They may add some new ID's and if there is an error, they
-					// won't get released, but that is a slight chance we will have
-					// to take because we don't know which ones were new and which
-					// ones weren't.
-					fillInValue(parm, NOT_A_PRIMITIVE, worker);
-				}
-			} else
-				worker.set();
-			return worker;
-		}
-	};
-		
-	private static final Object[] NULL_SENT = new Object[1];
-	/**
-	 * Callback, but send the parm as IDs so that proxies
-	 * will be created for the objects and can be referenced.
-	 *
-	 * This should be used even if there is only one parm.
-	 */
-	public Object callbackWithParms(int callbackID, int msgID, Object[] parms) throws CommandException {
-		try {
-			if (parms == null)
-				parms = NULL_SENT;
-				
-			Commands.ValueObject v = new Commands.ValueObject();
-							
-			v.setArrayIDS(new Retriever(parms), parms.length, Commands.OBJECT_CLASS);
-			Commands.sendCallbackCommand(out, callbackID, msgID);
-			Commands.writeValue(out, v, false);
-			out.flush();
-		} catch (CommandException e) {
-			throw e;
-		} catch (Exception e) {
-			throw new UnexpectedExceptionCommandException(false, e);
-		}
-		return run();	// Now run and wait for return.
-	}	
-	
-	/**
-	 * A closeHandler has been requested. This is called when
-	 * not waiting within a loop, so we need to do the cleanup ourselves.
-	 */
-	public void closeHandler() {
-		if (isConnected()) {
-			try {
-				Commands.sendQuitCommand(out);
-			} catch (IOException e) {
-			} finally {
-				if (in != null)
-					try {
-						in.close();
-					} catch (Exception e) {
-					}
-				if (out != null)
-					try {
-						out.close();
-					} catch (Exception e) {
-					}
-				close();
-				in = null;
-				out = null;
-				socket = null;
-			}
-		}
-	}
-			
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/CallbackOutputStream.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/CallbackOutputStream.java
deleted file mode 100644
index 238d2c1c..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/CallbackOutputStream.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: CallbackOutputStream.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import java.io.OutputStream;
-import java.io.IOException;
-import java.io.InterruptedIOException;
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.IOCommandException;
-/**
- * This is the special stream used to buffer and write a lot
- * of bytes to callback into the client.
- *
- * Before writing any bytes to the client, it will see if the
- * client has sent anything back. If it has, this is an indication
- * that that client has requested that the stream be closed. In that
- * case an InterruptedIOException is raised to indicate that
- * the stream will be closed and no more data will be sent.
- */
-public class CallbackOutputStream extends OutputStream {
-	
-	protected CallbackHandler fHandler;
-	protected RemoteVMServerThread fSvr;
-	protected byte[] fBuffer;
-	protected int fNextByte = 0;
-	
-	public CallbackOutputStream(CallbackHandler handler, RemoteVMServerThread svr) {
-		fHandler = handler;
-		fSvr = svr;
-		
-		Integer bufSize = Integer.getInteger("proxyvm.bufsize"); //$NON-NLS-1$
-		if (bufSize == null)
-			bufSize = new Integer(5000);
-		fBuffer = new byte[bufSize.intValue()];
-	}
-	
-	protected void clearStream() {
-		fSvr.returnCallbackHandler(fHandler);
-		fSvr = null;
-		fHandler = null;
-		fBuffer = null;
-	}
-	
-	protected void processException(CommandException e) throws IOException {
-		clearStream();
-		throw new IOCommandException(e);
-	}
-	
-	public void flush() throws IOException {
-		flushBuffer();
-		fHandler.out.flush();
-	}
-
-	protected void flushBuffer() throws IOException {
-		if (fHandler == null)
-			throw new IOException("Stream closed. No more operations permitted."); //$NON-NLS-1$
-		if (fNextByte > 0) {
-			try {
-				if (fHandler.in.available() > 0) {
-					// There was something waiting. This means a cancel has been requested.
-					fHandler.in.skip(fHandler.in.available());
-					close(false);	// Now close the stream. We need to have the close indicator sent so that the remote side, but we don't need to wait because the terminate response has already been sent.
-					throw new InterruptedIOException();
-				}
-				fHandler.writeBytes(fBuffer, fNextByte);
-				fNextByte = 0;
-			} catch (CommandException e) {
-				processException(e);
-			}
-		}
-	}
-	
-	/**
-	 * Closes this output stream and releases any system resources 
-	 * associated with this stream. The general contract of <code>close</code> 
-	 * is that it closes the output stream. A closed stream cannot perform 
-	 * output operations and cannot be reopened.
-	 * <p>
-	 * Close will send a -1 to the client and set to indicate it is closed.
-	 *
-	 * @exception  IOException  if an I/O error occurs.
-	 */
-	public void close() throws IOException {
-		close(true);
-	}
-	
-
-	protected void close(boolean wait) throws IOException {
-		if (fHandler != null) {
-			try {
-				flushBuffer();
-				try {				
-					fHandler.writeBytes(null, -1);
-					fHandler.out.flush();
-					if (wait) {
-						// Wait means wait for the remote side to send the terminated response.
-						// A normal close will do this. If the remote side sent a cancel request, then it has already
-						// sent the terminated response and it is waiting for us to send the end-of-file command.
-						
-						fHandler.in.readByte();	// Block and wait until the terminate request. There shouldn't be anything else in the pipeline.
-						if (fHandler.in.available() > 0)
-							// There was something else waiting. Let's just clear it out to be safe.
-							fHandler.in.skip(fHandler.in.available());
-					}
-				} catch (CommandException e) {
-					processException(e);
-				}
-			} finally {
-				clearStream();
-			}
-		}
-	}
-	
-	public void write(int b) throws IOException {
-		fBuffer[fNextByte++] = (byte) b;
-		if (fNextByte >= fBuffer.length)
-			flushBuffer();
-	}
-	
-	public void write(byte b[], int off, int len) throws IOException {
-		if (b == null) {
-		    throw new NullPointerException();
-		} else if ((off < 0) || (off > b.length) || (len < 0) ||
-			   ((off + len) > b.length) || ((off + len) < 0)) {
-		    throw new IndexOutOfBoundsException();
-		} else if (len == 0) {
-		    return;
-		}
-		
-		while (len > 0) {
-			int move = fBuffer.length-fNextByte;
-			if (len < move)
-				move = len;
-			System.arraycopy(b, off, fBuffer, fNextByte, move);
-			len -= move;
-			off += move;
-			fNextByte += move;
-			if (fNextByte >= fBuffer.length)
-				flushBuffer();
-		}
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ClassHelper.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ClassHelper.java
deleted file mode 100644
index 52ef482..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ClassHelper.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: ClassHelper.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-/**
- * This class is a helper for Class accessing functions.
- * Its main function is to bypass security. This is because
- * we don't care about security for remote vm. Security is
- * handled by the IDE and compilor over there. We do what
- * we're told.
- * 
- * @author richkulp
- */
-public class ClassHelper {
-
-	/**
-	 * Constructor for ClassHelper.
-	 */
-	private ClassHelper() {
-		super();
-	}
-	
-	private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
-	private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];	
-	public static Object newInstance(Class targetClass) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
-		// We want to get the default ctor, which is in the declared list. No need
-		// to worry about inheritance because ctors are never virtual.
-		Constructor ctor = targetClass.getDeclaredConstructor(EMPTY_CLASS_ARRAY);
-		ctor.setAccessible(true);
-		return ctor.newInstance(EMPTY_OBJECT_ARRAY);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ConnectionHandler.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ConnectionHandler.java
deleted file mode 100644
index c13d92f..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ConnectionHandler.java
+++ /dev/null
@@ -1,926 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: ConnectionHandler.java,v $
- *  $Revision: 1.15 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import java.io.*;
-import java.lang.reflect.Array;
-import java.net.Socket;
-import java.net.SocketException;
-import java.util.*;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-import org.eclipse.jem.internal.proxy.initParser.*;
-import org.eclipse.jem.internal.proxy.initParser.tree.NoExpressionValueException;
-
-/**
- * This handles one connection.
- */
-
-public class ConnectionHandler {	
-		
-	protected Socket socket;
-	final protected RemoteVMServerThread server;
-	final protected Thread connectionThread;
-	protected DataInputStream in;
-	protected DataOutputStream out;
-	
-	// Kludge: Bug in Linux 1.3.xxx of JVM. Closing a socket while the socket is being read/accept will not interrupt the
-	// wait. Need to timeout to the socket read/accept before the socket close will be noticed. This has been fixed
-	// in Linux 1.4. So on Linux 1.3 need to put timeouts in on those sockets that can be separately closed while reading/accepting.
-	static boolean LINUX_1_3 = "linux".equalsIgnoreCase(System.getProperty("os.name")) && System.getProperty("java.version","").startsWith("1.3");	 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	
-	/**
-	 * This may be running as a callback, in that case there is no connectionThread.
-	 */
-	public ConnectionHandler(Socket sc, RemoteVMServerThread svr, Thread connectionThread) {
-		socket = sc;
-		server = svr;
-		this.connectionThread = connectionThread;
-		
-		Integer bufSize = Integer.getInteger("proxyvm.bufsize"); //$NON-NLS-1$
-		if (bufSize == null)
-			bufSize = new Integer(5000);
-			
-		try {
-			out = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream(), bufSize.intValue()));
-			in = new DataInputStream(new BufferedInputStream(socket.getInputStream(), bufSize.intValue()));
-		} catch (IOException e) {
-		}
-			
-	}
-	
-	/**
-	 * Did this construct correctly.
-	 * This is needed because an exception could be thrown in the ctor and
-	 * that's not a good thing to do.
-	 */
-	public boolean isConnected() {
-		return socket != null;
-	}	
-	
-	/**
-	 * Request the thread to close down.
-	 */
-	public void close() {
-		if (socket != null) {
-			try {
-				Socket s = socket;
-				socket = null;
-				s.close();
-			} catch (Exception e) {
-			}
-		}
-	}
-	
-	// Map of ID to expression processers that are currently being processed.
-	private Map expressionProcessors = new HashMap();
-	
-	/**
-	 * Process and loop until told to stop. A callback_done will stop
-	 * the loop and will return a result. Otherwise null is returned.
-	 */
-	public Object run() throws CommandException {
-		Object result = null;		
-		boolean shutdown = false;
-		boolean closeWhenDone = true;
-		Commands.ValueObject valueObject = new Commands.ValueObject();	// Working value object so not continually recreated.
-		InvokableValueSender valueSender = new InvokableValueSender();	// Working valuesender so not continually recreated. 
-		try {
-			boolean doLoop = true;
-
-			/**
-			 * Note: In the cases below you will see a lot of finally clauses that null variables out.
-			 * This is because this is a long running loop, and variables declared within blocks are not
-			 * garbage collected until the method is terminated, so these variables once set would never
-			 * be GC'd. The nulling at the end of the case makes sure that any of those objects set are
-			 * now available for garbage collection when necessary.
-			 */		
-			while(doLoop && isConnected()) {
-				byte cmd = 0;
-				try {
-					if (LINUX_1_3)
-						socket.setSoTimeout(1000);	// Linux 1.3 bug, see comment on LINUX_1_3
-					cmd = in.readByte();
-					if (LINUX_1_3 && isConnected())
-						socket.setSoTimeout(0);	// Linux 1.3 bug, see comment on LINUX_1_3
-				} catch (InterruptedIOException e) {
-					continue;	// Timeout, try again
-				}
-				switch (cmd) {
-					case Commands.QUIT_CONNECTION:				
-						doLoop = false;	
-						break;	// Close this connection
-						
-					case Commands.TERMINATE_SERVER:
-						doLoop = false;		
-						shutdown = true;	// Shutdown everything
-						break;
-						
-					case Commands.GET_CLASS:
-						String className = in.readUTF();
-						Class aClass = null;
-						Class superClass = null;
-						String superClassName = null;
-						boolean added = false;
-						try {
-							aClass = Class.forName(className);	// Turns out using JNI format for array type will work fine.
-								
-							added = server.getIdentityID(aClass, valueObject);
-							boolean isInterface = aClass.isInterface();
-							boolean isAbstract = java.lang.reflect.Modifier.isAbstract(aClass.getModifiers());
-							superClass = aClass.getSuperclass();
-							superClassName = (superClass != null) ? superClass.getName() : ""; //$NON-NLS-1$
-							out.writeByte(Commands.GET_CLASS_RETURN);
-							out.writeInt(valueObject.objectID);
-							out.writeBoolean(isInterface);
-							out.writeBoolean(isAbstract);
-							out.writeUTF(superClassName);
-							out.flush();
-						} catch (ClassNotFoundException e) {
-							valueObject.set();
-							Commands.sendErrorCommand(out, Commands.GET_CLASS_NOT_FOUND, valueObject);						
-						} catch (ExceptionInInitializerError e) {
-							sendException(e.getException(), valueObject, out);								
-						} catch (LinkageError e) {
-							sendException(e, valueObject, out);								
-						} catch (Throwable e) {
-							// Something bad, did we add a class? If we did remove it from the table.
-							if (added)
-								server.removeObject(server.getObject(valueObject.objectID));
-							throw e;
-						} finally {
-							// clear out for GC to work.
-							className = null;
-							aClass = null;
-							superClass = null;
-							superClassName = null;
-							valueObject.set();
-						}
-						break;
-						
-					case Commands.GET_CLASS_FROM_ID:
-						int classID = in.readInt();
-						try {
-							aClass = (Class) server.getObject(classID);
-							boolean isInterface = aClass.isInterface();
-							boolean isAbstract = java.lang.reflect.Modifier.isAbstract(aClass.getModifiers());							
-							superClass = aClass.getSuperclass();
-							superClassName = (superClass != null) ? superClass.getName() : ""; //$NON-NLS-1$
-							out.writeByte(Commands.GET_CLASS_ID_RETURN);
-							out.writeUTF(aClass.getName());
-							out.writeBoolean(isInterface);
-							out.writeBoolean(isAbstract);
-							out.writeUTF(superClassName);
-							out.flush();
-						} catch (ClassCastException e) {
-							valueObject.set();
-							Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
-						} finally {	
-							// clear out for GC to work.
-							aClass = null;
-							superClass = null;
-							superClassName = null;
-							valueObject.set();							
-						}
-						break;
-
-					case Commands.GET_OBJECT_DATA:
-						int objectID = in.readInt();
-						Object anObject = null;
-						try {
-							anObject = server.getObject(objectID);
-							valueObject.setObjectID(objectID, server.getIdentityID(anObject.getClass()));
-							Commands.writeValue(out, valueObject, true);
-						} catch (ClassCastException e) {
-							valueObject.set();
-							Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
-						} finally {
-							anObject = null;	// Clear out for GC to work
-							valueObject.set();							
-						}
-						break;												
-						
-					case Commands.RELEASE_OBJECT:
-						int id = in.readInt();
-						server.removeObject(server.getObject(id));
-						break;						
-
-					case Commands.NEW_INIT_STRING:
-						classID = in.readInt();	// ID Of class to do new upon.
-						String initString = in.readUTF();	// The init string.
-						Object newValue = null;
-						Class theClass = null;
-						try {
-							theClass = (Class) server.getObject(classID);
-							if (theClass == null) {
-								// The class wasn't found. So imply ClassNotFound exception.
-								throw new ClassNotFoundException();
-							}
-							
-							InitializationStringParser parser = null;
-							try {
-								parser = InitializationStringParser.createParser(initString);
-								newValue = parser.evaluate();								
-								boolean primitive = parser.isPrimitive();
-								// If expected class is Void.TYPE, that means don't test the type of the result
-								// to verify if correct type, just return what it really is.
-								if (theClass != Void.TYPE && primitive != theClass.isPrimitive()) {
-									valueObject.set();
-									Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
-									continue;	// Goto next command.
-								} 
-								if (primitive) {
-									try {
-										// Need to do special tests for compatibility and assignment.
-										sendObject(newValue, classID != Commands.VOID_TYPE ? classID : server.getIdentityID(parser.getExpectedType()), valueObject, out, true);	// This will make sure it goes out as the correct primitive type
-									} catch (ClassCastException e) {
-										// The returned type is not of the correct type for what is expected.
-										valueObject.set();
-										Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
-										continue;	// Goto next command
-									}									
-								} else {
-									if (newValue != null) {
-										// Test to see if they are compatible. (Null can be assigned to any object,
-										// so that is why it was tested out above).
-										// If expected class is Void.TYPE, that means don't test the type of the result
-										// to verify if correct type, just return what it really is.
-										if (theClass != Void.TYPE && !theClass.isInstance(newValue)) {
-											// The returned type is not of the correct type for what is expected.
-											valueObject.set();
-											Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
-											continue;	// Goto next command
-										}
-									}
-									sendObject(newValue, NOT_A_PRIMITIVE, valueObject, out, true);	// Send out as an object.
-								}
-							} catch (InitializationStringEvaluationException e) {
-								if (e instanceof EvaluationException) {
-									// Want to return the real exception.
-									sendException(e.getOriginalException(), valueObject, out);
-								} else {
-									// Couldn't be evaluated, return an error for this.
-									setExceptionIntoValue(e.getOriginalException(), valueObject);
-									Commands.sendErrorCommand(out, Commands.CANNOT_EVALUATE_STRING, valueObject);
-								}
-							} finally {
-								parser = null;	// Clear out for GC to work
-							}									
-						} catch (Throwable e) {
-							sendException(e, valueObject, out);
-						} finally {
-							// Clear out for GC to work
-							initString = null;
-							theClass = null;
-							newValue = null;
-							valueObject.set();							
-						}	
-						break;						
-												
-					case Commands.INVOKE:
-						Object target = null;
-						Object[] parms = null;						
-						Class returnType = null;
-						java.lang.reflect.Method aMethod = null;						
-						try {					
-							int methodID = in.readInt();	// ID of method to invoke
-							aMethod = (java.lang.reflect.Method) server.getObject(methodID);	// Method to invoke
-							Commands.readValue(in, valueObject);
-							target = getInvokableObject(valueObject);	
-							Commands.readValue(in, valueObject);
-							if (valueObject.type == Commands.ARRAY_IDS) {
-								// It is an array containing IDs, as it normally would be.
-								valueSender.initialize(valueObject);
-								Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-								parms = (Object[]) valueSender.getArray();
-							} else {
-								// It is all objects or null, so it should be an Object[] or null. If not, then this is an error.
-								parms = (Object[]) valueObject.anObject;
-							}
-							
-							if (!aMethod.isAccessible())
-								aMethod.setAccessible(true);	// We will allow all to occur. Let access control be handled by IDE and compiler.
-							newValue = aMethod.invoke(target, parms);
-							returnType = aMethod.getReturnType();
-							if (returnType.isPrimitive()) {
-								int returnTypeID = server.getIdentityID(returnType);
-								// Need to tell sendObject the correct primitive type.
-								sendObject(newValue, returnTypeID, valueObject, out, true);
-				
-							} else {
-								sendObject(newValue, NOT_A_PRIMITIVE, valueObject, out, true);	// Just send the object back. sendObject knows how to iterpret the type
-							}									
-						} catch (CommandException e) {
-							throw e;	// Throw it again. These we don't want to come up as an exception proxy. These should end the thread.
-						} catch (java.lang.reflect.InvocationTargetException e) {
-							// This is a wrappered exception. Return the wrappered one so it looks like
-							// it was the real one. (Sometimes the method being invoked is on a java.lang.reflect.Constructor.newInstance,
-							// which in turn is an InvocationTargetException, so we will go until we don't have an InvocationTargetException.
-							Throwable t = e;
-							do {
-								t = ((java.lang.reflect.InvocationTargetException) t).getTargetException();
-							} while (t instanceof java.lang.reflect.InvocationTargetException);
-							sendException(t, valueObject, out);
-						} catch (Throwable e) {
-							sendException(e, valueObject, out);	// Turn it into a exception proxy on the client.
-						} finally {
-							// Clear out for GC to work
-							valueObject.set();
-							parms = null;
-							target = null;
-							aMethod = null;
-							returnType = null;
-							newValue = null;
-							valueSender.clear();
-						}					
-						break;
-						
-					case Commands.INVOKE_WITH_METHOD_PASSED:
-						aClass = null;
-						String methodName = null;
-						Class[] parmTypes = null;
-						target = null;
-						parms = null;						
-						returnType = null;
-						aMethod = null;						
-						
-						try {
-							Commands.readValue(in, valueObject);
-							aClass = (Class) getInvokableObject(valueObject); // The class that has the method.
-							methodName = in.readUTF();
-							Commands.readValue(in, valueObject);
-							if (valueObject.type == Commands.ARRAY_IDS) {
-								// It is an array containing IDs, as it normally would be.
-								valueSender.initialize(valueObject);
-								Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-								parmTypes = (Class[]) valueSender.getArray();
-							} else {
-								// It null, so it should be an null. If not, then this is an error.
-								parmTypes = null;
-							}
-							aMethod = aClass.getMethod(methodName, parmTypes);
-
-							// Now we get the info for the invocation of the method and execute it.
-							Commands.readValue(in, valueObject);
-							target = getInvokableObject(valueObject);	
-							Commands.readValue(in, valueObject);
-							if (valueObject.type == Commands.ARRAY_IDS) {
-								// It is an array containing IDs, as it normally would be.
-								valueSender.initialize(valueObject);
-								Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-								parms = (Object[]) valueSender.getArray();
-							} else {
-								// It is all objects or null, so it should be an Object[] or null. If not, then this is an error.
-								parms = (Object[]) valueObject.anObject;
-							}
-							
-							if (!aMethod.isAccessible())
-								aMethod.setAccessible(true);	// We will allow all to occur. Let access control be handled by IDE and compiler.
-							newValue = aMethod.invoke(target, parms);
-							returnType = aMethod.getReturnType();
-							if (returnType.isPrimitive()) {
-								int returnTypeID = server.getIdentityID(returnType);
-								// Need to tell sendObject the correct primitive type.
-								sendObject(newValue, returnTypeID, valueObject, out, true);
-				
-							} else {
-								sendObject(newValue, NOT_A_PRIMITIVE, valueObject, out, true);	// Just send the object back. sendObject knows how to iterpret the type
-							}									
-						} catch (CommandException e) {
-							throw e;	// Throw it again. These we don't want to come up as an exception proxy. These should end the thread.
-						} catch (java.lang.reflect.InvocationTargetException e) {
-							// This is a wrappered exception. Return the wrappered one so it looks like
-							// it was the real one. (Sometimes the method being invoked is on a java.lang.reflect.Constructor.newInstance,
-							// which in turn is an InvocationTargetException, so we will go until we don't have an InvocationTargetException.
-							Throwable t = e;
-							do {
-								t = ((java.lang.reflect.InvocationTargetException) t).getTargetException();
-							} while (t instanceof java.lang.reflect.InvocationTargetException);
-							sendException(t, valueObject, out);
-
-						} catch (Throwable e) {
-								sendException(e, valueObject, out);	// Turn it into a exception proxy on the client.
-						} finally {
-							aClass = null;
-							methodName = null;
-							parmTypes = null;
-							// Clear out for GC to work
-							valueObject.set();
-							parms = null;
-							target = null;
-							aMethod = null;
-							returnType = null;
-							newValue = null;
-							valueSender.clear();							
-						}
-						break;
-						
-					case Commands.GET_ARRAY_CONTENTS:
-						try {
-							target = server.getObject(in.readInt());	// Array to get the ids for.
-							valueObject.setArrayIDS(new ArrayContentsRetriever(target), Array.getLength(target), Commands.OBJECT_CLASS);
-							Commands.writeValue(out, valueObject, true);	// Write it back as a value command.
-						} catch (CommandException e) {
-							throw e;	// Throw it again. These we don't want to come up as an exception proxy. These should end the thread.
-						} catch (Throwable e) {
-							sendException(e, valueObject, out);	// Turn it into a exception proxy on the client.
-						} finally {
-							target = null;
-							valueObject.set();
-						}
-						break;
-						
-					case Commands.CALLBACK_DONE:
-						try {
-							if (connectionThread != null) {
-								valueObject.set();
-								Commands.sendErrorCommand(out, Commands.UNKNOWN_COMMAND_SENT, valueObject);
-							} else {
-								try {
-									Commands.readBackValue(in, valueObject, Commands.NO_TYPE_CHECK);
-									if (valueObject.type == Commands.ARRAY_IDS) {
-										// It is an array containing IDs, as it normally would be.
-										valueSender.initialize(valueObject);
-										Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-										result = (Object[]) valueSender.getArray();
-									} else {
-										result = getInvokableObject(valueObject);
-									}
-									doLoop = false; // We need to terminate and return result
-									closeWhenDone = false; // Don't close, we will continue.
-								} catch (CommandErrorException e) {
-									// There was an command error on the other side. This means 
-									// connection still good, but don't continue the callback processing.
-									doLoop = false; // We need to terminate and return result
-									closeWhenDone = false; // Don't close, we will continue.
-									throw e;	// Let it go on out.
-								}
-							}
-						} finally {
-							valueObject.set();
-							valueSender.clear();
-						}
-						break;
-						
-					case Commands.ERROR:
-						try {
-							// Got an error command. Don't know what to do but read the
-							// value and simply print it out.
-							Commands.readValue(in, valueObject);
-							result = getInvokableObject(valueObject);
-							System.out.println("Error sent to server: Result=" + result); //$NON-NLS-1$
-						} finally {
-							valueObject.set();
-						}
-						break;
-					
-					case Commands.EXPRESSION_TREE_COMMAND:
-						try {
-							processExpressionCommand(valueObject, valueSender);
-						} finally {
-							valueObject.set();
-							valueSender.clear();
-						}
-						break;
-						
-					default:
-						// Unknown command. We don't know how long it is, so we need to shut the connection down.
-						System.err.println("Error: Invalid cmd send to server: Cmd=" + cmd); //$NON-NLS-1$
-						doLoop = false;
-						closeWhenDone = true;
-						break;
-				}
-			}
-		} catch (EOFException e) {
-			// This is ok. It means that the connection on the other side was terminated.
-			// So just accept this and go down.
-		} catch (CommandException e) {
-			throw e;
-		} catch (SocketException e) {
-			if (socket != null)
-				throw new UnexpectedExceptionCommandException(false, e);	// socket null means a valid close request
-		} catch (Throwable e) {
-			e.printStackTrace();
-		} finally {
-			if (closeWhenDone) {
-				try {
-					for (Iterator itr = expressionProcessors.values().iterator(); itr.hasNext();) {
-						ExpressionProcesserController exp = (ExpressionProcesserController) itr.next();
-						exp.close();
-					}
-				} finally {
-					expressionProcessors.clear();
-				}
-
-				if (in != null)
-					try {
-						in.close();
-					} catch (Exception e) {
-					}
-				in = null;
-				if (out != null)
-					try {
-						out.close();
-					} catch (Exception e) {
-					}
-				out = null;
-				close();
-			}
-		}
-		
-		if (closeWhenDone && connectionThread != null)
-			server.removeConnectionThread(connectionThread);
-		if (shutdown)
-			server.requestShutdown();
-			
-		return result;
-	}
-	
-	// A retriever is what handles the array get contents.
-	private class ArrayContentsRetriever implements Commands.ValueRetrieve {
-		int index=0;
-		Object array;
-		int length;
-		int componentType;
-		Commands.ValueObject worker = new Commands.ValueObject();
-		
-		
-		public ArrayContentsRetriever(Object anArray) {
-			array = anArray;
-			length = Array.getLength(anArray);
-			if (anArray.getClass().getComponentType().isPrimitive()) {
-				componentType = server.getIdentityID(anArray.getClass().getComponentType());
-			} else
-				componentType = NOT_A_PRIMITIVE;
-		}
-		
-		public Commands.ValueObject nextValue() {
-			fillInValue(Array.get(array, index++), componentType, worker);
-			return worker;
-		}
-	};
-
-	
-	private void processExpressionCommand(Commands.ValueObject valueObject, InvokableValueSender valueSender) throws IOException, CommandException {
-		Integer expressionID = new Integer(in.readInt());
-		byte cmdType = in.readByte();
-		ExpressionProcesserController exp = null;
-		switch (cmdType) {
-			case ExpressionCommands.START_EXPRESSION_TREE_PROCESSING:
-				byte trace = in.readByte();
-				if (trace == ExpressionCommands.TRACE_DEFAULT)
-					exp = new ExpressionProcesserController(server, this);
-				else
-					exp = new ExpressionProcesserController(server, this, trace == ExpressionCommands.TRACE_ON);
-				expressionProcessors.put(expressionID, exp);
-				break;
-			case ExpressionCommands.TRANSFER_EXPRESSION_REQUEST:
-				exp = (ExpressionProcesserController) expressionProcessors.remove(expressionID); 
-				sendObject(exp, NOT_A_PRIMITIVE, valueObject, out, true);
-				break;
-			case ExpressionCommands.RESUME_EXPRESSION_REQUEST:
-				Commands.readValue(in, valueObject);
-				exp = (ExpressionProcesserController) getInvokableObject(valueObject); 
-				expressionProcessors.put(expressionID, exp);
-				break;
-			case ExpressionCommands.PUSH_EXPRESSION:
-				exp = (ExpressionProcesserController) expressionProcessors.get(expressionID);
-				exp.process(in);
-				break;
-			case ExpressionCommands.SYNC_REQUEST:
-				boolean haveProxies = in.readBoolean();	// See if we expression proxy ids that need to be resolved 
-				if (haveProxies) {
-					Commands.readValue(in, valueObject);
-					valueSender.initialize(valueObject);
-					Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-				}
-
-				exp = (ExpressionProcesserController) expressionProcessors.get(expressionID);
-				if (haveProxies)
-					sendExpressionProxyResolutions(valueObject, (int[]) valueSender.getArray(), exp);
-				if (exp.noErrors()) {
-					valueObject.set(true); // Mark that all is good.
-					Commands.writeValue(out, valueObject, true, true);
-				} else {
-					processExpressionError(exp, valueObject);
-				}
-				break;
-			case ExpressionCommands.PULL_VALUE_REQUEST:
-				haveProxies = in.readBoolean();	// See if we expression proxy ids that need to be resolved
-				if (haveProxies) {
-					Commands.readValue(in, valueObject);
-					valueSender.initialize(valueObject);
-					Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
-				}
-
-				exp = (ExpressionProcesserController) expressionProcessors.get(expressionID);
-				if (haveProxies)
-					sendExpressionProxyResolutions(valueObject, (int[]) valueSender.getArray(), exp);
-				if (exp.noErrors()) {
-					try {
-						Object[] pulledValue = exp.pullValue();
-						// Send back the command code for pull value. Don't flush. We will flush when all done.
-						if (((Class) pulledValue[1]).isPrimitive()) {
-							int returnTypeID = server.getIdentityID(pulledValue[1]);
-							// Need to tell sendObject the correct primitive type.
-							sendObject(pulledValue[0], returnTypeID, valueObject, out, true, true);
-							
-						} else {
-							sendObject(pulledValue[0], NOT_A_PRIMITIVE, valueObject, out, true, true);	// Just send the object back. sendObject knows how to iterpret the type
-						}
-					} catch (NoExpressionValueException e) {
-						sendNoValueErrorCommand(exp, valueObject);
-					}
-				} else 
-					processExpressionError(exp, valueObject);
-				break;
-			case ExpressionCommands.END_EXPRESSION_TREE_PROCESSING:
-				exp = (ExpressionProcesserController) expressionProcessors.remove(expressionID);
-				exp.close();
-				break;
-		}
-	}
-
-	/*
-	 * @param is
-	 * @param exp
-	 * 
-	 * @since 1.1.0
-	 */
-	private void sendExpressionProxyResolutions(Commands.ValueObject valueObject, final int[] proxyIDs, final ExpressionProcesserController exp) throws CommandException {
-		class ExpressionProxyRetriever implements Commands.ValueRetrieve {
-			int index = 0;
-			Object[] proxyResolution = new Object[2];
-			Commands.ValueObject worker = new Commands.ValueObject();
-
-			public Commands.ValueObject nextValue() {
-				int proxyID = proxyIDs[index++];
-				if (exp.pullExpressionProxyValue(proxyID, proxyResolution)) {
-					if (proxyResolution[1] != Void.TYPE) {
-						if (((Class) proxyResolution[1]).isPrimitive()) {
-							int returnTypeID = server.getIdentityID(proxyResolution[1]);
-							// Need to tell worker the correct primitive type.
-							fillInValue(proxyResolution[0], returnTypeID, worker);
-						} else {
-							fillInValue(proxyResolution[0], NOT_A_PRIMITIVE, worker);
-						}
-					} else
-						worker.setFlag(ExpressionCommands.EXPRESSIONPROXY_VOIDTYPE);	// It was resolved, but to not set due to void type of expression.
-				} else
-					worker.setFlag(ExpressionCommands.EXPRESSIONPROXY_NOTRESOLVED);	// It wasn't resolved.
-				
-				return worker;
-			}
-		};
-
-		valueObject.setArrayIDS(new ExpressionProxyRetriever(), proxyIDs.length, Commands.OBJECT_CLASS);
-		Commands.writeValue(out, valueObject, true, false);	// Write it back as a value command.
-
-	}
-
-	private void processExpressionError(ExpressionProcesserController exp, Commands.ValueObject valueObject) throws CommandException {
-		if (exp.isNoExpressionValue()) {
-			sendNoValueErrorCommand(exp, valueObject);
-		} else
-			sendException(exp.getErrorThrowable(), valueObject, out);
-	}
-
-	/*
-	 * @param exp
-	 * @param valueObject
-	 * @throws CommandException
-	 * 
-	 * @since 1.1.0
-	 */
-	private void sendNoValueErrorCommand(ExpressionProcesserController exp, Commands.ValueObject valueObject) throws CommandException {
-		setExceptionIntoValue(exp.getErrorThrowable(), valueObject);
-		Commands.sendErrorCommand(out, ExpressionCommands.EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION, valueObject);
-	}
-
-protected static final int NOT_A_PRIMITIVE = Commands.NOT_AN_ID;
-protected static final int SEND_AS_IS = -2;	// This means sends as an object not as an id.
-	
-public static final int CLASS_ADDED = 1;
-public static final int OBJECT_ADDED = 2;
-public int fillInValue(Object object, int primitiveTypeID, Commands.ValueObject valueObject) {
-	int added = 0;
-	if (object == null) {
-		valueObject.set();
-	} else {
-		int classID = 0;
-		if (primitiveTypeID != NOT_A_PRIMITIVE && primitiveTypeID != SEND_AS_IS) {
-			classID = primitiveTypeID;	// The object is really supposed to be a primitive of this type
-			switch (classID) {
-				case Commands.BOOLEAN_TYPE:
-					valueObject.set(((Boolean) object).booleanValue());
-					break;
-				case Commands.INTEGER_TYPE:
-					if (object instanceof Character)
-						valueObject.set((int) ((Character) object).charValue());	// Because char can be widened to an int
-					else
-						valueObject.set(((Number) object).intValue());					
-					break;
-				case Commands.BYTE_TYPE:
-					valueObject.set(((Number) object).byteValue());
-					break;
-				case Commands.CHARACTER_TYPE:
-					valueObject.set(((Character) object).charValue());
-					break;
-				case Commands.DOUBLE_TYPE:
-					if (object instanceof Character)
-						valueObject.set((double) ((Character) object).charValue());	// Because char can be widened to a double
-					else
-						valueObject.set(((Number) object).doubleValue());					
-					break;
-				case Commands.FLOAT_TYPE:
-					if (object instanceof Character)
-						valueObject.set((float) ((Character) object).charValue());	// Because char can be widened to a float
-					else
-						valueObject.set(((Number) object).floatValue());					
-					break;
-				case Commands.SHORT_TYPE:
-					valueObject.set(((Number) object).shortValue());
-					break;
-				case Commands.LONG_TYPE:
-					if (object instanceof Character)
-						valueObject.set((long) ((Character) object).charValue());	// Because char can be widened to a long
-					else
-						valueObject.set(((Number) object).longValue());					
-					break;
-			}
-		} else {
-			// It's not a primitive.
-			boolean addObject = false, addClass = false;			
-			Class objClass = object.getClass();
-			classID = server.getIdentityID(objClass);
-			if (classID == RemoteVMServerThread.ID_NOT_FOUND) {
-				Commands.ValueObject classValue = new Commands.ValueObject();
-				addClass = server.getIdentityID(objClass, classValue);
-				if (addClass)
-					added |= CLASS_ADDED;
-				classID = classValue.objectID;
-			}
-		
-			switch (classID) {
-				case Commands.BYTE_CLASS:
-					valueObject.set((Byte) object);
-					break;
-				case Commands.CHARACTER_CLASS:
-					valueObject.set((Character) object);
-					break;
-				case Commands.DOUBLE_CLASS:
-					valueObject.set((Double) object);
-					break;
-				case Commands.FLOAT_CLASS:
-					valueObject.set((Float) object);
-					break;
-				case Commands.INTEGER_CLASS:
-					valueObject.set((Integer) object);
-					break;
-				case Commands.LONG_CLASS:
-					valueObject.set((Long) object);
-					break;
-				case Commands.SHORT_CLASS:
-					valueObject.set((Short) object);
-					break;
-				case Commands.BOOLEAN_CLASS:
-					valueObject.set((Boolean) object);
-					break;
-				case Commands.STRING_CLASS:
-					valueObject.set((String) object);
-					break;
-				case Commands.BIG_DECIMAL_CLASS:
-					valueObject.set(object, Commands.BIG_DECIMAL_CLASS);
-					break;
-				case Commands.BIG_INTEGER_CLASS:
-					valueObject.set(object, Commands.BIG_INTEGER_CLASS);
-					break;
-				default:
-					if (primitiveTypeID != SEND_AS_IS) {
-						addObject = server.getIdentityID(object, valueObject);
-						if (addObject) {
-							added |= OBJECT_ADDED;			
-							valueObject.setObjectID(valueObject.objectID, classID);
-						} else
-							valueObject.setObjectID(valueObject.objectID);
-					} else
-						valueObject.set(object, classID);
-					break;
-			}
-		}
-	}
-	
-	return added;
-}
-
-public void sendObject(Object object, int primitiveTypeID, Commands.ValueObject valueObject, DataOutputStream out, boolean writeAsCommand) throws CommandException {
-	sendObject(object, primitiveTypeID, valueObject, out, writeAsCommand, writeAsCommand);
-}
-public void sendObject(Object object, int primitiveTypeID, Commands.ValueObject valueObject, DataOutputStream out, boolean writeAsCommand, boolean flush) throws CommandException {			
-	int added = fillInValue(object, primitiveTypeID, valueObject);
-	boolean sent = false;
-	try {
-		Commands.writeValue(out, valueObject, writeAsCommand, flush);	// Write it back as a value command.
-		sent = true;
-	} finally {
-		if (!sent) {
-			// Ending due to some problem, so clean up any added objects from the id table.
-			if ((added & OBJECT_ADDED) != 0)
-				server.removeObject(valueObject.objectID);
-			if ((added & CLASS_ADDED) != 0)
-				server.removeObject(valueObject.classID);
-		}
-	}
-}
-		
-	
-	public void sendException(Throwable e, Commands.ValueObject value, DataOutputStream out) throws CommandException {
-		// Exception ocurred, return a value command with the exception within it.
-		setExceptionIntoValue(e, value);
-		Commands.sendErrorCommand(out, Commands.THROWABLE_SENT, value);		
-	}
-
-	public void setExceptionIntoValue(Throwable e, Commands.ValueObject value) {		
-		server.getIdentityID(e, value);	// It should always create it so we don't need to know.
-		int eID = value.objectID;
-		Class eClass = e.getClass();							
-		server.getIdentityID(eClass, value);
-		int eClassID = value.objectID;
-		value.setException(eID, eClassID);
-	}
-	
-	/**
-	 * From the valueObject, get an Object that is invokable (i.e. can be the target of an invoke, or one of its parms).
-	 * If it is an array type, the a ValueSender is returned. The invoker needs to then cast this
-	 * to a ValueSender and call the readArray routine.
-	 */
-	public Object getInvokableObject(final Commands.ValueObject value) {
-		switch (value.type) {
-			case Commands.NEW_OBJECT_ID:
-			case Commands.OBJECT_ID:
-				// These need to have access to the server to get the real object
-				return server.getObject(value.objectID);						
-			default:
-				// These have all the info needed within the value object itself, so ask it.
-				return value.getAsObject();
-		}
-	}
-	
-	// Helper class for getting an array.
-	private class InvokableValueSender implements Commands.ValueSender {
-		int index = 0;
-		Object array;
-
-		public InvokableValueSender() {
-		}
-				
-		public InvokableValueSender(Commands.ValueObject arrayHeader) {
-			initialize(arrayHeader);
-		}
-		
-		public void initialize(Commands.ValueObject arrayHeader) {
-			index = 0;
-			Class arrayType = (Class) server.getObject(arrayHeader.classID);
-			array = java.lang.reflect.Array.newInstance(arrayType, arrayHeader.anInt);
-		}
-		
-		public void clear() {
-			array = null;
-			index = 0;
-		}
-		
-		public Object getArray() {
-			return array;
-		}
-					
-		// A new value is being sent to the array
-		public void sendValue(Commands.ValueObject value) {
-			java.lang.reflect.Array.set(array, index++, getInvokableObject(value));	// add it to the array
-		}
-					
-		// The next entry is an array too!
-		public Commands.ValueSender nestedArray(Commands.ValueObject arrayHeader) {
-			InvokableValueSender sender = new InvokableValueSender(arrayHeader);
-			// Take the newly created array and put it into the current array.
-			java.lang.reflect.Array.set(array, index++, sender.getArray());
-			return sender;
-		}
-	}
-
-}
-
-
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ConnectionThread.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ConnectionThread.java
deleted file mode 100644
index c472123..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ConnectionThread.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: ConnectionThread.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import java.net.Socket;
-
-import org.eclipse.jem.internal.proxy.common.CommandException;
-/**
- * This is a thread to handle one connection.
- */
-
-public class ConnectionThread extends Thread {	
-		
-	final protected ConnectionHandler connectionHandler;
-	
-	public ConnectionThread(Socket sc, RemoteVMServerThread svr, String name) {
-		super(name);
-
-		connectionHandler = new ConnectionHandler(sc, svr, this);
-	}
-	
-	/**
-	 * Request the thread to close down.
-	 */
-	public void close() {
-		try {
-			connectionHandler.close();
-		} catch (Exception e) {
-		}
-	}
-	
-	public void run() {
-		try {
-			connectionHandler.run();
-		} catch (CommandException e) {
-			e.printStackTrace();
-		}
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ExpressionProcesserController.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ExpressionProcesserController.java
deleted file mode 100644
index a6797d0..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/ExpressionProcesserController.java
+++ /dev/null
@@ -1,809 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ExpressionProcesserController.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:39:08 $ 
- */
-package org.eclipse.jem.internal.proxy.vm.remote;
-
-import java.io.DataInputStream;
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.List;
-
-import org.eclipse.jem.internal.proxy.common.*;
-import org.eclipse.jem.internal.proxy.common.remote.Commands;
-import org.eclipse.jem.internal.proxy.common.remote.ExpressionCommands;
-import org.eclipse.jem.internal.proxy.initParser.tree.*;
-
- 
-/**
- * This processes the commands for expression processing and sends them over
- * to the common expression processer.
- * 
- * This will be instantiated on the start of an expression. And then
- * each expression request from the IDE will be sent into here. The
- * reason this guy doesn't hold onto the connection and process the
- * entire expression is because we need to return to the connection
- * handler to keep the connection live (there is timeouts and stuff
- * in there that we don't want to duplicate here).
- * <p>
- * If there are any expression processing errors (versus hard io errors) we
- * will save up the error but don't do any more processing other than to make
- * sure we read the complete subcommand. This is so that the inputstream is left
- * in a valid state without standed data.
- * <p>
- * The at the sync point (either get value or sync subcommand) we will send back
- * the error.
- *  
- * @since 1.0.0
- */
-public class ExpressionProcesserController {
-
-	
-	protected final RemoteVMServerThread server;
-	protected final ConnectionHandler connHandler;	
-	protected final ExpressionProcesser exp;
-	protected Commands.ValueObject workerValue = new Commands.ValueObject();	// A worker value object so we don't need to keep creating them and releasing them.
-	private ClassLoader classLoader;
-	
-	/**
-	 * Create with a default expression processer and use default flag for trace.
-	 * @param server
-	 * 
-	 * @since 1.0.0
-	 */
-	public ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler) {
-		this(server, connHandler, new ExpressionProcesser(Boolean.getBoolean(ExpressionCommands.EXPRESSIONTRACE), Long.getLong(ExpressionCommands.EXPRESSIONTRACE_TIMER_THRESHOLD, -1L).longValue()));
-	}
-	
-	/**
-	 * Construct with a default expression processer.
-	 * @param server
-	 * @param connHandler
-	 * @param trace
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler, boolean trace) {
-		this(server, connHandler, new ExpressionProcesser(trace, Long.getLong(ExpressionCommands.EXPRESSIONTRACE_TIMER_THRESHOLD, -1L).longValue()));
-	}
-	
-	/**
-	 * Create from a subclass with a given expression processer.
-	 * 
-	 * @param server
-	 * @param exp
-	 * 
-	 * @since 1.0.0
-	 */
-	protected ExpressionProcesserController(RemoteVMServerThread server, ConnectionHandler connHandler, ExpressionProcesser exp) {
-		this.server = server;
-		this.connHandler = connHandler;
-		this.exp = exp;
-	}
-	
-	/**
-	 * Set the class loader to use for finding classes. If never set, or if <code>null</code>, then
-	 * <code>Class.forName</code> will be used.
-	 * 
-	 * @param classLoader
-	 * 
-	 * @since 1.0.0
-	 */
-	public void setClassLoader(ClassLoader classLoader) {
-		this.classLoader = classLoader;
-	}
-	
-	/*
-	 * Array of primitive type names. Used to look up primtive types in primitive types array. 
-	 * 
-	 * @since 1.0.0
-	 */
-	private static final List PRIMITIVE_NAMES = Arrays.asList(new String[] {"byte", "char", "short", "int", "long", "float", "double"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
-	private static final Class[] PRIMITIVE_TYPES = new Class[] {Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
-	/**
-	 * Load the class given the name. If not found, return null.
-	 * 
-	 * @param className
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected Class loadClass(String className) throws ClassNotFoundException {
-		if (className == null)
-			return null;
-		else if (className.endsWith("[]")) { //$NON-NLS-1$
-			// We have an array request instead. This is trickier.
-			return loadClass(MapTypes.getJNIFormatName(className));
-		} else {
-			int primIndex = PRIMITIVE_NAMES.indexOf(className);
-			if (primIndex >= 0)
-				return PRIMITIVE_TYPES[primIndex];
-			else if (classLoader == null) {
-				return Class.forName(className);
-			} else {
-				return classLoader.loadClass(className);
-			}
-		}
-	}
-
-	/**
-	 * Now process the input stream. If either throws occurs, this is a hard error and we must terminate
-	 * the entire connection. The input stream is in an unknown state.
-	 * 
-	 * @param in The input stream to get the data for the current sub-command.
-	 * 
-	 * @throws CommandException
-	 * @throws IOException
-	 * @since 1.0.0
-	 */
-	public void process(DataInputStream in) throws CommandException, IOException {
-		// In the following subcommand processing, we always read the entire subcommand from the stream.
-		// This is so that any errors during processing will not mess up the stream with unread data.
-		//
-		// Then we check if an error has occurred in the past. If it has, we simply break. This is because
-		// once an error occurred we don't want to continue wasting time evaluating, however we need to make
-		// sure that the stream is read completely so that we don't have a corrupted input stream. That way
-		// when all is done we can return the error and still have a valid connection socket.
-		byte subcommand = in.readByte();
-		try {
-			switch (subcommand) {
-				case InternalExpressionTypes.PUSH_TO_PROXY_EXPRESSION_VALUE:
-					// Getting a proxy push. The value is sent as valueObject, so use that to read it in.
-					Commands.readValue(in, workerValue);
-					Object value = connHandler.getInvokableObject(workerValue);
-					if (value == null)
-						exp.pushExpression(null, MethodHelper.NULL_TYPE);
-					else if (workerValue.isPrimitive())
-						exp.pushExpression(value, workerValue.getPrimitiveType());
-					else
-						exp.pushExpression(value, value.getClass());
-					break;
-
-				case InternalExpressionTypes.CAST_EXPRESSION_VALUE:
-					// Get a cast request. The type is sent as valueObject.
-					Commands.readValue(in, workerValue);
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushCast(classValue);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.INSTANCEOF_EXPRESSION_VALUE:
-					// Get a instanceof request. The type is sent as valueObject.
-					Commands.readValue(in, workerValue);
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushInstanceof(classValue);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.INFIX_EXPRESSION_VALUE:
-					// Get an infix request. The operator and operand type are sent as bytes.
-					byte infix_operator = in.readByte();
-					byte infix_operandType = in.readByte();
-					exp.pushInfix(InfixOperator.get(infix_operator), InternalInfixOperandType.get(infix_operandType));
-					break;
-
-				case InternalExpressionTypes.PREFIX_EXPRESSION_VALUE:
-					// Get a prefix request. The operator is sent as byte.
-					byte prefix_operandType = in.readByte();
-					exp.pushPrefix(PrefixOperator.get(prefix_operandType));
-					break;
-
-				case InternalExpressionTypes.ARRAY_ACCESS_EXPRESSION_VALUE:
-					// Get an array access request. The index cound is sent as int.
-					int arrayAccess_Indexcount = in.readInt();
-					exp.pushArrayAccess(arrayAccess_Indexcount);
-					break;
-
-				case InternalExpressionTypes.ARRAY_CREATION_EXPRESSION_VALUE:
-					// Get an array creation request. The type is sent as valueObject, followed by int dimension count.
-					Commands.readValue(in, workerValue);
-					int arrayCreation_dimCount = in.readInt();
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushArrayCreation(classValue, arrayCreation_dimCount);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.ARRAY_INITIALIZER_EXPRESSION_VALUE:
-					// Get an array initializer request. The type is sent as valueObject, followed by int expression count.
-					Commands.readValue(in, workerValue);
-					int stripCount = in.readInt();
-					int arrayInitializer_expressionCount = in.readInt();
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushArrayInitializer(classValue, stripCount, arrayInitializer_expressionCount);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.CLASS_INSTANCE_CREATION_EXPRESSION_VALUE:
-					// Get a class instance creation request. The type is sent as valueObject, followed by int argument count.
-					Commands.readValue(in, workerValue);
-					int newInstance_argCount = in.readInt();
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushClassInstanceCreation(classValue, newInstance_argCount);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.TYPERECEIVER_EXPRESSION_VALUE:
-					// Get a type receiver request. The type is sent as valueObject.
-					Commands.readValue(in, workerValue);
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushExpression(classValue, classValue);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.FIELD_ACCESS_EXPRESSION_VALUE:
-					// Get a field access request. Command.ValueObject, followed by hasReceiver as boolean.
-					Commands.readValue(in, workerValue);
-					boolean has_fieldAccess_receiver = in.readBoolean();
-					try {
-						Object fieldAccess = getFieldValue(workerValue);
-						exp.pushFieldAccess(fieldAccess, workerValue.getType() == Commands.STRING, has_fieldAccess_receiver);
-					} catch (ClassCastException e) {
-						exp.processException(e);	// Let the processor know we have a stopping error.						
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.METHOD_EXPRESSION_VALUE:
-					// Get a method invocation request. Sent as Commands.ValueObject, followed by hasReceiver as boolean., and argCount as int.
-					Commands.readValue(in, workerValue);
-					boolean has_method_receiver = in.readBoolean();
-					int method_argCount = in.readInt();
-					try {
-						Object method = getMethodValue(workerValue);					
-						exp.pushMethodInvocation(method, workerValue.getType() == Commands.STRING, has_method_receiver, method_argCount);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.CONDITIONAL_EXPRESSION_VALUE:
-					// Get a conditional expression request. The expression type (ie. condition/true/false) is sent as a byte
-					exp.pushConditional(InternalConditionalOperandType.get(in.readByte()));
-					break;
-					
-				case InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION_VALUE:
-					// Get an assignment expression request. The proxy id is sent as an int.
-					int proxyid = in.readInt();
-					exp.pushAssignment(new RemoteExpressionProxy(proxyid));
-					break;
-					
-				case InternalExpressionTypes.ASSIGNMENT_EXPRESSION_VALUE:
-					// Get an assignment expression request. Nothing else to read from stream.
-					exp.pushAssignment();
-					break;
-					
-				case InternalExpressionTypes.PUSH_TO_EXPRESSION_PROXY_EXPRESSION_VALUE:
-					// Get a push expression proxy expression. The proxy id is sent as an int.
-					// First test if a possible FailedExpressionProxy because we could of been pushing
-					// a failed reflection proxy.
-					proxyid = in.readInt();
-					try {
-						exp.getExpressionProxy(proxyid, new Object[] {null, null});
-					} catch (NoExpressionValueException e1) {						
-						if (e1.getProxy() != null) {
-							FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e1.getProxy();
-							exp.processException((Throwable) failure.getValue());
-							break;	// Don't go on, we processed it. A standard no expression value should be passed on and let following code handle it.
-						}
-					}
-					exp.pushExpressionProxy(proxyid);
-					break;
-				
-				case InternalExpressionTypes.BLOCK_BEGIN_EXPRESSION_VALUE:
-					// Get a begin block proxy expression. The block id is sent as an int.
-					exp.pushBlockBegin(in.readInt());
-					break;
-					
-				case InternalExpressionTypes.BLOCK_BREAK_EXPRESSION_VALUE:
-					// Get a break block proxy expression. The block id is sent as an int.
-					exp.pushBlockBreak(in.readInt());
-					break;
-					
-				case InternalExpressionTypes.BLOCK_END_EXPRESSION_VALUE:
-					// Get a end block proxy expression. The block id is sent as an int.
-					exp.pushBlockEnd(in.readInt());
-					break;
-					
-				case InternalExpressionTypes.TRY_BEGIN_EXPRESSION_VALUE:
-					// Get a try begin proxy expression. The try id is sent as an int.
-					exp.pushTryBegin(in.readInt());
-					break;
-					
-				case InternalExpressionTypes.TRY_CATCH_EXPRESSION_VALUE:
-					int tryNumber = in.readInt();
-					Commands.readValue(in, workerValue);
-					proxyid = in.readInt();
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushTryCatchClause(tryNumber, classValue, proxyid != -1 ? new RemoteExpressionProxy(proxyid) : null);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-
-				case InternalExpressionTypes.TRY_FINALLY_EXPRESSION_VALUE:
-					// Get a try finally proxy expression. The try id is sent as an int.
-					exp.pushTryFinallyClause(in.readInt());
-					break;
-
-				case InternalExpressionTypes.TRY_END_EXPRESSION_VALUE:
-					// Get a try end proxy expression. The try id is sent as an int.
-					exp.pushTryEnd(in.readInt());
-					break;
-					
-				case InternalExpressionTypes.THROW_EXPRESSION_VALUE:
-					exp.pushThrowException();
-					break;
-
-				case InternalExpressionTypes.RETHROW_EXPRESSION_VALUE:
-					// Get a rethrow proxy expression. The try id is sent as an int.
-					exp.pushTryRethrow(in.readInt());
-					break;
-
-				case InternalExpressionTypes.PUSH_BEANTYPE_EXPRESSIONPROXY_EXPRESSION_VALUE:
-					// Get the beantype expression proxy and resolve it.
-					proxyid = in.readInt();
-					String typeName = Commands.readStringData(in);
-					try {
-						Class classValue = loadClass(typeName);
-						RemoteExpressionProxy rep = new RemoteExpressionProxy(proxyid);
-						rep.setProxy(classValue, Class.class);
-						exp.allocateExpressionProxy(rep);
-					} catch (ClassNotFoundException e) {
-						FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
-						rep.setProxy(e, e.getClass());
-						exp.allocateExpressionProxy(rep);
-					} catch (LinkageError e) {
-						FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
-						rep.setProxy(e, e.getClass());
-						exp.allocateExpressionProxy(rep);
-					}
-					break;
-					
-				case InternalExpressionTypes.PUSH_METHOD_EXPRESSIONPROXY_EXPRESSION_VALUE:
-					// Get the Method expression proxy and resolve it.
-					// Comes over as:
-					//   int for proxy id for the method
-					//   beanTypeValue for declaring class (either beantype or expression proxy)
-					//   string for method name
-					//   int for arg count
-					//   beanTypeValue(s) for arg types (as many as arg count).
-					proxyid = in.readInt();
-					Commands.ValueObject decClassValue =  Commands.readValue(in, new Commands.ValueObject());
-					String methodName = Commands.readStringData(in);
-					int argCount = in.readInt();
-					Commands.ValueObject[] args = null;
-					if (argCount > 0) {
-						args = new Commands.ValueObject[argCount];
-						for (int i = 0; i < argCount; i++) {
-							args[i] = Commands.readValue(in, new Commands.ValueObject());
-						}
-					}
-					Class decClass = null;
-					Class[] argClasses = null;
-					try {
-						decClass = getBeanTypeValue(decClassValue);
-						argClasses = null;
-						if (argCount>0) {
-							argClasses = new Class[argCount];
-							for (int i = 0; i < argCount; i++) {
-								argClasses[i] = getBeanTypeValue(args[i]);
-							}
-						}
-						// Now get the method itself.
-						Method m = decClass.getMethod(methodName, argClasses);
-						RemoteExpressionProxy rep = new RemoteExpressionProxy(proxyid);
-						rep.setProxy(m, Method.class);
-						exp.allocateExpressionProxy(rep);
-					} catch (FailedProxyException e) {
-						FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
-						rep.setProxy(e.getCause(), e.getCause().getClass());
-						exp.allocateExpressionProxy(rep);
-					} catch (NoSuchMethodException e) {
-						// The default trace doesn't show what method was being searched for, so recreate with that.
-						StringBuffer s = new StringBuffer();
-						s.append(decClass.getName());
-						s.append('.');
-						s.append(methodName);
-						s.append('(');
-						if (argClasses != null) {
-							for (int i = 0; i < argClasses.length; i++) {
-								if (i > 0)
-									s.append(',');
-								s.append(argClasses[i].getName());
-							}
-						}
-						s.append(')');
-						NoSuchMethodException ne = new NoSuchMethodException(s.toString());
-						ne.setStackTrace(e.getStackTrace());
-						FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
-						rep.setProxy(ne, ne.getClass());
-						exp.allocateExpressionProxy(rep);
-					}					
-					break;
-					
-				case InternalExpressionTypes.PUSH_FIELD_EXPRESSIONPROXY_EXPRESSION_VALUE:
-					// Get the Filed expression proxy and resolve it.
-					// Comes over as:
-					//   int for proxy id for the field
-					//   beanTypeValue for declaring class (either beantype or expression proxy)
-					//   string for field name
-					proxyid = in.readInt();
-					decClassValue =  Commands.readValue(in, new Commands.ValueObject());
-					String fieldName = Commands.readStringData(in);
-					try {
-						decClass = getBeanTypeValue(decClassValue);
-						// Now get the field itself.
-						Field f = decClass.getField(fieldName);
-						RemoteExpressionProxy rep = new RemoteExpressionProxy(proxyid);
-						rep.setProxy(f, Method.class);
-						exp.allocateExpressionProxy(rep);
-					} catch (FailedProxyException e) {
-						FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
-						rep.setProxy(e.getCause(), e.getCause().getClass());
-						exp.allocateExpressionProxy(rep);
-					} catch (NoSuchFieldException e) {
-						FailedRemoteExpressionProxy rep = new FailedRemoteExpressionProxy(proxyid);
-						rep.setProxy(e, e.getClass());
-						exp.allocateExpressionProxy(rep);
-					}					
-					break;					
-					
-				case InternalExpressionTypes.IF_TEST_EXPRESSION_VALUE:
-					// Get a if test expression request. 
-					exp.pushIfElse();
-					break;
-					
-				case InternalExpressionTypes.IF_ELSE_EXPRESSION_VALUE:
-					// Get a if/else expression clause request. The clause type (ie. true/false) is sent as a byte
-					exp.pushIfElse(InternalIfElseOperandType.get(in.readByte()));
-					break;
-					
-				case InternalExpressionTypes.NEW_INSTANCE_VALUE:
-					// Get a new instance from string.
-					String initString = Commands.readStringData(in);
-					workerValue =  Commands.readValue(in, new Commands.ValueObject());
-					try {
-						Class classValue = getBeanTypeValue(workerValue);
-						exp.pushNewInstanceFromString(initString, classValue, classLoader);
-					} catch (FailedProxyException e) {
-						exp.processException(e.getCause());	// Let the processor know we have a stopping error.
-					}
-					break;
-					
-				case InternalExpressionTypes.MARK_VALUE:
-					// Do a mark.
-					int markID = in.readInt();
-					exp.pushMark(markID);
-					break;
-					
-				case InternalExpressionTypes.ENDMARK_VALUE:
-					// Do an end mark.
-					markID = in.readInt();
-					boolean restore = in.readBoolean();
-					exp.pushEndmark(markID, restore);
-					break;
-					
-				case InternalExpressionTypes.SUBEXPRESSION_BEGIN_EXPRESSION_VALUE:
-					// Get a begin subexpression proxy expression. The subexpression id is sent as an int.
-					exp.pushSubexpressionBegin(in.readInt());
-					break;
-					
-				case InternalExpressionTypes.SUBEXPRESSION_END_EXPRESSION_VALUE:
-					// Get a end subexpression proxy expression. The subexpression id is sent as an int.
-					exp.pushSubexpressionEnd(in.readInt());
-					break;
-					
-			}
-			
-		} catch (RuntimeException e) {
-			exp.processException(e);
-		}
-		
-		workerValue.set();	// Clear it out so nothing being held onto.
-	}
-	
-	/**
-	 * This is an exception that is thrown from the getBeanType, field, method (reflect type stuff)
-	 * that wrappers the real throwable that occurred during the previous reflection. This is
-	 * because reflection is done out of sequence with the use of the reflect value. So we need
-	 * to store the reflection exception in this exception and then store this exception in
-	 * a {@link FailedRemoteExpressionProxy}. This will then be picked up when trying to be
-	 * used and it will get the true exception out of the {@link Throwable#getCause()}.
-	 * 
-	 * @since 1.1.0
-	 */
-	private static class FailedProxyException extends Exception {
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0
-		 */
-		private static final long serialVersionUID = 2872325672166348923L;
-
-		public FailedProxyException(Throwable realThrowable) {
-			super(realThrowable);
-		}
-	}
-	
-	/**
-	 * Get the beantype (class) out of the value object sent in. It can handle the beantype sent or
-	 * as an expression proxy to a beantype expression proxy.
-	 * 
-	 * @param value
-	 * @return
-	 * @throws FailedProxyException Wrappers the real throwable that caused the bean type to not be found.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected Class getBeanTypeValue(Commands.ValueObject value) throws FailedProxyException {
-		Object beantype = connHandler.getInvokableObject(value);
-		// It is either a type directly or is an expression proxy.
-		if (value.type == Commands.INT) {
-			// It is an expression proxy request.
-			Object[] expvalue = new Object[2];
-			try {
-				exp.getExpressionProxy(((Integer) beantype).intValue(), expvalue);
-				beantype = expvalue[0]; 
-			} catch (NoExpressionValueException e) {
-				// See if there is a failed proxy.
-				if (e.getProxy() != null) {
-					FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e.getProxy();
-					throw new FailedProxyException((Throwable) failure.getValue());
-				} else
-					throw new FailedProxyException(new ClassNotFoundException());	// This shouldn't of occurred.
-			} 
-		}
-		return (Class) beantype;
-	}
-		
-	/**
-	 * Get the method out of the value object sent in. It can handle the method sent or
-	 * as an expression proxy to a method expression proxy.
-	 * @param value
-	 * @return method if a method or string if a string or get the method if an expression proxy.
-	 * @throws FailedProxyException Wrappers the real Throwable that caused the method to not be found.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected Object getMethodValue(Commands.ValueObject value) throws FailedProxyException {
-		Object method = connHandler.getInvokableObject(value);
-		// It is either a method directly or is an expression proxy.
-		if (value.type == Commands.INT) {
-			// It is an expression proxy request.
-			Object[] expvalue = new Object[2];
-			try {
-				exp.getExpressionProxy(((Integer) method).intValue(), expvalue);
-				method = expvalue[0]; 
-			} catch (NoExpressionValueException e) {
-				// See if there is a failed proxy.
-				if (e.getProxy() != null) {
-					FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e.getProxy();
-					throw new FailedProxyException((Throwable) failure.getValue());
-				} else
-					throw new FailedProxyException(new NoSuchMethodException());	// This shouldn't of occurred.
-			}
-		}
-		return method;
-	}	
-
-	/**
-	 * Get the field out of the value object sent in. It can handle the field sent or
-	 * as an expression proxy to a field expression proxy.
-	 * @param value
-	 * @return field if a field or string if a string or get the field if an expression proxy.
-	 * @throws FailedProxyException Wrappers the real throwable that caused the field to not be found.
-	 * 
-	 * @since 1.1.0
-	 */
-	protected Object getFieldValue(Commands.ValueObject value) throws FailedProxyException {
-		Object field = connHandler.getInvokableObject(value);
-		// It is either a field directly or is an expression proxy.
-		if (value.type == Commands.INT) {
-			// It is an expression proxy request.
-			Object[] expvalue = new Object[2];
-			try {
-				exp.getExpressionProxy(((Integer) field).intValue(), expvalue);
-				field = expvalue[0]; 
-			} catch (NoExpressionValueException e) {
-				// See if there is a failed proxy.
-				if (e.getProxy() != null) {
-					FailedRemoteExpressionProxy failure = (FailedRemoteExpressionProxy) e.getProxy();
-					throw new FailedProxyException((Throwable) failure.getValue());
-				} else
-					throw new FailedProxyException(new NoSuchFieldException());	// This shouldn't of occurred.
-
-			} 
-		}
-		return field;
-	}	
-	
-	/**
-	 * Pull the Expression Proxy value into the result object.
-	 * @param proxyID
-	 * @param result
-	 * @return <code>true</code> if value could be returned, <code>false</code> if it was no expression value assigned.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean pullExpressionProxyValue(int proxyID, Object[] result) {
-		try {
-			exp.pullExpressionProxyValue(proxyID, result);
-			return true;
-		} catch (NoExpressionValueException e) {
-		}
-		return false;
-	}
-	
-	private static class RemoteExpressionProxy implements InternalExpressionProxy {
-
-		
-		private final int proxyID;
-		private Object value;
-		private Class type;
-		private boolean set;
-		
-		public RemoteExpressionProxy(int proxyID) {
-			this.proxyID = proxyID;
-			
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getProxyID()
-		 */
-		public int getProxyID() {
-			return proxyID;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getType()
-		 */
-		public Class getType() {
-			return type;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getValue()
-		 */
-		public Object getValue() {
-			return value;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#isSet()
-		 */
-		public boolean isSet() {
-			return set;
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#setProxy(java.lang.Object, java.lang.Class)
-		 */
-		public void setProxy(Object value, Class type) {
-			this.value = value;
-			this.type = type;
-			set = true;
-		}
-		
-		public boolean isFailedExpression() {
-			return false;
-		}
-	}
-	
-	/**
-	 * Used for the java.lang.reflect things (class, field, method) to indicate
-	 * why they aren't found.
-	 * <p>
-	 * The exception will be placed into value, BUT this should never be sent
-	 * back to the caller. It is intended only as a place-holder for subsequent
-	 * usage. Use the {@link RemoteExpressionProxy#isFailedExpression()} method
-	 * to determine if it is a failed one.
-	 * <p>
-	 * This is used because the reflect calls are done out of sequence from where
-	 * they are used and so if there was an error, the error is reported in the
-	 * wrong place.
-	 * 
-	 * @since 1.1.0
-	 */
-	private static class FailedRemoteExpressionProxy extends RemoteExpressionProxy {
-
-		public FailedRemoteExpressionProxy(int proxyID) {
-			super(proxyID);
-		}
-		
-		public boolean isFailedExpression() {
-			return true;
-		}
-		
-		public boolean isSet() {
-			return false;	// This should never be considered to be set. It is holder of info only.
-		}
-		
-	}
-	
-
-	/**
-	 * Pull the value. 
-	 * 
-	 * @return r[0] is the value, r[1] is the type of the value.
-	 * @throws NoExpressionValueException
-	 * 
-	 * @since 1.0.0
-	 */
-	public Object[] pullValue() throws NoExpressionValueException {
-		Object[] result = new Object[2];
-		exp.pullValue(result);
-		return result;
-	}
-				
-	/**
-	 * Close out things.
-	 * 
-	 * @since 1.0.0
-	 */
-	public void close() {
-		exp.close();
-	}
-	
-	/**
-	 * Get the throwable error.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public Throwable getErrorThrowable() {
-		return exp.getErrorThrowable();
-	}
-	
-	/**
-	 * Return whether there were no errors or not.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean noErrors() {
-		return exp.noErrors();
-	}
-	
-	/**
-	 * Return whether there is a no expression value exception or not.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isNoExpressionValue() {
-		return exp.isNoExpressionValue();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/IdentityMap.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/IdentityMap.java
deleted file mode 100644
index b0583e7..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/IdentityMap.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: IdentityMap.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import java.util.*;
-/**
- * A HashMap where the key is
- * done as an identity (i.e. found by '==' not equals()).
- */
-
-public class IdentityMap extends HashMap{
-	
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -6817274833221383683L;
-
-	/**
-	 * Key that returns true on equals() only
-	 * if the item it is wrappering is '=='
-	 * not equals()
-	 */
-	static class IdentityKey {
-		
-		public static IdentityKey createKey(Object obj) {
-			return obj != null ? new IdentityKey(obj) : null;
-		}
-		
-		final Object o;
-		
-		public IdentityKey(Object obj) {
-			o = obj;
-		}
-		
-		public boolean equals(Object obj) {
-			if (this == obj) return true;
-			if (!(obj instanceof IdentityKey)) return false;
-			if (this.o == (((IdentityKey) obj).o)) return true;
-			return false;
-		}
-		
-		public int hashCode() {
-			return o.hashCode();
-		}
-	}
-	
-	public IdentityMap() {
-	}
-	
-	public IdentityMap(int capacity) {
-		super(capacity);
-	}
-	
-	public IdentityMap(int capacity, float loadFactor) {
-		super(capacity, loadFactor);
-	}
-	
-	public boolean containsKey(Object key) {
-		return super.containsKey(IdentityKey.createKey(key));
-	}
-	
-	public Object get(Object key) {
-		return super.get(IdentityKey.createKey(key));
-	}
-	
-	public Object put(Object key, Object value) {
-		return super.put(IdentityKey.createKey(key), value);
-	}
-	
-	public Object remove(Object key) {
-		return super.remove(IdentityKey.createKey(key));
-	}
-	
-	/**
-	 * NOTE: Didn't bother implementing entrySet(). If that becomes
-	 * needed, then it will be implemented.
-	 */
-	public Set entrySet() {
-		throw  new UnsupportedOperationException();
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/RemoteVMApplication.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/RemoteVMApplication.java
deleted file mode 100644
index 570d663..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/RemoteVMApplication.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: RemoteVMApplication.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-/**
- * The application to run to kick off the remote VM server side.
- *
- *
- * All this does is start the Server Thread and waits for it to finish.
- * This allows other mains to have a server thread, and some other
- * threads if they wished. They could start the server thread too
- * and some other thread, and then wait for both to finish.
- */
-
-public class RemoteVMApplication {
-
-public static void main(java.lang.String[] args) {
-	String serverName = "Server Thread"; //$NON-NLS-1$
-	if (System.getProperty("proxyvm.servername") != null) //$NON-NLS-1$
-		serverName = serverName + "-" + System.getProperty("proxyvm.servername"); //$NON-NLS-1$ //$NON-NLS-2$
-	Thread t = new RemoteVMServerThread(serverName);
-	t.start();
-	try {
-		t.join();
-	} catch (Exception e) {
-	}
-	System.exit(0);
-}
-
-
-
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/RemoteVMServerThread.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/RemoteVMServerThread.java
deleted file mode 100644
index 2081fc7..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/RemoteVMServerThread.java
+++ /dev/null
@@ -1,717 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: RemoteVMServerThread.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import java.util.*;
-import java.io.*;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.net.*;
-import org.eclipse.jem.internal.proxy.common.remote.*;
-import org.eclipse.jem.internal.proxy.common.*;
-/**
- * RemoteVM Server Thread. This thread is the one
- * that waits for connections and spins off 
- * server connection threads. It manages the
- * connection threads and handles shutting them
- * down.
- *
- * System Properties:
- *   proxyvm.port - Port number to use for the ServerSocket (default is 8888)
- *   proxyvm.bufsize - Buffer size to use for TCP/IP buffers (default is system default)
- */
-
-public class RemoteVMServerThread extends Thread implements IVMServer, IVMCallbackServer {
-	protected List threads = Collections.synchronizedList(new LinkedList());	// List of active threads.
-	protected ServerSocket server;	// Server Socket for this application
-	private int highestIdentityID = 0;	// Identity codes to identify objects between server and client.
-	private Map objectToIDMap;
-	private HashMap idToObjectMap = new HashMap(100);	// Map from identity id to object
-	
-	protected Stack fCallbackHandlerPool = new Stack();	// Stack of free callback handlers
-	protected static int NUMBER_FREE_CALLBACKS = 5;	// Number of free callback handlers to keep open.
-	
-	public static int ID_NOT_FOUND = Commands.NOT_AN_ID;	// The id was not found in the table.
-	
-	protected int masterIDESocketPort = -1;	// Port of master server socket on IDE. Used for special global requests.
-	protected int registryKey = -1;	// Key of registry on the IDE.
-	
-	// Kludge: Bug in Linux 1.3.xxx of JVM. Closing a socket while the socket is being read/accept will not interrupt the
-	// wait. Need to timeout to the socket read/accept before the socket close will be noticed. This has been fixed
-	// in Linux 1.4. So on Linux 1.3 need to put timeouts in on those sockets that can be separately closed while reading/accepting.
-	static boolean LINUX_1_3 = "linux".equalsIgnoreCase(System.getProperty("os.name")) && System.getProperty("java.version","").startsWith("1.3");	 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-	
-	// If version 1.3.x, we need to use our IdentidyMap, if 1.4 or greater then we can use Java's IdentidyHashMap, which is more efficient than ours.
-	static Constructor IDENTIDYMAP_CLASS_CTOR;
-	static {
-		Class idClass;
-		try {
-			idClass = Class.forName("java.util.IdentityHashMap");
-		} catch (ClassNotFoundException e) {
-			idClass = IdentityMap.class;
-		}
-		try {
-			IDENTIDYMAP_CLASS_CTOR = idClass.getConstructor(new Class[] {Integer.TYPE});
-		} catch (SecurityException e) {
-			e.printStackTrace();
-		} catch (NoSuchMethodException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	public RemoteVMServerThread(String name) {
-		super(name);
-		try {
-			objectToIDMap = (Map) IDENTIDYMAP_CLASS_CTOR.newInstance(new Object[] {new Integer(100)});
-		} catch (IllegalArgumentException e) {
-			e.printStackTrace();
-		} catch (InstantiationException e) {
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			e.printStackTrace();
-		} catch (InvocationTargetException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	// The purpose of this thread is to wait 5 minutes, then see if the IDE is still
-	// up. If it isn't it will go down. This is safety mechanism
-	// in case the client went down without cleaning up and telling the server to go down.
-	// That way it won't hang around forever.
-	private boolean goingDown = false;
-	private Thread safeClean = new Thread(new Runnable() {
-		public void run() {
-			while (!goingDown) {
-				if (Thread.interrupted())
-					continue;	// Get to clean uninterrupted state.
-				try {
-					Thread.sleep(5 * 60 * 1000);	// Sleep five minutes
-					// Test if IDE still up.
-					if (!isAlive()) {
-						System.err.println("No registry available to connect with after five minutes. Shutting down.");	//$NON-NLS-1$
-						requestShutdown();
-						break;
-					}
-				} catch (InterruptedException e) {
-				}
-			}
-		}
-
-		/*
-		 * See if still alive
-		 */		
-		private boolean isAlive() {
-			Socket socket = getSocket();
-			if (socket != null) {
-				try {
-					DataOutputStream out = new DataOutputStream(socket.getOutputStream());
-					DataInputStream in = new DataInputStream(socket.getInputStream());
-					
-					try {
-						out.writeByte(Commands.ALIVE);
-						out.writeInt(registryKey);
-						out.flush();
-						return in.readBoolean();
-						// Now get the result.
-					} finally {
-						try {
-							in.close();
-						} catch (IOException e) {
-						}
-						try {
-							out.close();
-						} catch (IOException e) {
-						}
-					}
-				} catch (IOException e) {
-					e.printStackTrace();
-				} finally {
-					try {
-						socket.close();
-					} catch (IOException e) {
-						e.printStackTrace();	// They should be closing. If they aren't, then they accumulate and master server will start rejecting new ones.
-					}
-				}					
-			}
-			
-			return false;
-		}	
-		
-	}, "Timeout Termination Thread"); //$NON-NLS-1$
-	
-	
-	public void run() {
-		
-		// Initialize the mapping table with certain pre-defined ids.
-		synchronized(objectToIDMap) {
-			objectToIDMap.put(Void.TYPE, new Integer(Commands.VOID_TYPE));
-			idToObjectMap.put(new Integer(Commands.VOID_TYPE), Void.TYPE);
-			
-			objectToIDMap.put(Boolean.TYPE, new Integer(Commands.BOOLEAN_TYPE));
-			idToObjectMap.put(new Integer(Commands.BOOLEAN_TYPE), Boolean.TYPE);
-			objectToIDMap.put(Boolean.class, new Integer(Commands.BOOLEAN_CLASS));
-			idToObjectMap.put(new Integer(Commands.BOOLEAN_CLASS), Boolean.class);
-			
-			objectToIDMap.put(Integer.TYPE, new Integer(Commands.INTEGER_TYPE));
-			idToObjectMap.put(new Integer(Commands.INTEGER_TYPE), Integer.TYPE);
-			objectToIDMap.put(Integer.class, new Integer(Commands.INTEGER_CLASS));
-			idToObjectMap.put(new Integer(Commands.INTEGER_CLASS), Integer.class);
-			
-			objectToIDMap.put(Byte.TYPE, new Integer(Commands.BYTE_TYPE));
-			idToObjectMap.put(new Integer(Commands.BYTE_TYPE), Byte.TYPE);
-			objectToIDMap.put(Byte.class, new Integer(Commands.BYTE_CLASS));
-			idToObjectMap.put(new Integer(Commands.BYTE_CLASS), Byte.class);
-			
-			objectToIDMap.put(Short.TYPE, new Integer(Commands.SHORT_TYPE));
-			idToObjectMap.put(new Integer(Commands.SHORT_TYPE), Short.TYPE);
-			objectToIDMap.put(Short.class, new Integer(Commands.SHORT_CLASS));
-			idToObjectMap.put(new Integer(Commands.SHORT_CLASS), Short.class);	
-			
-			objectToIDMap.put(Long.TYPE, new Integer(Commands.LONG_TYPE));
-			idToObjectMap.put(new Integer(Commands.LONG_TYPE), Long.TYPE);
-			objectToIDMap.put(Long.class, new Integer(Commands.LONG_CLASS));
-			idToObjectMap.put(new Integer(Commands.LONG_CLASS), Long.class);
-			
-			objectToIDMap.put(Character.TYPE, new Integer(Commands.CHARACTER_TYPE));
-			idToObjectMap.put(new Integer(Commands.CHARACTER_TYPE), Character.TYPE);
-			objectToIDMap.put(Character.class, new Integer(Commands.CHARACTER_CLASS));
-			idToObjectMap.put(new Integer(Commands.CHARACTER_CLASS), Character.class);
-			
-			objectToIDMap.put(Double.TYPE, new Integer(Commands.DOUBLE_TYPE));
-			idToObjectMap.put(new Integer(Commands.DOUBLE_TYPE), Double.TYPE);
-			objectToIDMap.put(Double.class, new Integer(Commands.DOUBLE_CLASS));
-			idToObjectMap.put(new Integer(Commands.DOUBLE_CLASS), Double.class);
-			
-			objectToIDMap.put(Float.TYPE, new Integer(Commands.FLOAT_TYPE));
-			idToObjectMap.put(new Integer(Commands.FLOAT_TYPE), Float.TYPE);
-			objectToIDMap.put(Float.class, new Integer(Commands.FLOAT_CLASS));
-			idToObjectMap.put(new Integer(Commands.FLOAT_CLASS), Float.class);														
-						
-			objectToIDMap.put(String.class, new Integer(Commands.STRING_CLASS));
-			idToObjectMap.put(new Integer(Commands.STRING_CLASS), String.class);
-			
-			objectToIDMap.put(java.math.BigDecimal.class, new Integer(Commands.BIG_DECIMAL_CLASS));
-			idToObjectMap.put(new Integer(Commands.BIG_DECIMAL_CLASS), java.math.BigDecimal.class);
-			
-			objectToIDMap.put(java.math.BigInteger.class, new Integer(Commands.BIG_INTEGER_CLASS));
-			idToObjectMap.put(new Integer(Commands.BIG_INTEGER_CLASS), java.math.BigInteger.class);
-			
-			objectToIDMap.put(Number.class, new Integer(Commands.NUMBER_CLASS));
-			idToObjectMap.put(new Integer(Commands.NUMBER_CLASS), Number.class);				
-			
-			objectToIDMap.put(Throwable.class, new Integer(Commands.THROWABLE_CLASS));
-			idToObjectMap.put(new Integer(Commands.THROWABLE_CLASS), Throwable.class);	
-			
-			
-			objectToIDMap.put(Object.class, new Integer(Commands.OBJECT_CLASS));
-			idToObjectMap.put(new Integer(Commands.OBJECT_CLASS), Object.class);	
-						
-			objectToIDMap.put(Class.class, new Integer(Commands.CLASS_CLASS));
-			idToObjectMap.put(new Integer(Commands.CLASS_CLASS), Class.class);
-			
-			objectToIDMap.put(java.lang.reflect.AccessibleObject.class, new Integer(Commands.ACCESSIBLEOBJECT_CLASS));
-			idToObjectMap.put(new Integer(Commands.ACCESSIBLEOBJECT_CLASS), java.lang.reflect.AccessibleObject.class);								
-
-			objectToIDMap.put(java.lang.reflect.Method.class, new Integer(Commands.METHOD_CLASS));
-			idToObjectMap.put(new Integer(Commands.METHOD_CLASS), java.lang.reflect.Method.class);
-			
-			objectToIDMap.put(java.lang.reflect.Constructor.class, new Integer(Commands.CONSTRUCTOR_CLASS));
-			idToObjectMap.put(new Integer(Commands.CONSTRUCTOR_CLASS), java.lang.reflect.Constructor.class);				
-			
-			objectToIDMap.put(java.lang.reflect.Field.class, new Integer(Commands.FIELD_CLASS));
-			idToObjectMap.put(new Integer(Commands.FIELD_CLASS), java.lang.reflect.Field.class);	
-
-			objectToIDMap.put(IVMServer.class, new Integer(Commands.IVMSERVER_CLASS));
-			idToObjectMap.put(new Integer(Commands.IVMSERVER_CLASS), IVMServer.class);	
-
-			objectToIDMap.put(ICallback.class, new Integer(Commands.ICALLBACK_CLASS));
-			idToObjectMap.put(new Integer(Commands.ICALLBACK_CLASS), ICallback.class);	
-			
-			objectToIDMap.put(this, new Integer(Commands.REMOTESERVER_ID));
-			idToObjectMap.put(new Integer(Commands.REMOTESERVER_ID), this);	
-
-			objectToIDMap.put(RemoteVMServerThread.class, new Integer(Commands.REMOTEVMSERVER_CLASS));
-			idToObjectMap.put(new Integer(Commands.REMOTEVMSERVER_CLASS), RemoteVMServerThread.class);	
-
-			objectToIDMap.put(Thread.class, new Integer(Commands.THREAD_CLASS));
-			idToObjectMap.put(new Integer(Commands.THREAD_CLASS), Thread.class);	
-
-			objectToIDMap.put(ExpressionProcesserController.class, new Integer(Commands.EXPRESSIONPROCESSERCONTROLLER_CLASS));
-			idToObjectMap.put(new Integer(Commands.EXPRESSIONPROCESSERCONTROLLER_CLASS), ExpressionProcesserController.class);	
-
-			try {
-				java.lang.reflect.Method getMethod = Class.class.getMethod("getMethod", new Class[] {String.class, (new Class[0]).getClass()}); //$NON-NLS-1$
-				objectToIDMap.put(getMethod, new Integer(Commands.GET_METHOD_ID));
-				idToObjectMap.put(new Integer(Commands.GET_METHOD_ID), getMethod);	
-				
-				java.lang.reflect.Method initMethod = ICallback.class.getMethod("initializeCallback", new Class[] {IVMCallbackServer.class, Integer.TYPE}); //$NON-NLS-1$
-				objectToIDMap.put(initMethod, new Integer(Commands.INITIALIZECALLBACK_METHOD_ID));
-				idToObjectMap.put(new Integer(Commands.INITIALIZECALLBACK_METHOD_ID), initMethod);	
-				
-			} catch (NoSuchMethodException e) {
-				// Shouldn't really ever occur.
-			}				
-
-			highestIdentityID = Commands.FIRST_FREE_ID;		
-		}
-
-		masterIDESocketPort = Integer.getInteger("proxyvm.masterPort", -1).intValue(); //$NON-NLS-1$
-		if (masterIDESocketPort == -1) {
-			// No ports specified, need to just shutdown.
-			shutdown();
-			return;
-		}
-		
-		registryKey = Integer.getInteger("proxyvm.registryKey", -1).intValue(); //$NON-NLS-1$
-		if (registryKey == -1) {
-			// No registry specified, need to just shutdown.
-			shutdown();
-			return;
-		}		
-		
-		safeClean.setPriority(Thread.MIN_PRIORITY);
-		safeClean.start();	
-		boolean trying = true;
-		try {
-			server = new ServerSocket(0, 50 , InetAddress.getByName("localhost")); //$NON-NLS-1$
-			trying = false;
-			if (LINUX_1_3)
-				server.setSoTimeout(1000);	// Linux 1.3 bug, see comment on LINUX_1_3
-			if (registerServer(server.getLocalPort())) {
-				while(server != null) {
-					Socket incoming = null;
-					try {
-						incoming = server.accept();
-					} catch (InterruptedIOException e) {
-						continue;	// Timeout, try again
-					} catch (NullPointerException e) {
-						continue;	// Server could of gone null after test in while, means shutting down. This probably would only happen Linux 1.3.
-					}
-					Thread st = new ConnectionThread(incoming, this, "Connection Thread"); //$NON-NLS-1$
-					threads.add(st);
-					safeClean.interrupt();	// Let safeClean know there is a change
-					st.start();
-					// Null out locals so they can be GC'd since this is a long running loop.
-					st = null;
-					incoming = null;
-				}
-			}
-		} catch (SocketException e) {
-			if (trying || server != null)
-				e.printStackTrace();	// Exception and not shutdown request, so print stack trace.
-		} catch (Throwable e) {
-			e.printStackTrace();
-		}
-		
-		// We've had an exception, either something really bad, or we were closed,
-		// so go through shutdowns.
-		shutdown();		
-	}
-	
-	
-	/**
-	 * Get an identityID, return -1 if not found.
-	 */
-	public int getIdentityID(Object anObject) {
-		synchronized(objectToIDMap) {
-			Integer id = (Integer) objectToIDMap.get(anObject);
-			return id != null ? id.intValue() : ID_NOT_FOUND;
-		}
-	}
-	
-	/**
-	 * Get an identityID and add it if not found. Place the id in the
-	 * ValueObject passed in and return whether it was added (true) or was already in table (false)
-	 */
-	public boolean getIdentityID(Object anObject, Commands.ValueObject intoValue ) {
-		boolean added = false;
-		synchronized(objectToIDMap) {
-			Integer id = (Integer) objectToIDMap.get(anObject);
-			if (id == null) {
-				do {
-					if (++highestIdentityID == Commands.NOT_AN_ID)
-						++highestIdentityID;	// Don't let -1 be a valid id.
-					id = new Integer(highestIdentityID);
-				} while (idToObjectMap.containsKey(id)); // Make sure not in use, really shouldn't ever happen because we have over 4 billion before it wraps back
-				objectToIDMap.put(anObject, id);
-				idToObjectMap.put(id, anObject);
-				added = true;
-			} 
-			intoValue.setObjectID(id.intValue());
-		}
-		return added;
-	}
-	
-	/**
-	 * Remove an identity object from the mapping.
-	 */
-	public void removeObject(Object anObject) {
-		synchronized(objectToIDMap) {
-			Integer id = (Integer) objectToIDMap.remove(anObject);
-			idToObjectMap.remove(id);
-		}
-	}
-	
-	/**
-	 * Remove an identity object from the mapping, given the id.
-	 */
-	public void removeObject(int id) {
-		synchronized(objectToIDMap) {
-			Object o = idToObjectMap.remove(new Integer(id));
-			objectToIDMap.remove(o);
-		}
-	}
-	
-	/**
-	 * Get the object for an identity id
-	 */
-	public Object getObject(int id) {
-		synchronized(objectToIDMap) {
-			return idToObjectMap.get(new Integer(id));
-		}
-	} 
-	
-	/**
-	 * Remove a thread from the list.
-	 */
-	public void removeConnectionThread(Thread thread) {
-		threads.remove(thread);
-		safeClean.interrupt();	// Let safe clean know there is a change.
-	}
-	
-	/**
-	 * Use this to request a shutdown. If the server hasn't even been
-	 * created yet, this will return false.
-	 */
-	public boolean requestShutdown() {		
-		if (server == null)
-			return false;
-		// Closing the server socket should cause a break.
-		try {
-			ServerSocket srv = server;
-			server = null;	// So that server knows it is being shutdown and not print exception msg.
-			srv.close();
-		} catch (Exception e) {
-		}
-		return true;
-	}
-	
-	/**
-	 * Request a callback stream to write to.
-	 * When done, the stream should be closed to release the connection.
-	 */
-	public OutputStream requestStream(int callbackID, int msgID)  throws CommandException {
-		CallbackHandler h = (CallbackHandler) getFreeCallbackHandler();
-		if (h == null)
-			throw new CommandException("No callback handler retrieved.", null);	//$NON-NLS-1$
-		h.initiateCallbackStream(callbackID, msgID);
-		return new CallbackOutputStream(h, this);
-	}
-	
-	protected void shutdown() {
-		goingDown = true;
-		safeClean.interrupt();	// Let safeClean know to come down.
-		
-		if (server != null)
-			try {
-				server.close();	// Close it so that no more requests can be made.
-			} catch (Exception e) {
-			}
-		
-		// Go through each thread and ask it to close. Make a copy of the list so that we
-		// won't get into deadlocks.
-		ConnectionThread[] threadsArray = (ConnectionThread[]) threads.toArray(new ConnectionThread[0]);
-		for (int i=0; i<threadsArray.length; i++) {
-			// This is a harsh way to shut a connection down, but there's no
-			// other way I know of to interrupt the read on a socket.
-			threadsArray[i].close();
-		}
-			
-		// Now that they've been told to close, wait on each one to finish.
-		for (int i=0; i<threadsArray.length; i++)
-			try {
-				threadsArray[i].join(10000);	// Wait ten seconds, if longer, just go on to next one.
-				if (threadsArray[i].isAlive())
-					System.out.println("*** Connection "+i+" did not die."); //$NON-NLS-1$ //$NON-NLS-2$
-			} catch (InterruptedException e) {
-			}
-	
-		if (safeClean.isAlive()) {
-			try {	
-				safeClean.join(10000);
-				if (safeClean.isAlive())
-					System.out.println("*** Cleanup thread did not die."); //$NON-NLS-1$
-			} catch (InterruptedException e) {
-			}
-		}
-		
-		// Now close the callbacks.
-		synchronized(fCallbackHandlerPool) {
-			// Now we walk through all of the free handlers and close them properly.
-			Iterator itr = fCallbackHandlerPool.iterator();
-			while (itr.hasNext()) {
-				((CallbackHandler) itr.next()).closeHandler();
-			}
-			
-			fCallbackHandlerPool.clear();
-		}	
-		
-		List runnables = null;
-		synchronized (this) {
-			runnables = shutdownRunnables;
-			shutdownRunnables = null;
-		}
-		if (runnables != null) {
-			for (Iterator itr = runnables.iterator(); itr.hasNext();) {
-				try {
-					((Runnable) itr.next()).run();
-				} catch (RuntimeException e) {
-					e.printStackTrace();
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Return a free callback handler
-	 */
-	public ICallbackHandler getFreeCallbackHandler() {
-		synchronized(fCallbackHandlerPool) {
-			if (!fCallbackHandlerPool.isEmpty())
-				return (ICallbackHandler) fCallbackHandlerPool.pop();
-			// else we need to allocate one.			
-			return createCallbackHandler();
-		}
-	}
-	
-	/**
-	 * Make a new callback handler
-	 */
-	protected ICallbackHandler createCallbackHandler() {
-		Socket callbackSocket = requestCallbackSocket();
-		if (callbackSocket != null) {
-			CallbackHandler handler = new CallbackHandler(callbackSocket, this);
-			if (handler.isConnected())
-				return handler;
-				
-			// Failed, close the socket.
-			try {
-				callbackSocket.close();
-			} catch (IOException e) {
-			}
-		}
-		return null;
-	}	
-	
-	/**
-	 * Free the handler
-	 */
-	public void returnCallbackHandler(ICallbackHandler aHandler) {
-		CallbackHandler handler = (CallbackHandler) aHandler;
-		if (handler.isConnected())
-			synchronized (fCallbackHandlerPool) {
-				if (fCallbackHandlerPool.size() < NUMBER_FREE_CALLBACKS)
-					fCallbackHandlerPool.push(handler);
-				else
-					handler.closeHandler();	// We don't need to maintain more than five free connections.
-			}
-	}
-	
-	/**
-	 * Process a callback.
-	 */
-	public Object doCallback(ICallbackRunnable run) throws CommandException {
-		CallbackHandler handler = (CallbackHandler) getFreeCallbackHandler();
-		if (handler != null) {
-			try {
-				try {
-					return run.run(handler);
-				} catch (CommandErrorException e) {
-					// This is command error, connection still good, don't retry, just pass it on.
-					// It means the other side said I processed it, but there is an error.
-					throw e;
-				} catch (CommandException e) {
-					if (!e.isRecoverable()) {
-						// Close this handler and try a new one, one more time.
-						handler.closeHandler();
-						handler = (CallbackHandler) getFreeCallbackHandler();
-						try {
-							return run.run(handler);											
-						} catch (CommandException eAgain) {
-							// It failed again, just close the connection and rethrow the exception.
-							handler.closeHandler();
-							throw eAgain;
-						}
-					} else
-						throw e;	// Recoverable, rethrow exception.
-				}
-			} finally {
-				returnCallbackHandler(handler);
-			}
-		} else
-			throw new CommandException("No callback handler retrieved.", null);	//$NON-NLS-1$
-		
-	}
-	
-	/*
-	 * Register the server. Return if ide still active
-	 */
-	private boolean registerServer(int vmserverPort) {
-		Socket socket = getSocket();
-		if (socket != null) {
-			try {
-				DataOutputStream out = new DataOutputStream(socket.getOutputStream());
-				DataInputStream in = new DataInputStream(socket.getInputStream());
-				
-				try {
-					out.writeByte(Commands.REMOTE_STARTED);
-					out.writeInt(registryKey);
-					out.writeInt(vmserverPort);
-					out.flush();
-					return in.readBoolean();
-				} finally {
-					try {
-						in.close();
-					} catch (IOException e) {
-					}
-					try {
-						out.close();
-					} catch (IOException e) {
-					}
-				}
-			} catch (IOException e) {
-				e.printStackTrace();
-			} finally {
-				try {
-					socket.close();
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
-			}					
-
-		}
-		
-		return false;
-	}
-	
-	/*
-	 * Request the callback socket. <code>null</code> if there isn't one.
-	 */
-	private Socket requestCallbackSocket() {
-		Socket socket = getSocket();
-		if (socket != null) {
-			boolean closeSocket = true;
-			try {
-				DataOutputStream out = new DataOutputStream(socket.getOutputStream());
-				DataInputStream in = new DataInputStream(socket.getInputStream());
-				
-				try {
-					out.writeByte(Commands.ATTACH_CALLBACK);
-					out.writeInt(registryKey);
-					out.flush();
-					closeSocket = !in.readBoolean();
-					return !closeSocket ? socket : null;
-				} finally {
-					if (closeSocket) {
-						try {
-							in.close();
-						} catch (IOException e) {
-						}
-						try {
-							out.close();
-						} catch (IOException e) {
-						}
-					}
-				}
-			} catch (IOException e) {
-				e.printStackTrace();
-			} finally {
-				if (closeSocket) {
-					try {
-						socket.close();
-					} catch (IOException e) {
-						e.printStackTrace();
-					}
-				}
-			}					
-		}
-		
-		return null;
-	}	
-	
-
-
-	protected Socket getSocket() {
-		// We are putting it off into a thread because there are no timeout capabilities on getting a socket.
-		// So we need to allow for that.		
-		final Socket[] scArray = new Socket[1];
-		final boolean[] waiting = new boolean[] {true};		
-		Thread doIt = new Thread(new Runnable() {
-			public void run() {
-				try {
-					Socket sc = new Socket("localhost", masterIDESocketPort); //$NON-NLS-1$
-					synchronized (this) {
-						if (waiting[0])
-							scArray[0] = sc;
-						else
-							sc.close();	// We are no longer waiting on this thread so close the socket since no one will use it.
-					}					
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
-			}
-		});
-		
-		doIt.start();
-		while (true) {
-			try {
-				doIt.join(60000);
-				synchronized (doIt) {
-					waiting[0] = false;	// To let it know we are no longer waiting
-				}
-				break;
-			} catch (InterruptedException e) {
-			}
-		}
-		
-		if (scArray[0] == null) {
-			System.out.println("Couldn't retrieve a socket from master server in 60 seconds.");	//$NON-NLS-1$
-			return null;	// Couldn't get one, probably server is down.
-		}
-			
-		return scArray[0];
-	}
-	
-	private List shutdownRunnables;
-	
-	public synchronized void addShutdownListener(Runnable runnable) {
-		if (shutdownRunnables == null) {
-			shutdownRunnables = new ArrayList();
-		} else if (shutdownRunnables.contains(runnable))
-			return;
-		shutdownRunnables.add(runnable);
-	}
-	
-	public synchronized void removeShutdownListener(Runnable runnable) {
-		if (shutdownRunnables != null)
-			shutdownRunnables.remove(runnable);
-	}
-
-
-	public IVMServer getIVMServer() {
-		return this;
-	}
-}
diff --git a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/StackTraceUtility.java b/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/StackTraceUtility.java
deleted file mode 100644
index bdeb6ae..0000000
--- a/plugins/org.eclipse.jem.proxy/vm_remotevm/org/eclipse/jem/internal/proxy/vm/remote/StackTraceUtility.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.proxy.vm.remote;
-/*
- *  $RCSfile: StackTraceUtility.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:39:08 $ 
- */
-
-
-import java.io.*;
-/**
- * A utility to get the stack trace from an exception
- * back to the client.
- */
-public class StackTraceUtility {
-	
-	public static String printStackTrace(Throwable t) {
-		StringWriter writer = new StringWriter();
-		t.printStackTrace(new PrintWriter(writer));
-		return writer.toString();
-	}
-		
-
-}
diff --git a/plugins/org.eclipse.jem.ui/.classpath b/plugins/org.eclipse.jem.ui/.classpath
deleted file mode 100644
index 66f349e..0000000
--- a/plugins/org.eclipse.jem.ui/.classpath
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="ui"/>
-	<classpathentry kind="src" path="beaninfoui"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/plugins/org.eclipse.jem.ui/.cvsignore b/plugins/org.eclipse.jem.ui/.cvsignore
deleted file mode 100644
index 60463af..0000000
--- a/plugins/org.eclipse.jem.ui/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-bin
-build.xml
diff --git a/plugins/org.eclipse.jem.ui/.options b/plugins/org.eclipse.jem.ui/.options
deleted file mode 100644
index a7e0740..0000000
--- a/plugins/org.eclipse.jem.ui/.options
+++ /dev/null
@@ -1,3 +0,0 @@
-org.eclipse.jem.ui/debug/logtrace=default
-org.eclipse.jem.ui/debug/logtracefile=default
-org.eclipse.jem.ui/debug/loglevel=default
diff --git a/plugins/org.eclipse.jem.ui/.project b/plugins/org.eclipse.jem.ui/.project
deleted file mode 100644
index aee49c2..0000000
--- a/plugins/org.eclipse.jem.ui/.project
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem.ui</name>
-	<comment></comment>
-	<projects>
-		<project>org.eclipse.core.resources</project>
-		<project>org.eclipse.core.runtime.compatibility</project>
-		<project>org.eclipse.debug.core</project>
-		<project>org.eclipse.debug.ui</project>
-		<project>org.eclipse.jdt.core</project>
-		<project>org.eclipse.jdt.debug.ui</project>
-		<project>org.eclipse.jdt.launching</project>
-		<project>org.eclipse.jdt.ui</project>
-		<project>org.eclipse.jem.beaninfo</project>
-		<project>org.eclipse.jem.proxy</project>
-		<project>org.eclipse.jem.workbench</project>
-		<project>org.eclipse.ui</project>
-		<project>org.eclipse.ui.ide</project>
-	</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/plugins/org.eclipse.jem.ui/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.jem.ui/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 6dbabc3..0000000
--- a/plugins/org.eclipse.jem.ui/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,282 +0,0 @@
-#Thu Jun 16 13:22:06 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=error
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=1
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=0
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
-org.eclipse.jdt.core.formatter.comment.format_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
-org.eclipse.jdt.core.formatter.comment.line_length=150
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=150
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=tab
-org.eclipse.jdt.core.formatter.tabulation.size=4
diff --git a/plugins/org.eclipse.jem.ui/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.jem.ui/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 4cff627..0000000
--- a/plugins/org.eclipse.jem.ui/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed May 11 16:20:15 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.ignorelowercasenames=true
-org.eclipse.jdt.ui.importorder=java;javax;org;org.eclipse.wtp;org.eclipse.jem;org.eclipse.ve.internal.cdm;org.eclipse.ve.internal.cde;org.eclipse.ve.internal.jcm;org.eclipse.ve.internal.java;org.eclipse.ve;com;
-org.eclipse.jdt.ui.ondemandthreshold=3
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/plugins/org.eclipse.jem.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.jem.ui/META-INF/MANIFEST.MF
deleted file mode 100644
index 508ec7f..0000000
--- a/plugins/org.eclipse.jem.ui/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,26 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jem.ui; singleton:=true
-Bundle-Version: 1.2.0
-Bundle-Activator: org.eclipse.jem.internal.ui.core.JEMUIPlugin
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Export-Package: org.eclipse.jem.internal.beaninfo.ui,
- org.eclipse.jem.internal.ui.core,
- org.eclipse.jem.internal.ui.proxy,
- org.eclipse.jem.internal.ui.proxy.remote
-Require-Bundle: org.eclipse.core.resources,
- org.eclipse.jdt.core,
- org.eclipse.ui,
- org.eclipse.jdt.ui,
- org.eclipse.jem.beaninfo,
- org.eclipse.ui.ide,
- org.eclipse.debug.ui,
- org.eclipse.debug.core,
- org.eclipse.jem.proxy,
- org.eclipse.jdt.launching,
- org.eclipse.jdt.debug.ui,
- org.eclipse.jem.util,
- org.eclipse.core.runtime
-Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jem.ui/about.html b/plugins/org.eclipse.jem.ui/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/plugins/org.eclipse.jem.ui/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BIListElementSorter.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BIListElementSorter.java
deleted file mode 100644
index d24f2ed..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BIListElementSorter.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: BIListElementSorter.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 21:07:12 $ 
- */
-
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerSorter;
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry;
-
-/**
- * Sorter for sorting BPBeaninfoListElements within the main list.
- * 
- * @version 	1.0
- * @author
- */
-public class BIListElementSorter extends ViewerSorter {
-	
-	/*
-	 * @see ViewerSorter#category(Object)
-	 */
-	public int category(Object obj) {
-		if (obj instanceof BPBeaninfoListElement) {
-			BPBeaninfoListElement element = (BPBeaninfoListElement) obj;
-			
-			switch (((BeaninfoEntry) element.getEntry()).getKind()) {
-			case IClasspathEntry.CPE_LIBRARY:
-				return 4;
-			case IClasspathEntry.CPE_PROJECT:
-				return 1;
-			case IClasspathEntry.CPE_SOURCE:
-				return 0;
-			case IClasspathEntry.CPE_VARIABLE:
-				return 3;
-			case BeaninfoEntry.BIE_PLUGIN:
-				return 5;
-			case IClasspathEntry.CPE_CONTAINER:
-				return 2;
-			}
-		}
-		return super.category(obj);
-	}
-
-	/*
-	 * @see ViewerSorter#compare()
-	 */	
-	public int compare(Viewer viewer, Object e1, Object e2) {
-		int cat1 = category(e1);
-		int cat2 = category(e2);
-	
-		if (cat1 != cat2)
-			return cat1 - cat2;
-			
-		if ((e1 instanceof BPBeaninfoListElement) && (e2 instanceof BPBeaninfoListElement)) {
-			BeaninfoEntry p1 = (BeaninfoEntry) ((BPBeaninfoListElement) e1).getEntry();
-			BeaninfoEntry p2 = (BeaninfoEntry) ((BPBeaninfoListElement) e2).getEntry();
-			
-			// Compare paths
-			return p1.getPath().toString().compareTo(p2.getPath().toString());
-		}
-		return super.compare(viewer, e1, e2);
-	}	
-
-
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPBeaninfoListElement.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPBeaninfoListElement.java
deleted file mode 100644
index 082d5ae..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPBeaninfoListElement.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: BPBeaninfoListElement.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $ 
- */
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry;
-import org.eclipse.jem.internal.beaninfo.core.SearchpathEntry;
-
-/**
- * @version 	1.0
- * @author
- */
-public class BPBeaninfoListElement extends BPListElement {
-
-	BPSearchListElement[] searchpaths;
-	
-	/**
-	 * Constructor for BPBeaninfoListElement.
-	 * The searchPaths is the initial list, it is assumed that
-	 * the beaninfoEntry has these searchpaths in them too.
-	 */
-	public BPBeaninfoListElement(BeaninfoEntry entry, BPSearchListElement[] searchpaths, boolean missing) {
-		super(entry, missing);
-		this.searchpaths = searchpaths != null ? searchpaths : new BPSearchListElement[0];
-	}
-
-	/**
-	 * Mark the entry as exported.
-	 */
-	public void setExported(boolean exported) {
-		((BeaninfoEntry) entry).setIsExported(exported);
-	}
-
-	/*
-	 * @see BPListElement#canExportBeChanged()
-	 */
-	public boolean canExportBeChanged() {
-		return true;
-	}
-
-	/*
-	 * @see BPListElement#isExported()
-	 */
-	public boolean isExported() {
-		return ((BeaninfoEntry) entry).isExported();
-	}
-	
-	/**
-	 * Return the current list of Searchpaths for this Beaninfo Element.
-	 */
-	public BPSearchListElement[] getSearchpaths() {
-		return searchpaths;
-	}
-	
-	/**
-	 * Set the new list. This will update the beaninfo entry too.
-	 */
-	public void setSearchpaths(BPSearchListElement[] searchpaths) {
-		this.searchpaths = searchpaths;
-		
-		SearchpathEntry[] spEntries = new SearchpathEntry[searchpaths.length];
-		for (int i = 0; i < searchpaths.length; i++) {
-			BPSearchListElement bps = searchpaths[i];
-			spEntries[i] = (SearchpathEntry) bps.getEntry();
-		}
-		
-		((BeaninfoEntry) entry).setSearchPaths(spEntries);
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPListElement.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPListElement.java
deleted file mode 100644
index 2e56245..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPListElement.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: BPListElement.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $ 
- */
-
-
-import org.eclipse.jem.internal.beaninfo.core.IBeaninfosDocEntry;
-/**
- * A Base ListElement (i.e. element in a list viewer) for
- * a BeanInfo Search Path Entry.
- */
-
-public abstract class BPListElement extends Object {
-	protected IBeaninfosDocEntry entry;
-	protected boolean missing; // Library/folder/classpath entry for this entry could not be found.
-
-	public BPListElement(IBeaninfosDocEntry entry, boolean missing) {
-		this.entry = entry;
-		this.missing = missing;
-	}
-
-	public IBeaninfosDocEntry getEntry() {
-		return entry;
-	}
-
-	public boolean isMissing() {
-		return missing;
-	}
-
-	/**
-	 * Certain entries cannot have their export status changed.
-	 */
-	public abstract boolean canExportBeChanged();
-
-	/**
-	 * Return whether this entry is exported.
-	 */
-	public abstract boolean isExported();
-
-	/**
-	 * If export can be changed, change it.
-	 */
-	public abstract void setExported(boolean exported);
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPSearchListElement.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPSearchListElement.java
deleted file mode 100644
index 4f4331a..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BPSearchListElement.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: BPSearchListElement.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $ 
- */
-
-import org.eclipse.jem.internal.beaninfo.core.SearchpathEntry;
-
-/**
- * @version 	1.0
- * @author
- */
-public class BPSearchListElement extends BPListElement {
-
-	protected boolean exported;
-	protected boolean packageMissing;
-	/**
-	 * Constructor for BPSearchListElement.
-	 * @param entry
-	 * @param project
-	 * @param inMissing
-	 */
-	public BPSearchListElement(
-		SearchpathEntry entry,
-		boolean missing,
-		boolean packageMissing,
-		boolean exported) {
-		super(entry, missing);
-
-		this.packageMissing = packageMissing;
-		this.exported = exported;
-	}
-
-	/*
-	 * @see BPListElement#canExportBeChanged()
-	 */
-	public boolean canExportBeChanged() {
-		return false;
-	}
-
-	/*
-	 * @see BPListElement#isExported()
-	 */
-	public boolean isExported() {
-		return exported;
-	}
-
-	/**
-	 * Is the package missing.
-	 */
-	public boolean isPackageMissing() {
-		return packageMissing;
-	}
-	
-	/*
-	 * @see BPListElement#setExported(boolean)
-	 */
-	public void setExported(boolean exported) {
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeanInfoUIMessages.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeanInfoUIMessages.java
deleted file mode 100644
index 7bce516..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeanInfoUIMessages.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class BeanInfoUIMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.beaninfo.ui.messages";//$NON-NLS-1$
-
-	private BeanInfoUIMessages() {
-		// Do not instantiate
-	}
-
-	public static String SearchPathDialog_ChoosePackages;
-	public static String SearchPathDialog_Remove;
-	public static String SearchPathDialog_Desc_Label;
-	public static String SearchPathDialog_ModifySearchPaths;
-	public static String SearchPathDialog_NotEditable_INFO_;
-	public static String SearchPathDialog_PackagePresent_INFO_;
-	public static String SearchPathDialog_InputDialog_Title;
-	public static String SearchPathDialog_InputDialog_Message;
-	public static String BeanInfoPathsBlock_ExportAll;
-	public static String BeanInfoPathsBlock_UnexportAll;
-	public static String BeanInfoPathsBlock_Page_Tab_Packages;
-	public static String BeanInfoPathsBlock_Page_Tab_Classes;
-	public static String BeanInfosWorkbookPage_AddFolders;
-	public static String BeanInfosWorkbookPage_AddJARs;
-	public static String BeanInfosWorkbookPage_AddExternalJAR;
-	public static String BeanInfosWorkbookPage_AddVariable;
-	public static String BeanInfosWorkbookPage_AddProjects;
-	public static String BeanInfosWorkbookPage_ModifyPaths;
-	public static String BeanInfosWorkbookPage_Remove;
-	public static String BeanInfosWorkbookPage_List_Text;
-	public static String BeanInfosWorkbookPage_SelectionDialog_Classes_Title;
-	public static String BeanInfosWorkbookPage_SelectionDialog_JARs_Title;
-	public static String BeanInfosWorkbookPage_SelectionDialog_JARs_Message;
-	public static String BeanInfosWorkbookPage_SelectionDialog_ExtJARs_Text;
-	public static String BeanInfosWorkbookPage_SelectionDialog_Projects_Title;
-	public static String BeanInfosWorkbookPage_SelectionDialog_Classes_Prompt;
-	public static String BeanInfosWorkbookPage_SelectionDialog_Projects_Prompt;
-	public static String PackagesWorkbook_ChoosePackages;
-	public static String PackagesWorkbook_ChooseDefinedPaths;
-	public static String PackagesWorkbook_Remove;
-	public static String PackagesWorkbook_LabelText;
-	public static String PackagesWorkbook_SelectionDialog_DefinedPaths_Title;
-	public static String PackagesWorkbook_SelectionDialog_DefinedPaths_Message;
-	public static String LabelProvider_Library_Folder;
-	public static String LabelProvider_Library__PathLastSegment_PathRelative_;
-	public static String LabelProvider_Library__PathLastSegment_PathExceptLast_;
-	public static String LabelProvider_Variable__name_PathOSString_;
-	public static String LabelProvider__packageName_Path_;
-	public static String VariableSelectionBlock_variable_label;
-	public static String VariableSelectionBlock_variable_button;
-	public static String VariableSelectionBlock_extension_label;
-	public static String VariableSelectionBlock_extension_button;
-	public static String VariableSelectionBlock_fullpath_label;
-	public static String VariableSelectionBlock_error_entername_ERROR_;
-	public static String VariableSelectionBlock_error_namenotexists_ERROR_;
-	public static String VariableSelectionBlock_error_pathexists_ERROR_;
-	public static String VariableSelectionBlock_error_invalidextension_ERROR_;
-	public static String VariableSelectionBlock_warning_pathnotexists_WARN_;
-	public static String VariableSelectionBlock_ExtJarDialog_title;
-	public static String Beaninfo_UI__errortitle;
-	public static String Beaninfo_UI__error;
-	public static String BeaninfoPropertiesPage_INFO__nojavaproject;
-	public static String BeaninfoPropertiesPage_INFO__closedproject;
-	public static String BeaninfoPathsBlock_UI__enablebeaninfo;
-	public static String BeaninfoPathsBlock_UI__searchpath_label;
-	public static String BeaninfoPathsBlock_UI__searchpath_up_button;
-	public static String BeaninfoPathsBlock_UI__searchpath_down_button;
-	public static String BeaninfoPathsBlock_UI__searchpath_remove_button;
-	public static String BeaninfoPathsBlock_UI__serachpath_tab_order;
-	public static String BeaninfoPathsBlock_WARN__searchpath_missing_path_format;
-	public static String BeaninfoPathsBlock_UI__searchpath_operationdescription;
-	public static String BeaninfoPathsBlock_UI__addsearchpath_title;
-	public static String BeaninfoPathsBlock_UI__addsearchpath_description;
-	public static String BeaninfoPathsBlock_UI__warning_EntryMissing;
-	public static String BeaninfoPathsBlock_UI__searchpath_add_button;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, BeanInfoUIMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfoEntrySearchpathDialog.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfoEntrySearchpathDialog.java
deleted file mode 100644
index 2ccf00d..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfoEntrySearchpathDialog.java
+++ /dev/null
@@ -1,448 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: BeaninfoEntrySearchpathDialog.java,v $
- *  $Revision: 1.9 $  $Date: 2005/10/04 17:59:17 $ 
- */
-
-import java.text.MessageFormat;
-import java.util.*;
-import java.util.List;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.ui.JavaElementLabelProvider;
-import org.eclipse.jface.dialogs.*;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.viewers.*;
-import org.eclipse.jface.window.Window;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.*;
-import org.eclipse.swt.layout.*;
-import org.eclipse.swt.widgets.*;
-import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
-import org.eclipse.ui.dialogs.ISelectionStatusValidator;
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry;
-import org.eclipse.jem.internal.beaninfo.core.SearchpathEntry;
-
-/**
- * This dialog is used to display and modify the search path
- * within a BeaninfoEntry.
- * @version 	1.0
- * @author
- */
-public class BeaninfoEntrySearchpathDialog extends Dialog {
-	protected BPBeaninfoListElement infoElement;
-	protected IJavaProject jProject;
-	//protected ListDialogField listField;
-	
-	private Composite top;
-	private Table table;
-	private TableViewer tableViewer;
-	private Label label;
-	private Composite buttonsBar;
-	private Button upbutton;
-	private Button downButton;
-	private Button choosePackagesButton;
-	private Button removeButton;
-	private List tableElements;
-	private boolean enabled = true;
-
-	public BeaninfoEntrySearchpathDialog(
-		Shell parentShell,
-		BPBeaninfoListElement infoElement,
-		IJavaProject jProject) {
-		super(parentShell);
-
-		this.infoElement = infoElement;
-		this.jProject = jProject;
-		this.tableElements = new ArrayList();
-	}
-
-	protected void configureShell(Shell newShell) {
-		super.configureShell(newShell);
-		newShell.setText(
-			MessageFormat.format(
-				BeanInfoUIMessages.SearchPathDialog_ModifySearchPaths, 
-				new Object[] { infoElement.getEntry().getPath().toString()}));
-	}
-
-	protected Control createDialogArea(Composite parent) {
-		top = new Composite(parent, SWT.NONE);
-		top.setLayoutData(new GridData(GridData.FILL_BOTH));
-		top.setLayout(new GridLayout(2, false));
-		
-		label = new Label(top, SWT.NONE);
-		label.setText(BeanInfoUIMessages.SearchPathDialog_Desc_Label);
-		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
-		gd.horizontalSpan = 2;
-		label.setLayoutData(gd);
-		
-		createTable();
-		createButtonsBar();
-
-		updatePackagesList();
-		
-		updateButtons();
-
-		return top;
-	}
-
-	/**
-	 * This method initializes table	
-	 *
-	 */
-	private void createTable() {
-		GridData gridData1 = new org.eclipse.swt.layout.GridData();
-		gridData1.horizontalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData1.grabExcessHorizontalSpace = true;
-		gridData1.grabExcessVerticalSpace = true;
-		gridData1.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		table = new Table(top, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
-		table.setLayoutData(gridData1);
-		table.addSelectionListener(new SelectionListener(){
-			public void widgetSelected(SelectionEvent e) {
-				updateButtons();
-			}
-			public void widgetDefaultSelected(SelectionEvent e) {
-				widgetSelected(e);
-			}
-		});
-		tableViewer = new TableViewer(table);
-		//tableViewer.setSorter(new BIListElementSorter());
-		tableViewer.setContentProvider(new ArrayContentProvider());
-		tableViewer.setLabelProvider(new SearchPathListLabelProvider(jProject));
-		tableViewer.setInput(tableElements);
-	}
-
-	/**
-	 * This method initializes buttonsBar	
-	 *
-	 */
-	private void createButtonsBar() {
-		RowLayout rowLayout = new RowLayout();
-		rowLayout.type = org.eclipse.swt.SWT.VERTICAL;
-		rowLayout.marginLeft = 3;
-		rowLayout.fill = true;
-		GridData gridData2 = new org.eclipse.swt.layout.GridData();
-		gridData2.grabExcessVerticalSpace = true;
-		gridData2.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData2.horizontalAlignment = org.eclipse.swt.layout.GridData.BEGINNING;
-		buttonsBar = new Composite(top, SWT.NONE);
-		buttonsBar.setLayoutData(gridData2);
-		buttonsBar.setLayout(rowLayout);
-		upbutton = new Button(buttonsBar, SWT.NONE);
-		upbutton.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__searchpath_up_button);
-		upbutton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-				Iterator selItr = selected.iterator();
-				while (selItr.hasNext()) {
-					Object element = selItr.next();
-					int oldIndex = tableElements.indexOf(element);
-					if(oldIndex>0){
-						tableElements.remove(element);
-						tableElements.add(--oldIndex, element);
-					}
-				}
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-		downButton = new Button(buttonsBar, SWT.NONE);
-		downButton.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__searchpath_down_button);
-		downButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-				Iterator selItr = selected.iterator();
-				while (selItr.hasNext()) {
-					Object element = selItr.next();
-					int oldIndex = tableElements.indexOf(element);
-					if(oldIndex<(tableElements.size()-1)){
-						tableElements.remove(element);
-						tableElements.add(++oldIndex, element);
-					}
-				}
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-		new Label(buttonsBar, SWT.NONE);
-		choosePackagesButton = new Button(buttonsBar, SWT.NONE);
-		choosePackagesButton.setText(BeanInfoUIMessages.SearchPathDialog_ChoosePackages);
-		choosePackagesButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				final List elementsToAdd = choosePackages();
-				if (elementsToAdd != null && !elementsToAdd.isEmpty()) {
-					tableElements.addAll(elementsToAdd);
-					tableViewer.refresh();
-					table.getDisplay().asyncExec(new Runnable(){
-						public void run() {
-							tableViewer.setSelection(new StructuredSelection(elementsToAdd));
-						};
-					});
-				}
-			}
-		});
-		new Label(buttonsBar, SWT.NONE);
-		removeButton = new Button(buttonsBar, SWT.NONE);
-		removeButton.setText(BeanInfoUIMessages.SearchPathDialog_Remove);
-		removeButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-				tableElements.removeAll(selected);
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-	}
-
-	
-	protected void pageChanged() {
-		// TODO Auto-generated method stub
-		
-	}
-
-	protected void updateButtons() {
-		if(top!=null && !top.isDisposed()){
-			upbutton.setEnabled(enabled && canMoveUp());
-			downButton.setEnabled(enabled && canMoveDown());
-			removeButton.setEnabled(enabled && !tableViewer.getSelection().isEmpty());
-			choosePackagesButton.setEnabled(enabled);
-		}
-	}
-	
-	private boolean canMoveDown() {
-		int[] indc= table.getSelectionIndices();
-		int k= tableElements.size() - 1;
-		for (int i= indc.length - 1; i >= 0 ; i--, k--) {
-			if (indc[i] != k) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private boolean canMoveUp() {
-		int[] indc= table.getSelectionIndices();
-		for (int i= 0; i < indc.length; i++) {
-			if (indc[i] != i) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private void updatePackagesList() {
-		if (infoElement.getEntry().getKind() == BeaninfoEntry.BIE_PLUGIN) {
-			// We don't allow these to be updated. They should only be used through
-			// registered mechanisms and we won't be showing them here normally.
-			label.setText(BeanInfoUIMessages.SearchPathDialog_NotEditable_INFO_); 
-			updateEnabledState(false);
-			return;
-		}
-		tableElements.clear();
-		tableElements.addAll(Arrays.asList(infoElement.getSearchpaths()));
-		tableViewer.refresh();
-	}
-
-	private void updateEnabledState(boolean b) {
-		enabled = b;
-		if(top!=null && !top.isDisposed()){
-			label.setEnabled(enabled);
-			table.setEnabled(enabled);
-			updateButtons();
-		}
-	}
-
-	protected void okPressed() {
-		if (table.isEnabled()) {
-			// If the field is not enabled, then there is no update to perform. We don't
-			// want to accidentially wipe out the search paths in this case.
-
-			// Override to put the list of elements back into the BPBeaninfoListElement
-			// Until then they aren't actually updated.
-			infoElement.setSearchpaths(
-				(BPSearchListElement[]) tableElements.toArray(new BPSearchListElement[tableElements.size()]));
-		}
-		super.okPressed();
-	}
-
-	/**
-	 * Choose the packages that should be in the search path.
-	 */
-	private List choosePackages() {
-
-		IPackageFragmentRoot[] roots = getBeaninfoRoots();
-		List newPackageNames = new ArrayList();
-		if (roots != null) {
-			// It's within the workspace, so we can get the roots and packages.
-			ISelectionStatusValidator validator = new PackagesWorkbookPage.ChoosePackagesSelectionValidator();
-
-			// Show up to the package fragment, don't show any contents of it.
-			Class[] acceptedClasses = new Class[] { IPackageFragmentRoot.class, IPackageFragment.class };
-			Object[] rejectedFragments = getFilteredExistingEntries(roots);
-
-			// Only show package fragments that have children (i.e. there classes in it, not interested
-			// in intermediate ones that have no classes defined in them. Those are filtered out.
-			TypedViewerFilter filter = new TypedViewerFilter(acceptedClasses, rejectedFragments) {
-				public boolean select(Viewer viewer, Object parentElement, Object element) {
-					if (super.select(viewer, parentElement, element)) {
-						if (element instanceof IPackageFragment) {
-							IPackageFragment pkg = (IPackageFragment) element;
-							try {
-								return pkg.hasChildren();
-							} catch (JavaModelException e) {
-							}
-							return false;
-						} else
-							return true;
-					}
-					return false;
-				}
-			};
-
-			ITreeContentProvider provider = new PackageOnlyContentProvider();
-
-			ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
-			ElementTreeSelectionDialog dialog =
-				new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
-			dialog.setTitle(BeanInfoUIMessages.BeaninfoPathsBlock_UI__addsearchpath_title); 
-
-			dialog.setValidator(validator);
-			dialog.setMessage(BeanInfoUIMessages.BeaninfoPathsBlock_UI__addsearchpath_description); 
-			dialog.addFilter(filter);
-			dialog.setInput(Arrays.asList(getBeaninfoRoots()));
-
-			if (dialog.open() == Window.OK) {
-				Object[] elements = dialog.getResult();
-				for (int i = 0; i < elements.length; i++) {
-					newPackageNames.add(((IPackageFragment) elements[i]).getElementName());
-				}
-			}
-		} else {
-			// It's not within the workspace
-			final List existingPackagenames = getFilteredExistingEntries();
-			IInputValidator validator = new IInputValidator() {
-				public String isValid(String newText) {
-					if (existingPackagenames.contains(newText))
-						return BeanInfoUIMessages.SearchPathDialog_PackagePresent_INFO_; 
-						
-					IStatus status = JavaConventions.validatePackageName(newText);
-					return status.getSeverity() == IStatus.OK ? null : status.getMessage();
-				}
-			};
-			InputDialog dialog = new InputDialog(getShell(), BeanInfoUIMessages.SearchPathDialog_InputDialog_Title, BeanInfoUIMessages.SearchPathDialog_InputDialog_Message, null, validator); 
-			if (dialog.open() == Window.OK)
-				newPackageNames.add(dialog.getValue());
-		}
-
-		if (newPackageNames.size() == 0)
-			return Collections.EMPTY_LIST;
-
-		List newElements = new ArrayList(newPackageNames.size());
-		for (int i = 0; i < newPackageNames.size(); i++)
-			newElements.add(
-				new BPSearchListElement(new SearchpathEntry((String) newPackageNames.get(i)), false, false, false));
-		return newElements;
-	}
-	/**
-	 * Return the packagefragment roots for the given beaninfo entry.
-	 * Return null if it can be handled (i.e. not in a project some where).
-	 */
-	protected IPackageFragmentRoot[] getBeaninfoRoots() {
-		IPackageFragmentRoot[] roots = null;
-		if (infoElement.getEntry().getKind() != BeaninfoEntry.BIE_PLUGIN) {
-			IClasspathEntry resolved = JavaCore.getResolvedClasspathEntry(((BeaninfoEntry) infoElement.getEntry()).getClasspathEntry());
-			IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(resolved.getPath());
-			if (res != null && res.exists()) {
-				if (res instanceof IProject) {
-					// It is a project itself.
-					IJavaProject jp = (IJavaProject) JavaCore.create(res);
-					try {
-						if (jp != null)
-							roots = jp.getPackageFragmentRoots(); // All of the roots in the project are applicable.
-					} catch (JavaModelException e) {
-					}
-				} else {
-					// It is within another project
-					IProject containingProject = res.getProject();
-					IJavaProject jp = JavaCore.create(containingProject);
-					if (jp != null) {
-						// The roots if this is in the classpath of this project
-						try {
-							IPackageFragmentRoot root = jp.findPackageFragmentRoot(resolved.getPath());
-							if (root != null)
-								roots = new IPackageFragmentRoot[] { root };
-						} catch (JavaModelException e) {
-						}
-					}
-				}
-			}
-		}
-		return roots;
-	}
-
-	/**
-	 * Return the list of entries that already are in the search path
-	 * so that they don't show up in the list.
-	 */
-	protected Object[] getFilteredExistingEntries(IPackageFragmentRoot[] roots) {
-		List entries = tableElements;
-		List fragments = new ArrayList(entries.size());
-		Iterator itr = entries.iterator();
-		while (itr.hasNext()) {
-			BPSearchListElement elem = (BPSearchListElement) itr.next();
-			fragments.addAll(getPackages(elem, roots));
-		}
-		return fragments.toArray();
-	}
-	
-	/**
-	 * Return the list of entries that already are in the search path
-	 * so that they don't show up in the list. This one is just the package names.
-	 */
-	protected List getFilteredExistingEntries() {
-		List entries = tableElements;
-		List names = new ArrayList(entries.size());
-		Iterator itr = entries.iterator();
-		while (itr.hasNext()) {
-			BPSearchListElement elem = (BPSearchListElement) itr.next();
-			names.add(((SearchpathEntry) elem.getEntry()).getPackage());
-		}
-		return names;
-	}
-
-	protected List getPackages(BPSearchListElement element, IPackageFragmentRoot[] roots) {
-		String packageName = ((SearchpathEntry) element.getEntry()).getPackage();
-		if (packageName == null)
-			return Collections.EMPTY_LIST;
-
-		try {
-			List packages = new ArrayList(10);
-			for (int i = 0; i < roots.length; i++) {
-				IJavaElement[] pfs = roots[i].getChildren();
-				for (int j = 0; j < pfs.length; j++)
-					if (pfs[j].getElementType() == IJavaElement.PACKAGE_FRAGMENT
-						&& pfs[j].getElementName().equals(packageName)) {
-						packages.add(pfs[j]);
-						break;
-					}
-			}
-			return packages;
-		} catch (JavaModelException e) {
-		}
-		return Collections.EMPTY_LIST;
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfoPathsBlock.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfoPathsBlock.java
deleted file mode 100644
index 1179a51..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfoPathsBlock.java
+++ /dev/null
@@ -1,550 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeaninfoPathsBlock.java,v $
- *  $Revision: 1.16 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.net.URL;
-import java.util.*;
-import java.util.List;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.ui.ISharedImages;
-import org.eclipse.jdt.ui.JavaUI;
-import org.eclipse.jface.operation.IRunnableWithProgress;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.IStructuredSelection;
-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.*;
-
-import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature;
-import org.eclipse.jem.internal.beaninfo.core.*;
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
-
-public class BeaninfoPathsBlock {
-
-	//private Shell sShell1 = null;  //  @jve:decl-index=0:visual-constraint="40,19"
-	private Composite top = null;
-	private TabFolder tabFolder = null;
-	private Button enableBeaninfoCheckbox = null;
-	private PackagesWorkbookPage packagesWorkbookPage2 = null;
-	private SearchpathOrderingWorkbookPage searchpathOrderingWorkbookPage2 = null;
-	private BeaninfosWorkbookPage beaninfosPropertyPage2 = null;
-	private Control packagesPageControl = null;
-	private Control searchpathPageControl = null;
-	private Control beaninfosPageControl = null;
-	private Image packagesTabImage;
-	private Image beaninfosTabImage;
-	private Image searchPathTabImage;
-	// ...ui
-	
-	private IWorkspaceRoot workspaceRoot;
-	private IStatusChangeListener statusChangeListener;
-	private IBuildSearchPage currentPage;
-	private IJavaProject javaProject;
-	private boolean enableBeaninfo = true;
-	
-	public BeaninfoPathsBlock(IWorkspaceRoot workspaceRoot, IStatusChangeListener statusChangeListener){
-		this.workspaceRoot = workspaceRoot;
-		this.statusChangeListener = statusChangeListener;
-	}
-	
-	private void setEnableBeaninfo(boolean enable){
-		enableBeaninfo = enable;
-		if(enableBeaninfoCheckbox!=null && !enableBeaninfoCheckbox.isDisposed())
-			enableBeaninfoCheckbox.setSelection(enable);
-	}
-	
-//	/**
-//	 * This method initializes sShell1	
-//	 *
-//	 */
-//	private void createSShell1() {
-//		sShell1 = new Shell();
-//		sShell1.setLayout(new FillLayout());
-//		createTop();
-//		sShell1.setSize(new org.eclipse.swt.graphics.Point(403,289));
-//	}
-
-	/**
-	 * This method initializes top	
-	 *
-	 */
-	public Control createControl(Composite parent) {
-		top = new Composite(parent, SWT.NONE);
-		top.setLayout(new GridLayout());
-		createTabFolder();
-		enableBeaninfoCheckbox = new Button(top, SWT.CHECK);
-		enableBeaninfoCheckbox.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__enablebeaninfo);
-		enableBeaninfoCheckbox.addSelectionListener(new org.eclipse.swt.events.SelectionListener() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				enableBeaninfo = enableBeaninfoCheckbox.getSelection();
-				packagesWorkbookPage2.setBeaninfoEnabled(enableBeaninfo);
-				beaninfosPropertyPage2.setBeaninfoEnabled(enableBeaninfo);
-				searchpathOrderingWorkbookPage2.setBeaninfoEnabled(enableBeaninfo);
-			}
-			public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
-				widgetSelected(e);
-			}
-		});
-		enableBeaninfoCheckbox.setSelection(enableBeaninfo);
-		if(javaProject!=null){
-			getPackagesPage().init(javaProject);
-			getBeaninfosPage().init(javaProject);
-			getSearchpathOrderingPage().init(javaProject);
-		}
-		return top;
-	}
-
-	/**
-	 * This method initializes tabFolder	
-	 *
-	 */
-	private void createTabFolder() {
-		GridData gridData = new org.eclipse.swt.layout.GridData();
-		gridData.horizontalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData.grabExcessHorizontalSpace = true;
-		gridData.grabExcessVerticalSpace = true;
-		gridData.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		tabFolder = new TabFolder(top, SWT.NONE);
-		tabFolder.setLayoutData(gridData);
-		createPackagesWorkbookPage2();
-		createBeaninfosPropertyPage2();
-		createSearchpathOrderingWorkbookPage2();
-		tabFolder.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				tabChanged(e.item);
-			}
-		});
-				
-		TabItem tabItem = new TabItem(tabFolder, SWT.NONE);
-		tabItem.setText(BeanInfoUIMessages.BeanInfoPathsBlock_Page_Tab_Packages);
-		tabItem.setImage(getPackagesTabImage());
-		tabItem.setControl(packagesPageControl);
-		TabItem tabItem1 = new TabItem(tabFolder, SWT.NONE);
-		tabItem1.setText(BeanInfoUIMessages.BeanInfoPathsBlock_Page_Tab_Classes);
-		tabItem1.setImage(getBeaninfosTabImage());
-		tabItem1.setControl(beaninfosPageControl);
-		TabItem tabItem2 = new TabItem(tabFolder, SWT.NONE);
-		tabItem2.setImage(getSearchPathTabImage());
-		tabItem2.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__serachpath_tab_order);
-		tabItem2.setControl(searchpathPageControl);
-		tabFolder.setSelection(2);
-	}
-
-	private Image getSearchPathTabImage() {
-		if(searchPathTabImage==null)
-			searchPathTabImage = JEMUIPlugin.imageDescriptorFromPlugin(JEMUIPlugin.getPlugin().getBundle().getSymbolicName(), "icons/cp_order_obj.gif").createImage();
-		return searchPathTabImage;
-	}
-
-	private Image getPackagesTabImage() {
-		if(packagesTabImage==null)
-			packagesTabImage = JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_PACKAGE);
-		return packagesTabImage;
-	}
-	
-	private Image getBeaninfosTabImage(){
-		if(beaninfosTabImage==null){
-			URL imageURL = Platform.find(JEMUIPlugin.getPlugin().getBundle(), new Path("icons/javabean.gif")); //$NON-NLS-1$
-			if (imageURL != null) 
-				beaninfosTabImage = ImageDescriptor.createFromURL(imageURL).createImage();
-			else
-				beaninfosTabImage = ImageDescriptor.getMissingImageDescriptor().createImage();
-		}
-		return beaninfosTabImage;
-	}
-
-	/**
-	 * This method initializes packagesWorkbookPage2	
-	 *
-	 */
-	private void createPackagesWorkbookPage2() {
-		packagesPageControl = getPackagesPage().createControl(tabFolder);
-	}
-
-	/**
-	 * This method initializes searchpathOrderingWorkbookPage2	
-	 *
-	 */
-	private void createSearchpathOrderingWorkbookPage2() {
-		searchpathPageControl = getSearchpathOrderingPage().createControl(tabFolder);
-		searchpathPageControl.addDisposeListener(new org.eclipse.swt.events.DisposeListener() {
-			public void widgetDisposed(org.eclipse.swt.events.DisposeEvent e) {
-				if(searchPathTabImage!=null){
-					if(!searchPathTabImage.isDisposed())
-						searchPathTabImage.dispose();
-					searchPathTabImage=null;
-				}
-			}
-		});
-	}
-
-	/**
-	 * This method initializes beaninfosPropertyPage2	
-	 *
-	 */
-	private void createBeaninfosPropertyPage2() {
-		beaninfosPageControl = getBeaninfosPage().createControl(tabFolder);
-		beaninfosPageControl.addDisposeListener(new org.eclipse.swt.events.DisposeListener() {
-			public void widgetDisposed(org.eclipse.swt.events.DisposeEvent e) {
-				if(beaninfosTabImage!=null){
-					if(!beaninfosTabImage.isDisposed())
-						beaninfosTabImage.dispose();
-					beaninfosTabImage=null;
-				}
-			}
-		});
-	}
-
-	PackagesWorkbookPage getPackagesPage(){
-		if(packagesWorkbookPage2==null)
-			packagesWorkbookPage2 = new PackagesWorkbookPage(workspaceRoot, this);
-		return packagesWorkbookPage2;
-	}
-	
-	BeaninfosWorkbookPage getBeaninfosPage(){
-		if(beaninfosPropertyPage2==null)
-			beaninfosPropertyPage2 = new BeaninfosWorkbookPage(workspaceRoot, this);
-		return beaninfosPropertyPage2;
-	}
-	
-	SearchpathOrderingWorkbookPage getSearchpathOrderingPage(){
-		if(searchpathOrderingWorkbookPage2==null)
-			searchpathOrderingWorkbookPage2 = new SearchpathOrderingWorkbookPage(this);
-		return searchpathOrderingWorkbookPage2;
-	}
-	
-	private void tabChanged(Widget widget) {
-		if (widget instanceof TabItem) {
-			IBuildSearchPage newPage = (IBuildSearchPage) ((TabItem) widget).getData();
-			if (currentPage != null) {
-				List selection = currentPage.getSelection();
-				if (!selection.isEmpty()) {
-					newPage.setSelection(selection);
-				}
-			}
-			currentPage = newPage;
-		}
-	}	
-	
-	/**
-	 * Creates a runnable that sets the configured build paths.
-	 */
-	public IRunnableWithProgress getRunnable() {
-		final boolean wantNature = enableBeaninfo;
-		final List searchPathEntries = wantNature ? getSearchpathOrderingPage().getElements() : null;
-
-		return new IRunnableWithProgress() {
-			public void run(IProgressMonitor monitor) throws InvocationTargetException {
-				if (monitor == null) {
-					monitor = new NullProgressMonitor();
-				}
-				monitor.beginTask(
-					BeanInfoUIMessages.BeaninfoPathsBlock_UI__searchpath_operationdescription, 
-					10);
-				try {
-					setBeaninfoSearchpath(wantNature, searchPathEntries, monitor);
-				} catch (CoreException e) {
-					throw new InvocationTargetException(e);
-				} finally {
-					monitor.done();
-				}
-			}
-		};
-	}
-
-	private void setBeaninfoSearchpath(
-			boolean wantNature,
-			List searchPathEntries,
-			IProgressMonitor monitor)
-			throws CoreException {
-
-		if (wantNature) {
-			// create beaninfo nature
-			if (!javaProject.getProject().hasNature(BeaninfoNature.NATURE_ID)) {
-				addNatureIDToProject(javaProject.getProject(), BeaninfoNature.NATURE_ID, monitor);
-			}
-
-			BeaninfoNature nature = BeaninfoNature.getRuntime(javaProject.getProject());
-			// Now build/set the search path.
-			if (searchPathEntries.size() > 0) {
-				IBeaninfosDocEntry[] sparray = new IBeaninfosDocEntry[searchPathEntries.size()];
-				Iterator itr = searchPathEntries.iterator();
-				int i = 0;
-				while (itr.hasNext()) {
-					BPListElement elem = (BPListElement) itr.next();
-					sparray[i++] = elem.getEntry();
-				}
-				nature.setSearchPath(new BeaninfosDoc(sparray), monitor);
-			} else
-				nature.setSearchPath(null, monitor);
-		} else {
-			// Remove the nature, no longer wanted.
-			removeNatureIDFromProject(javaProject.getProject(), BeaninfoNature.NATURE_ID, monitor);
-		}
-	}
-
-	/**
-	 * Initializes the classpath for the given project. Multiple calls to init are allowed,
-	 * but all existing settings will be cleared and replace by the given or default paths.
-	 * @param project The java project to configure.
-	 */
-	public void init(IJavaProject jproject) {
-		this.javaProject = jproject;
-		//TODO: labelProvider.setJavaProject(jproject);
-
-		try {
-			// If we have a config file, we will assume we have a nature. It will add it automatically
-			// when we ask for the information. Even if we didn't have the nature, as soon as someone
-			// asks for it, we would create it anyhow, and it would use the existing config file.
-			// If we don't have a config file, we could have the nature, so we will check for that too.
-			boolean haveConfigFile = jproject.getProject().getFile(BeaninfoNature.P_BEANINFO_SEARCH_PATH).exists();
-			boolean haveNature = javaProject.getProject().hasNature(BeaninfoNature.NATURE_ID);
-			enableBeaninfo = haveConfigFile || haveNature;
-			if (haveNature || haveConfigFile) {
-				BeaninfosDoc doc = BeaninfoNature.getRuntime(javaProject.getProject()).getSearchPath();
-				IClasspathEntry[] raw = javaProject.getRawClasspath();
-
-				List newSearchpath = new ArrayList();
-				if (doc != null) {
-					IBeaninfosDocEntry[] sp = doc.getSearchpath();
-					for (int i = 0; i < sp.length; i++) {
-						IBeaninfosDocEntry curr = sp[i];
-						boolean isMissing = false;
-						BPListElement elem = null;
-						if (curr instanceof BeaninfoEntry) {
-							BeaninfoEntry be = (BeaninfoEntry) curr;
-
-							// get the resource, this tells if the beaninfos exist or not.
-							Object[] paths = be.getClasspath(javaProject);
-							if (paths != null && paths.length > 0) {
-								for (int j = 0; !isMissing && j < paths.length; j++) {
-									Object path = paths[j];
-									if (path instanceof IProject)
-										isMissing = !((IProject) path).exists();
-									else if (path instanceof String) {
-										File f = new File((String) path);
-										isMissing = !f.exists();
-									} else if (path instanceof IPath) {
-										isMissing = true;	// Plugins are invalid in BeaninfoConfig. They only apply within contributions.
-									} else
-										isMissing = true; // Invalid, so isMissing.
-								}								
-							} else
-								isMissing = true;
-
-							elem = new BPBeaninfoListElement(be, getInitialSearchpaths(be), isMissing);
-						} else {
-							// Searchpath entry, see if we can find the raw classpath entry that it is for.
-							boolean isExported = false;
-							boolean isPackageMissing = true;
-							isMissing = true;	// Initially missing until we find it.
-							SearchpathEntry ce = (SearchpathEntry) curr;
-							int kind = ce.getKind();
-							IPath path = ce.getPath();
-							for (int j = 0; j < raw.length; j++) {
-								if (raw[j].getEntryKind() == kind && raw[j].getPath().equals(path)) {
-									isMissing = false;
-									isExported = raw[j].isExported() || raw[j].getEntryKind() == IClasspathEntry.CPE_SOURCE;
-									String packageName = ce.getPackage();
-									if (packageName != null) {
-										IPackageFragmentRoot[] roots = javaProject.findPackageFragmentRoots(raw[j]);
-										for (int k = 0; k < roots.length; k++) {
-											IPackageFragmentRoot iroot = roots[k];
-											if (iroot.getPackageFragment(packageName).exists()) {
-												isPackageMissing = false;
-												break;
-											}
-										}
-									} else
-										isPackageMissing = false;
-									break;
-								}
-							}
-							elem = new BPSearchListElement(ce, isMissing, isPackageMissing, isExported);
-						}
-
-						newSearchpath.add(elem);
-					}
-				}
-
-				// inits the dialog field
-				setSearchOrderElements(newSearchpath);
-
-				if (getPackagesPage() != null) {
-					getPackagesPage().init(javaProject);
-					getBeaninfosPage().init(javaProject);
-					getSearchpathOrderingPage().init(javaProject);
-				}
-			} else {
-				// No nature, disable,
-				setEnableBeaninfo(false);
-			}
-		} catch (JavaModelException e) {
-			setEnableBeaninfo(false);
-		} catch (CoreException e) {
-			setEnableBeaninfo(false);
-		}
-
-//		listenForClasspathChange();
-		doStatusLineUpdate();
-	}
-
-	/**
-	 * Adds a nature to a project
-	 */
-	private void addNatureIDToProject(IProject proj, String natureId, IProgressMonitor monitor)
-		throws CoreException {
-		IProjectDescription description = proj.getDescription();
-		String[] prevNatures = description.getNatureIds();
-		String[] newNatures = new String[prevNatures.length + 1];
-		System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
-		newNatures[prevNatures.length] = natureId;
-		description.setNatureIds(newNatures);
-		proj.setDescription(description, monitor);
-	}
-
-	private void removeNatureIDFromProject(IProject proj, String natureId, IProgressMonitor monitor)
-		throws CoreException {
-		IProjectDescription description = proj.getDescription();
-		String[] prevNatures = description.getNatureIds();
-		int indx = -1;
-		for (int i = 0; i < prevNatures.length; i++) {
-			if (prevNatures[i].equals(natureId)) {
-				indx = i;
-				break;
-			}
-		}
-		if (indx == -1)
-			return;
-
-		String[] newNatures = new String[prevNatures.length - 1];
-		if (newNatures.length != 0) {
-			System.arraycopy(prevNatures, 0, newNatures, 0, indx);
-			if (indx < newNatures.length)
-				System.arraycopy(prevNatures, indx + 1, newNatures, indx, newNatures.length - indx);
-		}
-		description.setNatureIds(newNatures);
-		proj.setDescription(description, monitor);
-	}
-	
-	void doStatusLineUpdate() {
-		statusChangeListener.statusChanged(getSearchpathOrderingPage().getStatus());
-	}
-	
-	/*
-	 * searchOrder dialog must never have all of elements set
-	 * directly. Must come through here first so that we can
-	 * make sure updates occur in correct sequence, else
-	 * we will wind up with entries being marked as unexported
-	 * when they really are exported. 
-	 */
-	public void setSearchOrderElements(List newElements) {
-		ArrayList exportedEntries = new ArrayList(newElements.size());
-		for (Iterator iter = newElements.iterator(); iter.hasNext();) {
-			BPListElement element = (BPListElement) iter.next();
-			if (element.isExported())
-				exportedEntries.add(element);
-		}
-		
-		getSearchpathOrderingPage().setElements(newElements);
-		getSearchpathOrderingPage().setCheckedElements(exportedEntries);
-	}
-	
-	/*
-	 * Create the Searchpath elements for a BeaninfoElement.
-	 * Return null if not to update.
-	 */
-	private BPSearchListElement[] getInitialSearchpaths(BeaninfoEntry infoEntry) {
-
-		// We can only verify the existence of packages within beaninfos that are 
-		// located within a project on the desktop. Otherwise we can't find out what
-		// packages are in them.
-		IPackageFragmentRoot[] roots = null;
-
-		if (infoEntry.getKind() != BeaninfoEntry.BIE_PLUGIN) {
-			IClasspathEntry resolved = JavaCore.getResolvedClasspathEntry(infoEntry.getClasspathEntry());
-			IResource res = workspaceRoot.findMember(resolved.getPath());
-			if (res != null && res.exists()) {
-				if (res instanceof IProject) {
-					// It is a project itself.
-					IJavaProject jp = (IJavaProject) JavaCore.create(res);
-					try {
-						if (jp != null)
-							roots = jp.getPackageFragmentRoots(); // All of the roots in the project are applicable.
-					} catch (JavaModelException e) {
-					}
-				} else {
-					// It is within another project
-					IProject containingProject = res.getProject();
-					IJavaProject jp = JavaCore.create(containingProject);
-					if (jp != null) {
-						// The roots if this is in the classpath of this project
-						try {
-							IPackageFragmentRoot root = jp.findPackageFragmentRoot(resolved.getPath());
-							if (root != null)
-								roots = new IPackageFragmentRoot[] { root };
-						} catch (JavaModelException e) {
-						}
-					}
-				}
-			}
-		}
-
-		SearchpathEntry[] entries = infoEntry.getSearchPaths();
-		BPSearchListElement[] packageElements = new BPSearchListElement[entries.length];
-		for (int i = 0;
-			i < entries.length;
-			i++) { // Searchpath entry, see if we can find the raw classpath entry that it is for.
-			boolean isPackageMissing = roots != null;
-			// If roots is null, then the package isn't missing because we can't test for it.
-			SearchpathEntry ce = entries[i];
-			if (roots != null) {
-				String packageName = ce.getPackage();
-				for (int k = 0; k < roots.length; k++) {
-					IPackageFragmentRoot iroot = roots[k];
-					if (iroot.getPackageFragment(packageName).exists()) {
-						isPackageMissing = false;
-						break;
-					}
-				}
-			}
-			packageElements[i] = new BPSearchListElement(ce, false, isPackageMissing, false);
-		}
-
-		return packageElements;
-	}
-	
-	
-	public static List getSelectedList(ISelection selection){
-		List selectedList = null;
-		if(selection!=null && !selection.isEmpty() && selection instanceof IStructuredSelection){
-			IStructuredSelection structuredSelection = (IStructuredSelection) selection;
-			selectedList = new ArrayList(Arrays.asList(structuredSelection.toArray()));
-		}
-		return selectedList;
-	}
-	
-	public boolean isBeaninfoEnabled(){
-		return enableBeaninfo;
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfosPropertyPage.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfosPropertyPage.java
deleted file mode 100644
index c9ede9f..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfosPropertyPage.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: BeaninfosPropertyPage.java,v $
- *  $Revision: 1.10 $  $Date: 2005/09/26 20:26:59 $ 
- */
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jface.dialogs.DialogPage;
-import org.eclipse.jface.dialogs.IMessageProvider;
-import org.eclipse.jface.operation.IRunnableWithProgress;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.*;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
-import org.eclipse.ui.dialogs.PropertyPage;
-
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
-
-/**
- * Property page for configuring Beaninfo path
- */
-public class BeaninfosPropertyPage extends PropertyPage implements IStatusChangeListener {
-		
-	/**
-	 * Applies the status to the status line of a dialog page.
-	 *
-	 * @param page the dialog page
-	 * @param status the status
-	 */
-	public static void applyToStatusLine(DialogPage page, IStatus status) {
-		String message= status.getMessage();
-		switch (status.getSeverity()) {
-			case IStatus.OK:
-				page.setMessage(message, IMessageProvider.NONE);
-				page.setErrorMessage(null);
-				break;
-			case IStatus.WARNING:
-				page.setMessage(message, IMessageProvider.WARNING);
-				page.setErrorMessage(null);
-				break;
-			case IStatus.INFO:
-				page.setMessage(message, IMessageProvider.INFORMATION);
-				page.setErrorMessage(null);
-				break;
-			default:
-				if (message.length() == 0) {
-					message= null;
-				}
-				page.setMessage(null);
-				page.setErrorMessage(message);
-				break;
-		}
-	}
-
-	private BeaninfoPathsBlock fBuildPathsBlock;
-	private IResourceChangeListener listener;
-	private IProject project;
-	
-	/*
-	 * @see PreferencePage#createControl(Composite)
-	 */
-	protected Control createContents(Composite parent) {
-// when we get help working.
-//		WorkbenchHelp.setHelp(parent, new DialogPageContextComputer(this, IJavaHelpContextIds.BUILD_PATH_PROPERTY_PAGE));
-
-		// ensure the page has no special buttons
-		noDefaultAndApplyButton();		
-		
-		project= getProject();
-		if (project == null || !isJavaProject(project)) {
-			return createWithoutJava(parent);
-		} else if (!project.isOpen()) {
-			return createForClosedProject(parent);
-		} else {
-			return createWithJava(parent);
-		}
-	}
-	
-	/**
-	 * Content for valid projects.
-	 */
-	private Control createWithJava(Composite parent) {
-		IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
-		fBuildPathsBlock= new BeaninfoPathsBlock(root, this);
-		final IJavaProject jproject = JavaCore.create(project);
-		fBuildPathsBlock.init(jproject);
-		final IPath classpathfile = project.getFile(".classpath").getFullPath(); //$NON-NLS-1$
-		listener = new IResourceChangeListener() {
-			
-			/* (non-Javadoc)
-			 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
-			 */
-			public void resourceChanged(IResourceChangeEvent event) {
-				if (fBuildPathsBlock != null) {
-					if (event.getDelta().findMember(classpathfile) != null)
-						getControl().getDisplay().asyncExec(new Runnable() {	// Can be called outside of display loop
-							public void run() {
-								fBuildPathsBlock.init(jproject);
-							}
-						});
-				}
-			}
-		};
-		project.getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.POST_CHANGE);
-
-		return fBuildPathsBlock.createControl(parent);
-	}
-
-	/**
-	 * Content for non-Java projects.
-	 */	
-	private Control createWithoutJava(Composite parent) {
-		Label label= new Label(parent, SWT.LEFT);
-		label.setText(BeanInfoUIMessages.BeaninfoPropertiesPage_INFO__nojavaproject); 
-		
-		fBuildPathsBlock= null;
-		setValid(true);
-		return label;
-	}
-
-	/**
-	 * Content for closed projects.
-	 */		
-	private Control createForClosedProject(Composite parent) {
-		Label label= new Label(parent, SWT.LEFT);
-		label.setText(BeanInfoUIMessages.BeaninfoPropertiesPage_INFO__closedproject); 
-		
-		fBuildPathsBlock= null;
-		setValid(true);
-		return label;
-	}
-	
-	private IProject getProject() {
-		IAdaptable adaptable= getElement();
-		if (adaptable != null) {
-			IJavaElement elem= (IJavaElement) adaptable.getAdapter(IJavaElement.class);
-			if (elem instanceof IJavaProject) {
-				return ((IJavaProject) elem).getProject();
-			}
-		}
-		return null;
-	}
-	
-	private boolean isJavaProject(IProject proj) {
-		try {
-			return proj.hasNature(JavaCore.NATURE_ID);
-		} catch (CoreException e) {
-			JEMUIPlugin.getPlugin().getLogger().log(e.getStatus());
-		}
-		return false;
-	}	
-	
-	/*
-	 * @see IPreferencePage#performOk
-	 */
-	public boolean performOk() {
-		if (fBuildPathsBlock != null) {
-			IRunnableWithProgress runnable= fBuildPathsBlock.getRunnable();
-
-			IRunnableWithProgress op= new WorkspaceModifyDelegatingOperation(runnable);
-			Shell shell= getControl().getShell();
-			try {
-				PlatformUI.getWorkbench().getProgressService().run(false, false, op);
-			} catch (InvocationTargetException e) {
-				String title= BeanInfoUIMessages.Beaninfo_UI__errortitle; 
-				String message= BeanInfoUIMessages.Beaninfo_UI__error; 
-				ExceptionHandler.handle(e, shell, title, message);
-				return false;
-			} catch (InterruptedException e) {
-				// cancelled
-				return false;
-			}
-		}
-		return true;
-	}
-	
-	/**
-	 * @see IStatusChangeListener#statusChanged
-	 */
-	public void statusChanged(IStatus status) {
-		setValid(!status.matches(IStatus.ERROR));
-		applyToStatusLine(this, status);
-	}
-
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jface.dialogs.IDialogPage#dispose()
-	 */
-	public void dispose() {
-		if (listener != null)
-			project.getWorkspace().removeResourceChangeListener(listener);
-		listener = null;
-		super.dispose();
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfosWorkbookPage.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfosWorkbookPage.java
deleted file mode 100644
index 8ca4528..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/BeaninfosWorkbookPage.java
+++ /dev/null
@@ -1,640 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: BeaninfosWorkbookPage.java,v $
- *  $Revision: 1.11 $  $Date: 2005/10/04 17:59:17 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.*;
-import java.util.List;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.ui.JavaElementLabelProvider;
-import org.eclipse.jdt.ui.wizards.BuildPathDialogAccess;
-import org.eclipse.jface.dialogs.IDialogSettings;
-import org.eclipse.jface.dialogs.StatusDialog;
-import org.eclipse.jface.viewers.*;
-import org.eclipse.jface.window.Window;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.layout.*;
-import org.eclipse.swt.widgets.*;
-import org.eclipse.ui.dialogs.*;
-import org.eclipse.ui.model.WorkbenchContentProvider;
-import org.eclipse.ui.model.WorkbenchLabelProvider;
-
-import org.eclipse.jem.internal.beaninfo.core.BeaninfoEntry;
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
-
-public class BeaninfosWorkbookPage implements IBuildSearchPage{
-
-	private static final String DIALOGSTORE_LASTVARIABLE = JEMUIPlugin.PI_BEANINFO_UI + ".lastvar"; //$NON-NLS-1$
-	
-	// a dialog to choose a variable
-	private class VariableSelectionDialog extends StatusDialog implements IStatusChangeListener {	
-		private VariableSelectionBlock fVariableSelectionBlock;
-		IDialogSettings dialogSettings= JEMUIPlugin.getPlugin().getDialogSettings();
-				
-		public VariableSelectionDialog(Shell parent, List existingPaths) {
-			super(parent);
-			setTitle("New Variable Classpath Entry"); //$NON-NLS-1$
-			String initVar= dialogSettings.get(DIALOGSTORE_LASTVARIABLE);
-			fVariableSelectionBlock= new VariableSelectionBlock(this, existingPaths, null, initVar, false);
-		}
-		
-		/*
-		 * @see Windows#configureShell
-		 */
-		protected void configureShell(Shell newShell) {
-			super.configureShell(newShell);
-//			WorkbenchHelp.setHelp(newShell, IJavaHelpContextIds.VARIABLE_SELECTION_DIALOG);
-		}		
-
-		/*
-		 * @see StatusDialog#createDialogArea()
-		 */				
-		protected Control createDialogArea(Composite parent) {
-			Composite composite= (Composite)super.createDialogArea(parent);
-					
-			Label message= new Label(composite, SWT.WRAP);
-			message.setText("New Variable Classpath Entry"); //$NON-NLS-1$
-			message.setLayoutData(new GridData());	
-						
-			Control inner= fVariableSelectionBlock.createControl(composite);
-			inner.setLayoutData(new GridData(GridData.FILL_BOTH));
-			return composite;
-		}
-		
-		/*
-		 * @see Dialog#okPressed()
-		 */
-		protected void okPressed() {
-			dialogSettings.put(DIALOGSTORE_LASTVARIABLE, getVariable().segment(0));
-			super.okPressed();
-		}	
-
-		/*
-		 * @see IStatusChangeListener#statusChanged()
-		 */			
-		public void statusChanged(IStatus status) {
-			updateStatus(status);
-		}
-		
-		public IPath getVariable() {
-			return fVariableSelectionBlock.getVariablePath();
-		}		
-	}
-
-	
-	//controls
-	private Composite javaProjectsComposite = null;
-	private Label label = null;
-	private Table table = null;
-	private Composite buttonsBar = null;
-	private Button addFoldersbutton = null;
-	private Button addJarsButton = null;
-	private Button addExtJarsButton = null;
-	private Button addVariableButton = null;
-	private Button addProjectButton = null;
-	private Button modifyPathsButton = null;
-	private Button removeButton = null;
-	private Label spacer2 = null;
-	private Label spacer1 = null;
-	// .. controls
-	private TableViewer tableViewer;
-	
-	private BeaninfoPathsBlock beaninfoPathsBlock;
-	private IJavaProject javaProject;
-	private List beaninfosList;
-	private IWorkspaceRoot workspaceRoot;
-	private IClasspathEntry[] resolvedList;
-	private IClasspathEntry[] rawList;
-	private SearchPathListLabelProvider labelProvider;
-
-	public BeaninfosWorkbookPage(IWorkspaceRoot workspaceRoot, BeaninfoPathsBlock beaninfoPathsBlock) {
-		this.workspaceRoot = workspaceRoot;
-		this.beaninfoPathsBlock = beaninfoPathsBlock;
-		this.labelProvider = new SearchPathListLabelProvider();
-		this.beaninfosList = new ArrayList();
-		if(spacer1==null || spacer2==null){
-			// just have SOME read access
-		}
-	}
-
-	/**
-	 * This method initializes javaProjectsComposite	
-	 *
-	 */
-	public Control createControl(Composite parent) {
-		GridData gridData = new org.eclipse.swt.layout.GridData();
-		gridData.horizontalSpan = 2;
-		GridLayout gridLayout = new GridLayout();
-		gridLayout.numColumns = 2;
-		javaProjectsComposite = new Composite(parent, SWT.NONE);
-		javaProjectsComposite.setLayout(gridLayout);
-		label = new Label(javaProjectsComposite, SWT.NONE);
-		label.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_List_Text);
-		label.setLayoutData(gridData);
-		createTable();
-		createButtonsBar();
-		updateEnabledStates();
-		return javaProjectsComposite;
-	}
-
-	/**
-	 * This method initializes table	
-	 *
-	 */
-	private void createTable() {
-		GridData gridData1 = new org.eclipse.swt.layout.GridData();
-		gridData1.horizontalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData1.grabExcessHorizontalSpace = true;
-		gridData1.grabExcessVerticalSpace = true;
-		gridData1.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		table = new Table(javaProjectsComposite, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
-		table.setLayoutData(gridData1);
-		table.addSelectionListener(new SelectionListener(){
-			public void widgetSelected(SelectionEvent e) {
-				updateButtons();
-			}
-			public void widgetDefaultSelected(SelectionEvent e) {
-				widgetSelected(e);
-			}
-		});
-		tableViewer = new TableViewer(table);
-		tableViewer.setSorter(new BIListElementSorter());
-		tableViewer.setContentProvider(new ArrayContentProvider());
-		tableViewer.setLabelProvider(labelProvider);
-		tableViewer.setInput(beaninfosList);
-	}
-
-	/**
-	 * This method initializes buttonsBar	
-	 *
-	 */
-	private void createButtonsBar() {
-		RowLayout rowLayout = new RowLayout();
-		rowLayout.type = org.eclipse.swt.SWT.VERTICAL;
-		rowLayout.marginLeft = 3;
-		rowLayout.fill = true;
-		GridData gridData2 = new org.eclipse.swt.layout.GridData();
-		gridData2.grabExcessVerticalSpace = true;
-		gridData2.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData2.horizontalAlignment = org.eclipse.swt.layout.GridData.BEGINNING;
-		buttonsBar = new Composite(javaProjectsComposite, SWT.NONE);
-		buttonsBar.setLayoutData(gridData2);
-		buttonsBar.setLayout(rowLayout);
-		addFoldersbutton = new Button(buttonsBar, SWT.NONE);
-		addFoldersbutton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_AddFolders);
-		addFoldersbutton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List beaninfoEntries = chooseClassContainers();
-				addToBeaninfosList(beaninfoEntries);
-			}
-		});
-		addJarsButton = new Button(buttonsBar, SWT.NONE);
-		addJarsButton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_AddJARs);
-		addJarsButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List beaninfoEntries = chooseJarFiles();
-				addToBeaninfosList(beaninfoEntries);
-			}
-		});
-		addExtJarsButton = new Button(buttonsBar, SWT.NONE);
-		addExtJarsButton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_AddExternalJAR);
-		addExtJarsButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List beaninfoEntries = chooseExtJarFiles();
-				addToBeaninfosList(beaninfoEntries);
-			}
-		});
-		addVariableButton = new Button(buttonsBar, SWT.NONE);
-		addVariableButton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_AddVariable);
-		addVariableButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List beaninfoEntries = chooseVariableEntries();
-				addToBeaninfosList(beaninfoEntries);
-			}
-		});
-		addProjectButton = new Button(buttonsBar, SWT.NONE);
-		addProjectButton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_AddProjects);
-		addProjectButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List beaninfoEntries = chooseProjects();
-				addToBeaninfosList(beaninfoEntries);
-			}
-		});
-		spacer1 = new Label(buttonsBar, SWT.NONE);
-		modifyPathsButton = new Button(buttonsBar, SWT.NONE);
-		modifyPathsButton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_ModifyPaths);
-		modifyPathsButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				modifySearchPaths();
-			}
-		});
-		spacer2 = new Label(buttonsBar, SWT.NONE);
-		removeButton = new Button(buttonsBar, SWT.NONE);
-		removeButton.setText(BeanInfoUIMessages.BeanInfosWorkbookPage_Remove);
-		removeButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-				beaninfosList.removeAll(selected);
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-	}
-	
-	private List chooseVariableEntries() {
-		// Remove existing variable entries in both the classpath and the beaninfopaths.
-		// Don't want classpath ones because they should be of been selected in the search paths page.
-		ArrayList existingPaths= new ArrayList();
-		for (int i= 0; i < rawList.length; i++) {
-			if (rawList[i].getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
-				existingPaths.add(rawList[i].getPath());
-			}
-		}
-		
-		List ours = beaninfosList;
-		for (int i = 0; i < ours.size(); i++) {
-			BPBeaninfoListElement bpb = (BPBeaninfoListElement) ours.get(i);
-			if (bpb.getEntry().getKind() == IClasspathEntry.CPE_VARIABLE)
-				existingPaths.add(bpb.getEntry().getPath());
-		}
-		
-		VariableSelectionDialog dialog= new VariableSelectionDialog(addVariableButton.getShell(), existingPaths);
-		if (dialog.open() == Window.OK) {
-			IPath path= dialog.getVariable();
-			IClasspathEntry cpe = JavaCore.newVariableEntry(path, null, null);
-			IPath resolvedPath= JavaCore.getResolvedVariablePath(path);
-			boolean isMissing = resolvedPath == null || !resolvedPath.toFile().isFile();
-			return Collections.singletonList(new BPBeaninfoListElement(new BeaninfoEntry(cpe, null, true), null, isMissing));
-		}
-		return null;
-	}	
-	
-	private List chooseJarFiles() {
-		IPath[] jarPaths = BuildPathDialogAccess.chooseJAREntries(addJarsButton.getShell(), javaProject.getPath(), getUsedJARFiles());
-		if (jarPaths!=null) {
-			List res= new ArrayList(jarPaths.length);
-			for (int i= 0; i < jarPaths.length; i++) {
-				BPBeaninfoListElement newGuy = newBPBeaninfoListElementFromFullpath(jarPaths[i]);
-				if (newGuy != null)
-					res.add(newGuy);
-			}
-			return res;
-		}
-		return null;
-	}
-
-	private List chooseExtJarFiles() {
-		IPath[] extJARPaths = BuildPathDialogAccess.chooseExternalJAREntries(addExtJarsButton.getShell());
-		List elems = null;
-		if(extJARPaths!=null){
-			elems = new ArrayList(extJARPaths.length);
-			for (int i= 0; i < extJARPaths.length; i++) {
-				BPBeaninfoListElement newGuy = newBPBeaninfoListElement(extJARPaths[i]);
-				if (newGuy != null)
-					elems.add(newGuy);
-			}
-		}
-		return elems;
-	}
-
-	private BPBeaninfoListElement newBPBeaninfoListElement(IPath path) {
-		// Create for an external, if not already used in either classpath or beaninfo path.
-		// These can't be pre-selected out like for the other choose dialogs.
-		for (int i = 0; i < resolvedList.length; i++) {
-			IClasspathEntry cpe = resolvedList[i];
-			if (cpe != null && cpe.getEntryKind() == IClasspathEntry.CPE_LIBRARY && cpe.getPath().equals(path))
-				return null;	// Already exists.
-		}
-		
-		// Now see if one of ours.
-		List ours = beaninfosList;
-		for (int i = 0; i < ours.size(); i++) {
-			BPBeaninfoListElement bpb = (BPBeaninfoListElement) ours.get(i);
-			if (bpb.getEntry().getKind() == IClasspathEntry.CPE_LIBRARY && bpb.getEntry().getPath().equals(path))
-				return null;	// Already exists
-		}
-		
-		IClasspathEntry cpe = JavaCore.newLibraryEntry(path, null, null);
-		BeaninfoEntry bie = new BeaninfoEntry(cpe, null, true);
-		return new BPBeaninfoListElement(bie, null, false);
-	}
-	
-
-	private IPath[] getUsedJARFiles() {
-		// Jars used by both the classpath and the beaninfo search path.
-		// Don't want jars used by classpath because those would then be
-		// in the buildpath and user would select paths through the search path page.
-		ArrayList res= new ArrayList();
-		for (int i= 0; i < resolvedList.length; i++) {
-			if (resolvedList[i] != null && resolvedList[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
-				IPath path = resolvedList[i].getPath();
-				IResource resource= workspaceRoot.findMember(path);
-				if (resource instanceof IFile)
-					res.add(path);
-			}
-		}
-
-		List bilist= beaninfosList;
-		for (int i= 0; i < bilist.size(); i++) {
-			BPListElement elem= (BPListElement)bilist.get(i);
-			if (elem.getEntry().getKind() == IClasspathEntry.CPE_LIBRARY) {
-				IPath path = elem.getEntry().getPath();
-				IResource resource= workspaceRoot.findMember(path);
-				if (resource instanceof IFile)
-					res.add(path);
-			}
-		}
-		return (IPath[]) res.toArray(new IPath[res.size()]);
-	}	
-
-	/**
-	 * Create a new BPListElement for the given object.
-	 */
-	private BPBeaninfoListElement newBPBeaninfoListElement(IResource element) {
-		if (element instanceof IContainer || element instanceof IFile) {
-			return newBPBeaninfoListElementFromFullpath(element.getFullPath());
-		}
-		return null;
-	}
-	
-	/**
-	 * Create a new BPListElement for the given object.
-	 * @since 1.2.0
-	 */
-	private BPBeaninfoListElement newBPBeaninfoListElementFromFullpath(IPath fullPath) {
-		if(fullPath!=null){
-			IClasspathEntry cpe = JavaCore.newLibraryEntry(fullPath, null, null);
-			BeaninfoEntry bie = new BeaninfoEntry(cpe, null, true);
-			return new BPBeaninfoListElement(bie, null, false);
-		}
-		return null;
-	}
-
-	private List chooseClassContainers() {	
-		Class[] acceptedClasses= new Class[] { IFolder.class };
-		ISelectionStatusValidator validator= new TypedElementSelectionValidator(acceptedClasses, true);
-			
-		acceptedClasses= new Class[] { IProject.class, IFolder.class };
-
-		ViewerFilter filter= new TypedViewerFilter(acceptedClasses, getUsedContainers());	
-			
-		ILabelProvider lp= new WorkbenchLabelProvider();
-		ITreeContentProvider cp= new WorkbenchContentProvider();
-
-		ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(addFoldersbutton.getShell(), lp, cp);
-		dialog.setValidator(validator);
-		dialog.setTitle(BeanInfoUIMessages.BeanInfosWorkbookPage_SelectionDialog_Classes_Title); 
-		dialog.setMessage(BeanInfoUIMessages.BeanInfosWorkbookPage_SelectionDialog_Classes_Prompt);  
-		dialog.addFilter(filter);
-		dialog.setInput(workspaceRoot);
-		dialog.setInitialSelection(javaProject.getProject());
-		
-		if (dialog.open() == Window.OK) {
-			Object[] elements= dialog.getResult();
-			List res= new ArrayList(elements.length);
-			for (int i= 0; i < elements.length; i++) {
-				BPBeaninfoListElement newGuy = newBPBeaninfoListElement((IResource) elements[i]);
-				if (newGuy != null)
-					res.add(newGuy);
-			}
-			return res;
-		}
-		return null;		
-	}
-	
-	private IContainer[] getUsedContainers() {
-		// Containers used by both the classpath and the beaninfo search path.
-		// Don't want containers used by classpath because those would then be
-		// in the buildpath and user would select paths through the search path page.
-		ArrayList res= new ArrayList();
-		try {
-			IPath outputLocation= javaProject.getOutputLocation();
-			if (outputLocation != null) {
-				IResource resource= workspaceRoot.findMember(outputLocation);
-				if (resource instanceof IContainer) {
-					res.add(resource);
-				}
-			}
-		} catch (JavaModelException e) {
-			// ignore it here, just log
-			JEMUIPlugin.getPlugin().getLogger().log(e.getStatus());
-		}
-			
-		for (int i= 0; i < resolvedList.length; i++) {
-			if (resolvedList[i] != null && resolvedList[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
-				IResource resource= workspaceRoot.findMember(resolvedList[i].getPath());
-				if (resource instanceof IContainer) {
-					res.add(resource);
-				}
-			}
-		}
-
-		List bilist= beaninfosList;
-		for (int i= 0; i < bilist.size(); i++) {
-			BPListElement elem= (BPListElement)bilist.get(i);
-			if (elem.getEntry().getKind() == IClasspathEntry.CPE_SOURCE) {
-				IResource resource= workspaceRoot.findMember(elem.getEntry().getPath());
-				res.add(resource);
-			}
-		}
-		return (IContainer[]) res.toArray(new IContainer[res.size()]);
-	}
-	
-
-	protected void addToBeaninfosList(final List toAdd){
-		if (beaninfosList != null && toAdd!=null) {
-			beaninfosList.addAll(toAdd);
-			tableViewer.refresh();
-			table.getDisplay().asyncExec(new Runnable(){
-				public void run() {
-					tableViewer.setSelection(new StructuredSelection(toAdd));
-				}
-			});
-			pageChanged();
-		}
-	}
-	
-	private void pageChanged() {
-		if (javaProject != null) {
-			// already initialized
-			updateSearchpathList();
-		}
-	}
-
-	private void updateSearchpathList() {
-		List searchelements = beaninfoPathsBlock.getSearchpathOrderingPage().getElements();
-
-		List beaninfoelements = new ArrayList(beaninfosList);
-
-		boolean changeDone = false;
-		// First go through the search path and remove any Beaninfo list elements that
-		// are not in this pages beaninfos list.
-		for (ListIterator spitr = searchelements.listIterator(searchelements.size());
-			spitr.hasPrevious();
-			) {
-			BPListElement element = (BPListElement) spitr.previous();
-			if (element instanceof BPBeaninfoListElement && !beaninfoelements.remove(element)) {
-				// Search element and not found in packages list so remove it from searchpath list.
-				spitr.remove();
-				changeDone = true;
-			}
-		}
-		// Any left over in beaninfos list are new and need to be added.
-		searchelements.addAll(beaninfoelements);
-		changeDone = changeDone || !beaninfoelements.isEmpty();
-
-		if (changeDone)
-			beaninfoPathsBlock.setSearchOrderElements(searchelements);
-	}
-
-	public void init(IJavaProject javaProject){
-		this.javaProject = javaProject;
-		labelProvider.setJavaProject(this.javaProject);
-		try {
-			rawList = this.javaProject.getRawClasspath();
-			resolvedList = new IClasspathEntry[rawList.length];
-			for (int i = 0; i < rawList.length; i++) {
-				resolvedList[i] = JavaCore.getResolvedClasspathEntry(rawList[i]);
-			}
-		} catch (JavaModelException e) {
-			rawList = resolvedList = new IClasspathEntry[0];
-		}
-		updateBeaninfosList();
-	}
-
-	private void updateBeaninfosList() {
-		List spelements = beaninfoPathsBlock.getSearchpathOrderingPage().getElements();
-
-		List biElements = new ArrayList(spelements.size());
-		for (int i = 0; i < spelements.size(); i++) {
-			BPListElement spe = (BPListElement) spelements.get(i);
-			if (spe instanceof BPBeaninfoListElement) {
-				biElements.add(spe);
-			}
-		}
-		beaninfosList.clear();
-		beaninfosList.addAll(biElements);
-		if(tableViewer!=null && !table.isDisposed())
-			tableViewer.refresh();
-	}
-
-	public List getSelection() {
-		if(tableViewer!=null)
-			return BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-		return null;
-	}
-
-	public void setSelection(List selection) {
-		if(tableViewer!=null)
-			tableViewer.setSelection(new StructuredSelection(selection));
-	}
-
-	
-	protected void updateButtons(){
-		List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-		addExtJarsButton.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		addFoldersbutton.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		addJarsButton.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		addProjectButton.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		addVariableButton.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		
-		removeButton.setEnabled(selected!=null && selected.size()>0 && beaninfoPathsBlock.isBeaninfoEnabled());
-		modifyPathsButton.setEnabled(selected!=null && selected.size()==1 && beaninfoPathsBlock.isBeaninfoEnabled());
-	}
-	
-	private List chooseProjects() {	
-		Class[] acceptedClasses= new Class[] { IJavaProject.class };
-		ISelectionStatusValidator validator= new TypedElementSelectionValidator(acceptedClasses, true);
-
-		List allProjects = null;
-		try {
-			allProjects = new ArrayList(Arrays.asList(javaProject.getJavaModel().getChildren()));
-		} catch(JavaModelException e) {
-			allProjects = Collections.EMPTY_LIST;
-		}
-		allProjects.removeAll(getUsedProjects());
-			
-		ILabelProvider lp= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
-
-		ElementListSelectionDialog dialog= new ElementListSelectionDialog(addProjectButton.getShell(), lp);
-		dialog.setValidator(validator);
-		dialog.setTitle(BeanInfoUIMessages.BeanInfosWorkbookPage_SelectionDialog_Projects_Title); 
-		dialog.setMessage(BeanInfoUIMessages.BeanInfosWorkbookPage_SelectionDialog_Projects_Prompt); 
-		dialog.setElements(allProjects.toArray());
-		
-		if (dialog.open() == Window.OK) {
-			Object[] elements= dialog.getResult();
-			List res= new ArrayList(elements.length);
-			for (int i= 0; i < elements.length; i++) {
-				try {
-					IClasspathEntry cpe = JavaCore.newProjectEntry(((IJavaProject) elements[i]).getCorrespondingResource().getFullPath());
-					BeaninfoEntry bie = new BeaninfoEntry(cpe, null, true);
-					res.add(new BPBeaninfoListElement(bie, null, false));
-				} catch(JavaModelException e) {
-				}
-			}
-			return res;
-		}
-		return null;		
-	}
-	
-	private List getUsedProjects() {
-		// Projects used by both the classpath and the beaninfo search path.
-		// Don't want projects used by classpath because those would then be
-		// in the buildpath and user would select paths through the search path page.
-		ArrayList res= new ArrayList();
-		res.add(javaProject);	// Plus our own project is used.
-		IJavaModel jmodel = javaProject.getJavaModel();
-		for (int i= 0; i < resolvedList.length; i++) {
-			if (resolvedList[i] != null && resolvedList[i].getEntryKind() == IClasspathEntry.CPE_PROJECT) {
-				res.add(jmodel.getJavaProject(resolvedList[i].getPath().segment(0)));
-			}
-		}
-
-		List bilist= beaninfosList;
-		for (int i= 0; i < bilist.size(); i++) {
-			BPListElement elem= (BPListElement)bilist.get(i);
-			if (elem.getEntry().getKind() == IClasspathEntry.CPE_PROJECT) 
-				res.add(jmodel.getJavaProject(elem.getEntry().getPath().segment(0)));			
-		}
-		return res;
-	}
-
-	private void modifySearchPaths() {
-		// Bring up the dialog for modifying search paths of a particular beaninfo entry.
-		BPBeaninfoListElement elem = (BPBeaninfoListElement) ((IStructuredSelection)tableViewer.getSelection()).getFirstElement();	// There should only be one, button not enabled if none or more than one selected.
-		BeaninfoEntrySearchpathDialog dialog = new BeaninfoEntrySearchpathDialog(modifyPathsButton.getShell(), elem, javaProject);
-		dialog.open();
-	}
-	
-	protected void updateEnabledStates(){
-		updateButtons();
-		table.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		label.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-	}
-	
-	public void setBeaninfoEnabled(boolean enable) {
-		if(javaProjectsComposite!=null && !javaProjectsComposite.isDisposed()){ 
-			// ui populated
-			updateEnabledStates();
-		}
-	}
-
-}  //  @jve:decl-index=0:visual-constraint="10,10"
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/ExceptionHandler.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/ExceptionHandler.java
deleted file mode 100644
index bc75eca..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/ExceptionHandler.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ExceptionHandler.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/26 20:26:59 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.io.StringWriter;
-import java.lang.reflect.InvocationTargetException;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jface.dialogs.ErrorDialog;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.swt.widgets.Shell;
-
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
- 
-/**
- * 
- * 
- * @since 1.2.0
- */
-public class ExceptionHandler {
-
-	/**
-	 * 
-	 * @param e
-	 * @param shell
-	 * @param title
-	 * @param message
-	 * 
-	 * @since 1.2.0
-	 */
-	public static void handle(InvocationTargetException e, Shell shell, String title, String message) {
-		Throwable target= e.getTargetException();
-		if (target instanceof CoreException) {
-			handle((CoreException)target, shell, title, message);
-		} else {
-			JEMUIPlugin.getPlugin().getLogger().log(e);
-			if (e.getMessage() != null && e.getMessage().length() > 0) {
-				displayMessageDialog(e, e.getMessage(), shell, title, message);
-			} else {
-				displayMessageDialog(e, target.getMessage(), shell, title, message);
-			}
-		}
-	}
-	
-	public static void handle(CoreException e, Shell shell, String title, String message) {
-		JEMUIPlugin.getPlugin().getLogger().log(e);
-		IStatus status= e.getStatus();
-		if (status != null) {
-			ErrorDialog.openError(shell, title, message, status);
-		} else {
-			displayMessageDialog(e, e.getMessage(), shell, title, message);
-		}
-	}
-	
-	private static void displayMessageDialog(Throwable t, String exceptionMessage, Shell shell, String title, String message) {
-		StringWriter msg= new StringWriter();
-		if (message != null) {
-			msg.write(message);
-			msg.write("\n\n"); //$NON-NLS-1$
-		}
-		if (exceptionMessage == null || exceptionMessage.length() == 0)
-			msg.write("See error log for more details."); 
-		else
-			msg.write(exceptionMessage);
-		MessageDialog.openError(shell, title, msg.toString());			
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/IBuildSearchPage.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/IBuildSearchPage.java
deleted file mode 100644
index 04f98f3..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/IBuildSearchPage.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IBuildSearchPage.java,v $
- *  $Revision: 1.1 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.List;
-
-public interface IBuildSearchPage {
-
-	public List getSelection();
-	public void setSelection(List selection);
-	public void setBeaninfoEnabled(boolean enable);
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/IStatusChangeListener.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/IStatusChangeListener.java
deleted file mode 100644
index e7c2954..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/IStatusChangeListener.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IStatusChangeListener.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/26 20:26:59 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import org.eclipse.core.runtime.IStatus;
- 
-/**
- * Status change listener
- * 
- * @since 1.2.0
- */
-public interface IStatusChangeListener {
-	
-	/**
-	 * Notifies this listener that the given status has changed.
-	 * 
-	 * @param	status	the new status
-	 */
-	void statusChanged(IStatus status);
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/ImageDisposer.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/ImageDisposer.java
deleted file mode 100644
index ad1b829..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/ImageDisposer.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ImageDisposer.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/26 20:26:59 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import org.eclipse.jface.util.Assert;
-import org.eclipse.swt.events.DisposeEvent;
-import org.eclipse.swt.events.DisposeListener;
-import org.eclipse.swt.graphics.Image;
- 
-/**
- * 
- * 
- * @since 1.2.0
- */
-public class ImageDisposer implements DisposeListener {
-	
-	private Image[] fImages;
-		
-	public ImageDisposer(Image image) {
-		this(new Image[] { image });
-	}
-	
-	public ImageDisposer(Image[] images) {
-		Assert.isNotNull(images);
-		fImages= images;		
-	}
-	
-	/*
-	 * @see WidgetListener#widgetDisposed
-	 */
-	public void widgetDisposed(DisposeEvent e) {
-		if (fImages != null) {
-			for (int i= 0; i < fImages.length; i++) {
-				fImages[i].dispose();
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/OverlayComposite.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/OverlayComposite.java
deleted file mode 100644
index 7088d13..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/OverlayComposite.java
+++ /dev/null
@@ -1,200 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  Created Apr 27, 2005 by Gili Mendel
- * 
- *  $RCSfile: OverlayComposite.java,v $
- *  $Revision: 1.2 $  $Date: 2005/08/24 21:07:12 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.*;
-
-import org.eclipse.jface.resource.CompositeImageDescriptor;
-import org.eclipse.swt.graphics.ImageData;
-import org.eclipse.swt.graphics.Point;
- 
-//TODO:  This class was dropped in 3.1 M7 from org.eclipse.ui.internal.misc
-//       We made  local copy for the time being.  Need to investigate if this is file
-//       for us given that the OverlayIcon (replacement) is internal
-public class OverlayComposite extends CompositeImageDescriptor {
-
-    private ImageData backgroundImage;
-
-    private ImageData leftImage;
-
-    private ImageData rightImage;
-
-    private ImageData topImage;
-
-    private ImageData bottomImage;
-
-    private List foregroundImages = new ArrayList();
-
-    /**
-     *	Create an instance of this class.
-     */
-    public OverlayComposite(ImageData background) {
-        backgroundImage = background;
-    }
-
-    /**
-     *	Add the passed image to this descriptor's collection of images to 
-     * be composed together to create an image.
-     */
-    public void addForegroundImage(ImageData image) {
-        foregroundImages.add(image);
-    }
-
-    /**
-     *Superimpose self's images within the given bounds by means of #drawImage
-     *
-     *@see CompositeImage#drawImage(ImageData src,int ox,int oy)
-     */
-    protected void drawCompositeImage(int width, int height) {
-        //draw background
-        drawImage(backgroundImage, getLeftBound(), getTopBound());
-
-        //draw foreground images
-        Iterator e = foregroundImages.iterator();
-        while (e.hasNext())
-            drawImage(((ImageData) e.next()), getLeftBound(), getTopBound());
-
-        //draw extensions
-        if (topImage != null)
-            drawImage(topImage, getLeftBound(), 0);
-        if (bottomImage != null)
-            drawImage(bottomImage, getLeftBound(), height - bottomImage.height);
-        if (leftImage != null)
-            drawImage(leftImage, 0, getTopBound());
-        if (rightImage != null)
-            drawImage(rightImage, width - rightImage.width, getTopBound());
-
-    }
-
-    /**
-     * @see Object#equals
-     */
-    public boolean equals(Object o) {
-        if (!(o instanceof OverlayComposite)) {
-            return false;
-        }
-        OverlayComposite other = (OverlayComposite) o;
-
-        return equals(backgroundImage, other.backgroundImage)
-                && equals(leftImage, other.leftImage)
-                && equals(rightImage, other.rightImage)
-                && equals(topImage, other.topImage)
-                && equals(bottomImage, other.bottomImage)
-                && equals(foregroundImages, other.foregroundImages);
-    }
-
-    /**
-     * Private utility for comparing two possibly-null objects.
-     */
-    private boolean equals(Object o1, Object o2) {
-        return o1 == null ? o2 == null : o1.equals(o2);
-    }
-
-    /**
-     *	Answer the left-most coordinate that the main image can draw to
-     *
-     *	@return int
-     */
-    protected int getLeftBound() {
-        if (leftImage == null)
-            return 0;
-
-        return leftImage.width;
-    }
-
-    /**
-     *	Answer self's size, as determined by the size of the initially-
-     *	provided base-level image
-     */
-    protected Point getSize() {
-        //start with basic size
-        Point size = new Point(backgroundImage.width, backgroundImage.height);
-
-        //overlays may increase size.
-        if (topImage != null)
-            size.y += topImage.height;
-
-        if (bottomImage != null)
-            size.y += bottomImage.height;
-
-        if (leftImage != null)
-            size.x += leftImage.width;
-
-        if (rightImage != null)
-            size.x += rightImage.width;
-
-        return size;
-    }
-
-    /**
-     *	Answer the top-most coordinate that the main image can draw to
-     *
-     *	@return int
-     */
-    protected int getTopBound() {
-        if (topImage == null)
-            return 0;
-
-        return topImage.height;
-    }
-
-    /**
-     * @see Object#hashCode
-     */
-    public int hashCode() {
-        return hashCode(backgroundImage) + hashCode(leftImage)
-                + hashCode(rightImage) + hashCode(topImage)
-                + hashCode(bottomImage) + hashCode(foregroundImages);
-    }
-
-    /**
-     * Private utility for getting the hashCode for an
-     * object that may be null.
-     */
-    private int hashCode(Object o) {
-        return o == null ? 0 : o.hashCode();
-    }
-
-    /**
-     *  Set the image to be drawn below the primary overlay region.
-     */
-    public void setBottomExtension(ImageData value) {
-        bottomImage = value;
-    }
-
-    /**
-     *  Set the image to be drawn to the left of the primary overlay region.
-     */
-    public void setLeftExtension(ImageData value) {
-        leftImage = value;
-    }
-
-    /**
-     *  Set the image to be drawn to the right of the primary overlay region.
-     */
-    public void setRightExtension(ImageData value) {
-        rightImage = value;
-    }
-
-    /**
-     *  Set the image to be drawn above the primary overlay region.
-     */
-    public void setTopExtension(ImageData value) {
-        topImage = value;
-    }
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/PackageOnlyContentProvider.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/PackageOnlyContentProvider.java
deleted file mode 100644
index e8ad18b..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/PackageOnlyContentProvider.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: PackageOnlyContentProvider.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 21:07:12 $ 
- */
-
-
-import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
-
-import org.eclipse.jdt.core.IPackageFragment;
-import java.util.*;
-/**
- * A content provider which will only go down to the package level,
- * it won't explore further. The advantage of this is so that plus signs ('+')
- * won't show up on packages. The Filter technique could be used to not
- * show the children, but this still shows the plus sign.
- *
- * Also, if the element is a java.util.List, then that list will be returned
- * as the children. This allows for a root to be composed instead of being
- * one of the standard Java Elements.
- */
-
-public class PackageOnlyContentProvider extends StandardJavaElementContentProvider {
-	
-	/**
-	 * If the element is a list, return the iterator on it.
-	 * Else send it up the chain.
-	 */
-	public Object[] getChildren(Object element) {
-		if (element instanceof List)
-			return ((List) element).toArray();
-		return super.getChildren(element);
-	}
-	
-	/**
-	 * If the element is a list and it is not empty, it has children,
-	 * if it is a IPackageFragment it does not,
-	 * else send it up the chain.
-	 */
-	public boolean hasChildren(Object element) {
-		if (element instanceof List)
-			return !((List) element).isEmpty();
-		if (element instanceof IPackageFragment)
-			return false;
-		return super.hasChildren(element);
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/PackagesWorkbookPage.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/PackagesWorkbookPage.java
deleted file mode 100644
index 01423c4..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/PackagesWorkbookPage.java
+++ /dev/null
@@ -1,464 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PackagesWorkbookPage.java,v $
- *  $Revision: 1.9 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.*;
-import java.util.List;
-
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.ui.JavaElementLabelProvider;
-import org.eclipse.jface.viewers.*;
-import org.eclipse.jface.window.Window;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.layout.*;
-import org.eclipse.swt.widgets.*;
-import org.eclipse.ui.dialogs.*;
-
-import org.eclipse.jem.internal.beaninfo.core.SearchpathEntry;
-
-public class PackagesWorkbookPage implements IBuildSearchPage {
-	
-	/**
-	 * Validator for this workbook page to verify the selections on Choose page.
-	 * @version 	1.0
-	 * @author
-	 */
-	public static class ChoosePackagesSelectionValidator implements ISelectionStatusValidator {
-
-		private IStatus fgErrorStatus = StatusHelper.ERROR_STATUS; //$NON-NLS-1$
-		private IStatus fgOKStatus = StatusHelper.OK_STATUS;
-
-		public ChoosePackagesSelectionValidator() {
-		}
-
-		/*
-		 * @see ISelectionValidator#validate(Object)
-		 */
-		public IStatus validate(Object[] selection) {
-			if (isValid(selection)) {
-				return fgOKStatus;
-			}
-			return fgErrorStatus;
-		}
-
-		private boolean isValid(Object[] selection) {
-			if (selection.length == 0)
-				return false;
-
-			for (int i = 0; i < selection.length; i++) {
-				if (selection[i] instanceof IPackageFragment)
-					continue; // Fragments are always valid
-				return false;
-			}
-
-			return true;
-		}
-
-	}
-
-	
-	private Label label = null;
-	private Table table = null;
-	private Composite buttonBar = null;
-	private Button choosePackagesButton = null;
-	private Button chooseDefPathsButton = null;
-	private Label spacer1 = null;
-	private Button removeButton = null;
-	// ... ui
-	
-	private IJavaProject javaProject = null;
-	private SearchPathListLabelProvider labelProvider = null;
-	private BeaninfoPathsBlock beaninfosPathsBlock = null;
-	private IPackageFragmentRoot[][] rootsPerRawEntry;
-	private IClasspathEntry[] rawList;
-	private TableViewer tableViewer;
-	private List packagesList = null;
-	private Composite top;
-
-	public PackagesWorkbookPage(IWorkspaceRoot workspaceRoot, BeaninfoPathsBlock beaninfosPathsBlock) {
-		this.beaninfosPathsBlock = beaninfosPathsBlock;
-		this.packagesList = new ArrayList();
-		this.labelProvider = new SearchPathListLabelProvider();
-	}
-
-	public Control createControl(Composite parent){
-		top = new Composite(parent, SWT.NONE);
-		GridData gridData = new org.eclipse.swt.layout.GridData();
-		gridData.horizontalSpan = 2;
-		GridLayout gridLayout = new GridLayout();
-		gridLayout.numColumns = 2;
-		top.setLayout(gridLayout);
-		label = new Label(top, SWT.NONE);
-		label.setText(BeanInfoUIMessages.PackagesWorkbook_LabelText);
-		label.setLayoutData(gridData);
-		createTable();
-		createButtonBar();
-		top.setSize(new Point(300, 200));
-		updateEnabledStates();
-		if(spacer1==null){
-			//TODO: 
-		}
-		return top;
-	}
-
-	/**
-	 * This method initializes table	
-	 *
-	 */
-	private void createTable() {
-		GridData gridData1 = new org.eclipse.swt.layout.GridData();
-		gridData1.grabExcessVerticalSpace = true;
-		gridData1.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData1.grabExcessHorizontalSpace = true;
-		gridData1.horizontalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		table = new Table(top, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
-		table.setLayoutData(gridData1);
-		table.addSelectionListener(new org.eclipse.swt.events.SelectionListener() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				updateButtons();
-			}
-			public void widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent e) {
-				widgetSelected(e);
-			}
-		});
-		tableViewer = new TableViewer(table);
-		tableViewer.setLabelProvider(labelProvider);
-		tableViewer.setSorter(new SPListElementSorter());
-		tableViewer.setContentProvider(new ArrayContentProvider());
-		tableViewer.setInput(packagesList);
-	}
-
-	/**
-	 * This method initializes buttonBar	
-	 *
-	 */
-	private void createButtonBar() {
-		RowLayout rowLayout = new RowLayout();
-		rowLayout.type = org.eclipse.swt.SWT.VERTICAL;
-		rowLayout.fill = true;
-		GridData gridData2 = new org.eclipse.swt.layout.GridData();
-		gridData2.grabExcessVerticalSpace = true;
-		gridData2.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData2.horizontalAlignment = org.eclipse.swt.layout.GridData.BEGINNING;
-		buttonBar = new Composite(top, SWT.NONE);
-		buttonBar.setLayoutData(gridData2);
-		buttonBar.setLayout(rowLayout);
-		choosePackagesButton = new Button(buttonBar, SWT.NONE);
-		choosePackagesButton.setText(BeanInfoUIMessages.PackagesWorkbook_ChoosePackages);
-		choosePackagesButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				final List elementsToAdd = choosePackages();
-				addToPackagesList(elementsToAdd);
-			}
-		});
-		chooseDefPathsButton = new Button(buttonBar, SWT.NONE);
-		chooseDefPathsButton.setText(BeanInfoUIMessages.PackagesWorkbook_ChooseDefinedPaths);
-		chooseDefPathsButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List elementsToAdd = chooseDefined();
-				addToPackagesList(elementsToAdd);
-			}
-		});
-		spacer1 = new Label(buttonBar, SWT.NONE);
-		removeButton = new Button(buttonBar, SWT.NONE);
-		removeButton.setText(BeanInfoUIMessages.PackagesWorkbook_Remove);
-		removeButton.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
-			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
-				List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-				packagesList.removeAll(selected);
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-	}
-	
-	private void addToPackagesList(final List toAdd){
-		if (toAdd != null && !toAdd.isEmpty()) {
-			packagesList.addAll(toAdd);
-			tableViewer.refresh();
-			table.getDisplay().asyncExec(new Runnable(){
-				public void run() {
-					tableViewer.setSelection(new StructuredSelection(toAdd));
-				}
-			});
-			pageChanged();
-		}
-	}
-
-	public void init(IJavaProject jproject) {
-		javaProject = jproject;
-		labelProvider.setJavaProject(jproject);
-		try {
-			rawList = javaProject.getRawClasspath();
-			rootsPerRawEntry = new IPackageFragmentRoot[rawList.length][];
-			for (int i = 0; i < rawList.length; i++) {
-				rootsPerRawEntry[i] = javaProject.findPackageFragmentRoots(rawList[i]);
-			}		
-		} catch (JavaModelException e) {
-			rawList = new IClasspathEntry[0];
-			rootsPerRawEntry = new IPackageFragmentRoot[0][];
-		}
-		updatePackagesList();
-	}
-
-	public List getSelection() {
-		return BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-	}
-
-	public void setSelection(List selection) {
-		tableViewer.setSelection(new StructuredSelection(selection));
-	}
-	
-	private void updatePackagesList() {
-		List spelements = beaninfosPathsBlock.getSearchpathOrderingPage().getElements();
-
-		List packageElements = new ArrayList(spelements.size());
-		for (int i = 0; i < spelements.size(); i++) {
-			BPListElement spe = (BPListElement) spelements.get(i);
-			if (spe instanceof BPSearchListElement) {
-				packageElements.add(spe);
-			}
-		}
-		packagesList.clear();
-		packagesList.addAll(packageElements);
-		if(tableViewer!=null && !table.isDisposed())
-			tableViewer.refresh();
-	}
-
-	/**
-	 * Choose the packages that should be in the search path.
-	 */
-	private List choosePackages() {
-
-		ISelectionStatusValidator validator = new ChoosePackagesSelectionValidator();
-
-		// Show up to the package fragment, don't show any contents of it.
-		Class[] acceptedClasses =
-			new Class[] { IJavaProject.class, IPackageFragmentRoot.class, IPackageFragment.class };
-		Object[] rejectedFragments = getFilteredExistingEntries();
-
-		// Only show package fragments that have children (i.e. there classes in it, not interested
-		// in intermediate ones that have no classes defined in them. Those are filtered out.
-		TypedViewerFilter filter = new TypedViewerFilter(acceptedClasses, rejectedFragments) {
-			public boolean select(Viewer viewer, Object parentElement, Object element) {
-				if (super.select(viewer, parentElement, element)) {
-					if (element instanceof IPackageFragment) {
-						IPackageFragment pkg = (IPackageFragment) element;
-						try {
-							return pkg.hasChildren();
-						} catch (JavaModelException e) {
-						}
-						return false;
-					} else
-						return true;
-				}
-				return false;
-			}
-		};
-
-		ITreeContentProvider provider = new PackageOnlyContentProvider();
-
-		ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
-		ElementTreeSelectionDialog dialog =
-			new ElementTreeSelectionDialog(top.getShell(), labelProvider, provider);
-		dialog.setTitle(BeanInfoUIMessages.BeaninfoPathsBlock_UI__addsearchpath_title);
-
-		dialog.setValidator(validator);
-		dialog.setMessage(BeanInfoUIMessages.BeaninfoPathsBlock_UI__addsearchpath_description);
-		dialog.addFilter(filter);
-		dialog.setInput(javaProject);
-
-		if (dialog.open() == Window.OK) {
-			Object[] elements = dialog.getResult();
-			List newElements = new ArrayList(elements.length);
-			for (int i = 0; i < elements.length; i++) {
-				BPListElement newGuy = newBPListElement(elements[i]);
-				if (newGuy != null)
-					newElements.add(newGuy);
-			}
-			return newElements;
-		}
-		return Collections.EMPTY_LIST;
-	}
-
-	/**
-	 * Create a new BPListElement for the given object.
-	 */
-	protected BPListElement newBPListElement(Object element) {
-		SearchpathEntry se = null;
-		boolean isExported = false;
-		IPackageFragment frag = (IPackageFragment) element;
-		// Need to find corresponding raw class path entry.
-		IPackageFragmentRoot root = (IPackageFragmentRoot) frag.getParent(); // Get frag root.
-		for (int i = 0; i < rootsPerRawEntry.length; i++) {
-			for (int j = 0; j < rootsPerRawEntry[i].length; j++) {
-				if (rootsPerRawEntry[i][j].equals(root)) {
-					isExported = rawList[i].isExported() || rawList[i].getEntryKind() == IClasspathEntry.CPE_SOURCE;
-					se = new SearchpathEntry(rawList[i].getEntryKind(), rawList[i].getPath(), frag.getElementName());
-					break;
-				}
-			}
-		}
-
-		return new BPSearchListElement(se, false, false, isExported);
-	}
-
-	/**
-	 * Return the list of entries that already are in the search path
-	 * so that they don't show up in the list.
-	 */
-	protected Object[] getFilteredExistingEntries() {
-		try {
-			IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
-			List entries = packagesList;
-			List fragments = new ArrayList(entries.size());
-			Iterator itr = entries.iterator();
-			while (itr.hasNext()) {
-				BPListElement elem = (BPListElement) itr.next();
-				if (elem instanceof BPSearchListElement) {
-					BPSearchListElement bse = (BPSearchListElement) elem;
-					fragments.addAll(getPackages(bse, roots));
-				}
-			}
-			return fragments.toArray();
-		} catch (JavaModelException e) {
-		}
-		return new Object[0];
-	}
-	
-	/**
-	 * Find the package fragments for this package entry.
-	 */
-	protected List getPackages(BPSearchListElement element, IPackageFragmentRoot[] roots) {
-		String packageName = ((SearchpathEntry) element.getEntry()).getPackage();
-		if (packageName == null)
-			return Collections.EMPTY_LIST;
-
-		try {
-			List packages = new ArrayList(10);
-			for (int i = 0; i < roots.length; i++) {
-				IJavaElement[] pfs = roots[i].getChildren();
-				for (int j = 0; j < pfs.length; j++)
-					if (pfs[j].getElementType() == IJavaElement.PACKAGE_FRAGMENT
-						&& pfs[j].getElementName().equals(packageName)) {
-						packages.add(pfs[j]);
-						break;
-					}
-			}
-			return packages;
-		} catch (JavaModelException e) {
-		}
-		return Collections.EMPTY_LIST;
-	}
-	/**
-	 * Choose the pre-defined search paths that should be in the search path.
-	 */
-	private List chooseDefined() {
-
-		// Current pre-defined ones are only pre-reqed projects.
-		// The list of inputs will not contain any already in the path.
-		// We will create them here and if not selected they will thrown away.
-		// The assumption is that there are not very many and our SearchPathListLabelProvider does
-		// a good job of showing them. Otherwise we would need to come up with one that can show
-		// IJavaProjects when we get them.
-		List inputs = new ArrayList();
-		List currentList = packagesList;
-		for (int i = 0; i < rawList.length; i++) {
-			if (rawList[i].getEntryKind() == IClasspathEntry.CPE_PROJECT) {
-				boolean exists = false;
-				for (int j = 0; j < currentList.size(); j++) {
-					BPSearchListElement bse = (BPSearchListElement) currentList.get(j);
-					if (bse.getEntry().getKind() == IClasspathEntry.CPE_PROJECT && rawList[i].getPath().equals(bse.getEntry().getPath())) {
-						exists = true;
-						break;
-					}
-				}
-				
-				if (!exists)
-					inputs.add(new BPSearchListElement(new SearchpathEntry(IClasspathEntry.CPE_PROJECT, rawList[i].getPath(), null), false, false, rawList[i].isExported()));
-			}
-		}
-		
-		ILabelProvider labelProvider1 = new SearchPathListLabelProvider(javaProject);
-		ElementListSelectionDialog dialog =
-			new ElementListSelectionDialog(top.getShell(), labelProvider1);
-		dialog.setTitle(BeanInfoUIMessages.PackagesWorkbook_SelectionDialog_DefinedPaths_Title); 
-
-		dialog.setMessage(BeanInfoUIMessages.PackagesWorkbook_SelectionDialog_DefinedPaths_Message); 
-		dialog.setElements(inputs.toArray());
-
-		if (dialog.open() == Window.OK)
-			return Arrays.asList(dialog.getResult());
-		else
-			return Collections.EMPTY_LIST;
-	}
-
-	protected void updateButtons(){
-		chooseDefPathsButton.setEnabled(beaninfosPathsBlock.isBeaninfoEnabled());
-		choosePackagesButton.setEnabled(beaninfosPathsBlock.isBeaninfoEnabled());
-		
-		List selected = BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection());
-		removeButton.setEnabled(selected!=null && selected.size()>0 && beaninfosPathsBlock.isBeaninfoEnabled());
-	}
-	
-	/**
-	 * Something important about the page changed - perform update.
-	 * 
-	 * @since 1.2.0
-	 */
-	protected void pageChanged(){
-		updateSearchpathList();
-	}
-	
-	private void updateSearchpathList() {
-		List searchelements = beaninfosPathsBlock.getSearchpathOrderingPage().getElements();
-
-		List packageelements = packagesList;
-
-		boolean changeDone = false;
-		// First go through the search path and remove any SearchListElements that are
-		// not in the search packages list from this page.
-		for (ListIterator spitr = searchelements.listIterator(searchelements.size());
-			spitr.hasPrevious();
-			) {
-			BPListElement element = (BPListElement) spitr.previous();
-			if (element instanceof BPSearchListElement && !packageelements.remove(element)) {
-				// Search element and not found in packages list so remove it from searchpath list.
-				spitr.remove();
-				changeDone = true;
-			}
-		}
-		// Any left over in packages list are new and need to be added.
-		searchelements.addAll(packageelements);
-		changeDone = changeDone || !packageelements.isEmpty();
-
-		if (changeDone)
-			beaninfosPathsBlock.setSearchOrderElements(searchelements);
-	}
-
-	protected void updateEnabledStates(){
-		updateButtons();
-		table.setEnabled(beaninfosPathsBlock.isBeaninfoEnabled());
-		label.setEnabled(beaninfosPathsBlock.isBeaninfoEnabled());
-	}
-	
-	public void setBeaninfoEnabled(boolean enable) {
-		if(top!=null && !top.isDisposed())
-			updateEnabledStates();
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SPListElementSorter.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SPListElementSorter.java
deleted file mode 100644
index cb2885a..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SPListElementSorter.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: SPListElementSorter.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 21:07:12 $ 
- */
-
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerSorter;
-
-import org.eclipse.jem.internal.beaninfo.core.SearchpathEntry;
-
-/**
- * Sorter for sorting BPSearchListElements within the main list.
- * It is not to be used on elements within a specific beaninfo entry.
- * 
- * @version 	1.0
- * @author
- */
-public class SPListElementSorter extends ViewerSorter {
-	
-	/*
-	 * @see ViewerSorter#category(Object)
-	 */
-	public int category(Object obj) {
-		if (obj instanceof BPSearchListElement) {
-			BPSearchListElement element = (BPSearchListElement) obj;
-			
-			switch (((SearchpathEntry) element.getEntry()).getKind()) {
-			case IClasspathEntry.CPE_LIBRARY:
-				return 4;
-			case IClasspathEntry.CPE_PROJECT:
-				return 1;
-			case IClasspathEntry.CPE_SOURCE:
-				return 0;
-			case IClasspathEntry.CPE_VARIABLE:
-				return 3;
-			case IClasspathEntry.CPE_CONTAINER:
-				return 2;
-			}
-		}
-		return super.category(obj);
-	}
-
-	/*
-	 * @see ViewerSorter#compare()
-	 */	
-	public int compare(Viewer viewer, Object e1, Object e2) {
-		int cat1 = category(e1);
-		int cat2 = category(e2);
-	
-		if (cat1 != cat2)
-			return cat1 - cat2;
-			
-		if ((e1 instanceof BPSearchListElement) && (e2 instanceof BPSearchListElement)) {
-			SearchpathEntry p1 = (SearchpathEntry) ((BPSearchListElement) e1).getEntry();
-			SearchpathEntry p2 = (SearchpathEntry) ((BPSearchListElement) e2).getEntry();
-			
-			// Compare first within path, then packages within each path.
-			int c = p1.getPath().toString().compareTo(p2.getPath().toString());
-			if (c == 0) {
-				// Within same path, so now sort by package, if there are any.
-				String pkg1 = p1.getPackage();
-				String pkg2 = p2.getPackage();
-				if (pkg1 == null)
-					pkg1 = "";	// For null, use an empty string //$NON-NLS-1$
-				if (pkg2 == null)
-					pkg2 = ""; //$NON-NLS-1$
-				return pkg1.compareTo(pkg2);
-			} else
-				return c;	// Paths are not equal, so sort via path.
-		}
-		return super.compare(viewer, e1, e2);
-	}	
-
-
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SearchPathListLabelProvider.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SearchPathListLabelProvider.java
deleted file mode 100644
index 7542a72..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SearchPathListLabelProvider.java
+++ /dev/null
@@ -1,370 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-/*
- *  $RCSfile: SearchPathListLabelProvider.java,v $
- *  $Revision: 1.14 $  $Date: 2005/10/03 23:06:42 $ 
- */
-
-import java.net.URL;
-import java.text.MessageFormat;
-import java.util.HashMap;
-import java.util.Iterator;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.internal.ui.JavaPlugin;
-import org.eclipse.jdt.internal.ui.JavaPluginImages;
-import org.eclipse.jdt.ui.*;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
-import org.eclipse.jface.viewers.LabelProvider;
-import org.eclipse.swt.graphics.*;
-import org.eclipse.ui.IWorkbench;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.ide.IDE;
-import org.osgi.framework.Bundle;
-
-import org.eclipse.jem.internal.beaninfo.core.*;
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
-
-public class SearchPathListLabelProvider extends LabelProvider {
-
-	IWorkspaceRoot fRoot;
-	IJavaProject javaProject;
-
-	// Shared images
-	private Image fJarIcon, fExtJarIcon;
-	private Image fFolderImage, fProjectImage, fVariableImage, fLibraryImage;
-	private Image fMissingJarImage, fMissingVariableImage;
-	private Image fMissingFolderImage, fMissingProjectImage;
-	private Image fPackageImage;
-
-	// Local images, will be disposed.
-	private Image fPluginImage;
-	private Image fBeanImage;
-	private Image fMissingPackageImage;
-	private Image fBlankImage;
-	private Image fMissingLibraryImage;
-	private HashMap fBeanedImages = new HashMap(); // Key of image to a composite with a bean attached
-	private HashMap fPackagedImages = new HashMap();
-	private HashMap fMissingPackagedImages = new HashMap();
-	private HashMap fNormalImages = new HashMap();	// Need to composite normal images w/blank so that they are the same size as the composited ones.
-	// Key of image to a composite with a package attached
-
-	public SearchPathListLabelProvider() {
-		this(null);
-	}
-	
-	public SearchPathListLabelProvider(IJavaProject javaProject) {
-		this.javaProject = javaProject;
-		
-		fRoot = ResourcesPlugin.getWorkspace().getRoot();
-		ImageRegistry reg = JavaPlugin.getDefault().getImageRegistry();
-		ISharedImages jdtSharedImages = JavaUI.getSharedImages();
-
-		fJarIcon = jdtSharedImages.getImage(ISharedImages.IMG_OBJS_JAR);
-		fExtJarIcon = jdtSharedImages.getImage(ISharedImages.IMG_OBJS_EXTERNAL_ARCHIVE);
-		fFolderImage = jdtSharedImages.getImage(ISharedImages.IMG_OBJS_PACKFRAG_ROOT);
-
-		fVariableImage = reg.get(JavaPluginImages.IMG_OBJS_ENV_VAR);
-		
-		fLibraryImage = jdtSharedImages.getImage(ISharedImages.IMG_OBJS_LIBRARY);
-
-		IWorkbench workbench = PlatformUI.getWorkbench();
-		fProjectImage = workbench.getSharedImages().getImage(IDE.SharedImages.IMG_OBJ_PROJECT);
-
-		fMissingJarImage = reg.get(JavaPluginImages.IMG_OBJS_MISSING_JAR);
-		fMissingVariableImage = reg.get(JavaPluginImages.IMG_OBJS_MISSING_ENV_VAR);
-		fMissingFolderImage = reg.get(JavaPluginImages.IMG_OBJS_MISSING_PACKFRAG_ROOT);
-		fMissingProjectImage = workbench.getSharedImages().getImage(IDE.SharedImages.IMG_OBJ_PROJECT_CLOSED);
-
-		fPackageImage = jdtSharedImages.getImage(ISharedImages.IMG_OBJS_PACKAGE);
-
-		Rectangle r = fLibraryImage.getBounds();
-		Point s = new Point(r.width, r.height);
-		JavaElementImageDescriptor jed = new JavaElementImageDescriptor(jdtSharedImages.getImageDescriptor(ISharedImages.IMG_OBJS_LIBRARY),  JavaElementImageDescriptor.WARNING, s);
-		fMissingLibraryImage = jed.createImage();
-		Bundle bundle = JEMUIPlugin.getPlugin().getBundle();
-		URL url = Platform.find(bundle, new Path("icons/plugin_obj.gif")); //$NON-NLS-1$
-		if (url != null)
-			fPluginImage = ImageDescriptor.createFromURL(url).createImage();
-		else
-			fPluginImage = ImageDescriptor.getMissingImageDescriptor().createImage();
-
-		url = Platform.find(bundle, new Path("icons/javabean.gif")); //$NON-NLS-1$
-		if (url != null)
-			fBeanImage = ImageDescriptor.createFromURL(url).createImage();
-		else
-			fBeanImage = ImageDescriptor.getMissingImageDescriptor().createImage();
-
-		url = Platform.find(bundle, new Path("icons/package_obj_missing.gif")); //$NON-NLS-1$
-		if (url != null)
-			fMissingPackageImage = ImageDescriptor.createFromURL(url).createImage();
-		else
-			fMissingPackageImage = ImageDescriptor.getMissingImageDescriptor().createImage();
-
-		url = Platform.find(bundle, new Path("icons/blank.gif")); //$NON-NLS-1$
-		if (url != null)
-			fBlankImage = ImageDescriptor.createFromURL(url).createImage();
-		else
-			fBlankImage = ImageDescriptor.getMissingImageDescriptor().createImage();
-	}
-
-	public void setJavaProject(IJavaProject javaProject) {
-		this.javaProject = javaProject;
-	}
-	
-	public String getText(Object element) {
-		if (element instanceof BPListElement) {
-			BPListElement bpentry = (BPListElement) element;
-			IBeaninfosDocEntry docEntry = bpentry.getEntry();
-			IPath path = docEntry.getPath();
-			String pathString = null;
-			switch (docEntry.getKind()) {
-				case IClasspathEntry.CPE_LIBRARY :
-					IResource resource = fRoot.findMember(path);
-					if (resource instanceof IFolder) {
-						pathString =
-							MessageFormat.format(BeanInfoUIMessages.LabelProvider_Library_Folder, new Object[] { path.makeRelative().toString()}); 
-					} else if (resource instanceof IFile) {
-						if (VariableSelectionBlock.isArchivePath(path)) {
-							// Internal library
-							String[] args =
-								new String[] { path.lastSegment(), path.removeLastSegments(1).makeRelative().toString()};
-							pathString = MessageFormat.format(BeanInfoUIMessages.LabelProvider_Library__PathLastSegment_PathRelative_, args); 
-						}
-					} else {
-						if (VariableSelectionBlock.isArchivePath(path)) {
-							// External library
-							String[] args =
-								new String[] { path.lastSegment(), path.removeLastSegments(1).toString()};
-							pathString = MessageFormat.format(BeanInfoUIMessages.LabelProvider_Library__PathLastSegment_PathExceptLast_, args); 
-						} else {
-							// should not come here
-							pathString = path.makeRelative().toString();
-						}
-					}
-					break;
-
-				case IClasspathEntry.CPE_VARIABLE :
-					String name = path.makeRelative().toString();
-					IPath entryPath = JavaCore.getClasspathVariable(path.segment(0));
-					if (entryPath != null)
-						pathString =
-							MessageFormat.format(
-								BeanInfoUIMessages.LabelProvider_Variable__name_PathOSString_, 
-								new Object[] { name, entryPath.append(path.removeFirstSegments(1)).toOSString()});
-					else
-						pathString = name;
-					break;
-
-				case IClasspathEntry.CPE_CONTAINER:
-					try {
-						IClasspathContainer c = JavaCore.getClasspathContainer(path, javaProject);
-						if (c != null) {
-							pathString = c.getDescription();
-							break;
-						}
-					} catch (JavaModelException e) {
-					}
-					pathString = path.toString();
-					break;
-					
-				case IClasspathEntry.CPE_PROJECT :
-					pathString = path.toString();
-					break;
-
-				case IClasspathEntry.CPE_SOURCE :
-					pathString = path.makeRelative().toString();
-					break;
-
-				case BeaninfoEntry.BIE_PLUGIN :
-					pathString = path.toString();
-					break;
-				default :
-					// no path, so probably a search entry within a beaninfo entry.
-			}
-
-			if (docEntry instanceof SearchpathEntry) {
-				// There could be a package involved too if this is not a project or registered var entry
-				String packageName = ((SearchpathEntry) docEntry).getPackage();
-				if (packageName != null && packageName.length() > 0)
-					if (pathString != null)
-						return MessageFormat.format(BeanInfoUIMessages.LabelProvider__packageName_Path_, new Object[] { packageName, pathString }); 
-					else
-						return packageName;
-			}
-
-			if (pathString != null)
-				return pathString;
-			else
-				return "?"; //$NON-NLS-1$
-		}
-		return super.getText(element);
-	}
-
-	public Image getImage(Object element) {
-		Image returnedImage = null;
-		boolean imageIsNormal = true;	// Whether this is a normal sized image (which will need compositing with blank)
-		if (element instanceof BPListElement) {
-			BPListElement bpentry = (BPListElement) element;
-			IBeaninfosDocEntry docEntry = bpentry.getEntry();
-			IPath path = docEntry.getPath();
-			Image pathImage = null;
-			switch (docEntry.getKind()) {
-				case IClasspathEntry.CPE_SOURCE :
-					if (!bpentry.isMissing())
-						pathImage = fFolderImage;
-					else
-						pathImage = fMissingFolderImage;
-					break;
-
-				case IClasspathEntry.CPE_LIBRARY :
-					if (!bpentry.isMissing()) {
-						IResource resource = fRoot.findMember(path);
-						if (resource instanceof IFolder)
-							pathImage = fFolderImage;
-						else if (resource instanceof IFile)
-							pathImage = fJarIcon;
-						else
-							pathImage = fExtJarIcon;
-					} else
-						pathImage = fMissingJarImage;
-					break;
-
-				case IClasspathEntry.CPE_PROJECT :
-					if (!bpentry.isMissing())
-						pathImage = fProjectImage;
-					else
-						pathImage = fMissingProjectImage;
-					break;
-
-				case IClasspathEntry.CPE_VARIABLE :
-					if (!bpentry.isMissing())
-						pathImage = fVariableImage;
-					else
-						pathImage = fMissingVariableImage;
-					break;
-
-				case IClasspathEntry.CPE_CONTAINER:
-					if (!bpentry.isMissing())
-						pathImage = fLibraryImage;
-					else
-						pathImage = fMissingLibraryImage;
-					break;				
-					
-				case BeaninfoEntry.BIE_PLUGIN:
-					pathImage = fPluginImage;
-					break;
-					
-				default :
-					// probably a searchentry under beaninfo entry, no path icon to decorate.
-					break;
-			}
-
-			if (bpentry instanceof BPSearchListElement) {
-				SearchpathEntry se = (SearchpathEntry) docEntry;
-				BPSearchListElement bpse = (BPSearchListElement) bpentry;
-				if (se.getPackage() != null) {
-					if (pathImage != null) {
-						if (!bpse.isPackageMissing()) {
-							// Need to decorate with a package symbol.
-							imageIsNormal = false;
-							returnedImage = (Image) fPackagedImages.get(pathImage); // See if we've already created the image
-							if (returnedImage == null) {
-								OverlayComposite oc = new OverlayComposite(pathImage.getImageData());
-								oc.setRightExtension(fPackageImage.getImageData());
-								returnedImage = oc.createImage();
-								fPackagedImages.put(pathImage, returnedImage);
-							}
-						} else {
-							// Need to decorate with a missing package symbol.
-							imageIsNormal = false;
-							returnedImage = (Image) fMissingPackagedImages.get(pathImage); // See if we've already created the image
-							if (returnedImage == null) {
-								OverlayComposite oc = new OverlayComposite(pathImage.getImageData());
-								oc.setRightExtension(fMissingPackageImage.getImageData());
-								returnedImage = oc.createImage();
-								fMissingPackagedImages.put(pathImage, returnedImage);
-							}
-						}
-					}
-				}
-					
-				if (pathImage == null && returnedImage == null)
-					if (!bpse.isPackageMissing())
-						returnedImage = fPackageImage; // Just a package image
-					else
-						returnedImage = fMissingPackageImage;	// Just the missing package image.
-				else if (returnedImage == null)
-					returnedImage = pathImage;
-			} else {
-				if (pathImage != null) {
-					// It is a beaninfo entry, need to decorate with the bean.
-					imageIsNormal = false;
-					returnedImage = (Image) fBeanedImages.get(pathImage); // See if we've already created the image
-					if (returnedImage == null) {
-						OverlayComposite oc = new OverlayComposite(pathImage.getImageData());
-						oc.setRightExtension(fBeanImage.getImageData());
-						returnedImage = oc.createImage();
-						fBeanedImages.put(pathImage, returnedImage);
-					}
-				}
-				if (returnedImage == null)
-					returnedImage = fBeanImage; // Shouldn't occur.
-			}
-		}
-		
-		if (imageIsNormal && returnedImage != null) {
-			// We need to composite it with blank so that the result will be the same size
-			// as composited images. If this isn't done, the viewer will stretch the image
-			// to match the same size as the composited images and things will look aweful.
-			Image newReturned = (Image) fNormalImages.get(returnedImage);
-			if (newReturned == null) {
-				OverlayComposite oc = new OverlayComposite(returnedImage.getImageData());
-				oc.setRightExtension(fBlankImage.getImageData());
-				newReturned = oc.createImage();
-				fNormalImages.put(returnedImage, newReturned);
-			}
-			returnedImage = newReturned;
-		}
-		return returnedImage;
-	}
-
-	/*
-	 * @see IBaseLabelProvider#dispose()
-	 */
-	public void dispose() {
-		super.dispose();
-
-		fPluginImage.dispose();
-		fBeanImage.dispose();
-		fMissingPackageImage.dispose();
-		fBlankImage.dispose();
-		fMissingLibraryImage.dispose();
-		for (Iterator itr = fBeanedImages.values().iterator(); itr.hasNext();) {
-			((Image) itr.next()).dispose();
-		}
-		for (Iterator itr = fPackagedImages.values().iterator(); itr.hasNext();) {
-			((Image) itr.next()).dispose();
-		}
-		for (Iterator itr = fMissingPackagedImages.values().iterator(); itr.hasNext();) {
-			((Image) itr.next()).dispose();
-		}
-		for (Iterator itr = fNormalImages.values().iterator(); itr.hasNext();) {
-			((Image) itr.next()).dispose();
-		}		
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SearchpathOrderingWorkbookPage.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SearchpathOrderingWorkbookPage.java
deleted file mode 100644
index ab9fe47..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/SearchpathOrderingWorkbookPage.java
+++ /dev/null
@@ -1,326 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: SearchpathOrderingWorkbookPage.java,v $
- *  $Revision: 1.5 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.*;
-import java.util.List;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jface.viewers.*;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.*;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.layout.*;
-import org.eclipse.swt.widgets.*;
-
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
-
-public class SearchpathOrderingWorkbookPage implements IBuildSearchPage{
-
-	private Label label = null;
-	private Table table = null;
-	private Composite buttonBar = null;
-	private Button upButton = null;
-	private Button downButton = null;
-	private Label spacer1 = null;
-	private Button exportAllButton = null;
-	private Button unExportAllButton = null;
-	private IStatus status;
-	private boolean inUpdate;
-	private BeaninfoPathsBlock beaninfoPathsBlock;
-	private Composite top;
-	private CheckboxTableViewer tableViewer=null;
-	private SearchPathListLabelProvider labelProvider;
-
-	private List elements;
-	private List selected;
-	private List checked;
-
-	public SearchpathOrderingWorkbookPage(BeaninfoPathsBlock beaninfoPathsBlock) {
-		this.beaninfoPathsBlock = beaninfoPathsBlock;
-		this.status = StatusHelper.OK_STATUS;
-		this.labelProvider = new SearchPathListLabelProvider();
-		this.elements = new ArrayList();
-	}
-
-	public Control createControl(Composite parent){
-		top = new Composite(parent, SWT.NONE);
-		GridData gridData = new org.eclipse.swt.layout.GridData();
-		gridData.horizontalSpan = 2;
-		GridLayout gridLayout = new GridLayout();
-		gridLayout.numColumns = 2;
-		label = new Label(top, SWT.NONE);
-		label.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__searchpath_label);
-		label.setLayoutData(gridData);
-		createTable();
-		top.setLayout(gridLayout);
-		createButtonBar();
-		top.setSize(new Point(300, 200));
-		updateEnabledStates();
-		if(spacer1==null){
-			//TODO
-		}
-		return top;
-	}
-
-	/**
-	 * This method initializes table	
-	 *
-	 */
-	private void createTable() {
-		GridData gridData1 = new org.eclipse.swt.layout.GridData();
-		gridData1.horizontalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData1.grabExcessHorizontalSpace = true;
-		gridData1.grabExcessVerticalSpace = true;
-		gridData1.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		table = new Table(top, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CHECK | SWT.FULL_SELECTION);
-		table.setLayoutData(gridData1);
-		table.addSelectionListener(new SelectionListener(){
-			public void widgetSelected(SelectionEvent e) {
-				setSelection(BeaninfoPathsBlock.getSelectedList(tableViewer.getSelection()));
-				updateButtons();
-			}
-			public void widgetDefaultSelected(SelectionEvent e) {
-				widgetSelected(e);
-			}
-		});
-		tableViewer = new CheckboxTableViewer(table);
-		tableViewer.setContentProvider(new ArrayContentProvider());
-		tableViewer.setLabelProvider(labelProvider);
-		tableViewer.setInput(elements);
-		if(getSelection()!=null)
-			tableViewer.setSelection(new StructuredSelection(getSelection()));
-		if(checked!=null)
-			tableViewer.setCheckedElements(checked.toArray());
-		tableViewer.addCheckStateListener(new ICheckStateListener(){
-			public void checkStateChanged(CheckStateChangedEvent event) {
-				pageChanged();
-			}
-		});
-	}
-
-	/**
-	 * This method initializes composite	
-	 *
-	 */
-	private void createButtonBar() {
-		RowLayout rowLayout = new RowLayout();
-		rowLayout.type = org.eclipse.swt.SWT.VERTICAL;
-		rowLayout.fill = true;
-		GridData gridData2 = new org.eclipse.swt.layout.GridData();
-		gridData2.grabExcessVerticalSpace = true;
-		gridData2.verticalAlignment = org.eclipse.swt.layout.GridData.FILL;
-		gridData2.horizontalAlignment = org.eclipse.swt.layout.GridData.BEGINNING;
-		buttonBar = new Composite(top, SWT.NONE);
-		buttonBar.setLayoutData(gridData2);
-		buttonBar.setLayout(rowLayout);
-		upButton = new Button(buttonBar, SWT.NONE);
-		upButton.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__searchpath_up_button);
-		upButton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				Iterator selItr = getSelection().iterator();
-				while (selItr.hasNext()) {
-					Object element = selItr.next();
-					int oldIndex = elements.indexOf(element);
-					if(oldIndex>0){
-						elements.remove(element);
-						elements.add(--oldIndex, element);
-					}
-				}
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-		downButton = new Button(buttonBar, SWT.NONE);
-		downButton.setText(BeanInfoUIMessages.BeaninfoPathsBlock_UI__searchpath_down_button);
-		downButton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				Iterator selItr = getSelection().iterator();
-				while (selItr.hasNext()) {
-					Object element = selItr.next();
-					int oldIndex = elements.indexOf(element);
-					if(oldIndex<(elements.size()-1)){
-						elements.remove(element);
-						elements.add(++oldIndex, element);
-					}
-				}
-				tableViewer.refresh();
-				pageChanged();
-			}
-		});
-		spacer1 = new Label(buttonBar, SWT.NONE);
-		exportAllButton = new Button(buttonBar, SWT.NONE);
-		exportAllButton.setText(BeanInfoUIMessages.BeanInfoPathsBlock_ExportAll);
-		exportAllButton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				setCheckedElements(getElements());
-			}
-		});
-		unExportAllButton = new Button(buttonBar, SWT.NONE);
-		unExportAllButton.setText(BeanInfoUIMessages.BeanInfoPathsBlock_UnexportAll);
-		unExportAllButton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				setCheckedElements(null);
-			}
-		});
-	}
-
-	public List getElements() {
-		return new ArrayList(elements);
-	}
-	
-	public void setElements(List elements){
-		this.elements.clear();
-		this.elements.addAll(elements);
-		if(tableViewer!=null){
-			tableViewer.refresh();
-			updateButtons();
-		}
-	}
-
-	public void init(IJavaProject javaProject) {
-		labelProvider.setJavaProject(javaProject);
-	}
-
-	public void setCheckedElements(List exportedEntries) {
-		this.checked = exportedEntries;
-		if(tableViewer!=null && !table.isDisposed()){
-			tableViewer.setCheckedElements(checked!=null ? checked.toArray() : new Object[0]);
-			updateButtons();
-		}
-		pageChanged();
-	}
-
-	public boolean isChecked(BPListElement currElement) {
-		if(tableViewer!=null){
-			return tableViewer.getChecked(currElement);
-		}
-		return checked!=null && checked.contains(currElement);
-	}
-
-	public List getSelection() {
-		return selected;
-	}
-
-	public void setSelection(List selection) {
-		this.selected = selection;
-		if(tableViewer!=null && !table.isDisposed()){
-			tableViewer.setSelection(new StructuredSelection(selection!=null?selection : new ArrayList()));
-			updateButtons();
-		}
-	}
-	
-	public void pageChanged(){
-		updateSearchPathStatus();
-		beaninfoPathsBlock.doStatusLineUpdate();
-	}
-	
-	protected void updateButtons(){
-		upButton.setEnabled(canMoveUp() && beaninfoPathsBlock.isBeaninfoEnabled());
-		downButton.setEnabled(canMoveDown() && beaninfoPathsBlock.isBeaninfoEnabled());
-		exportAllButton.setEnabled(elements!=null && beaninfoPathsBlock.isBeaninfoEnabled());
-		unExportAllButton.setEnabled(elements!=null && beaninfoPathsBlock.isBeaninfoEnabled());
-	}
-	
-	private boolean canMoveDown() {
-		int[] indc= table.getSelectionIndices();
-		int k= elements.size() - 1;
-		for (int i= indc.length - 1; i >= 0 ; i--, k--) {
-			if (indc[i] != k) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private boolean canMoveUp() {
-		int[] indc= table.getSelectionIndices();
-		for (int i= 0; i < indc.length; i++) {
-			if (indc[i] != i) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Validates the search path.
-	 */
-	private void updateSearchPathStatus() {
-		if (inUpdate)
-			return;
-		try {
-			inUpdate = true;
-
-			status = StatusHelper.OK_STATUS;
-
-			List elements = getElements();
-
-			boolean entryMissing = false;
-
-			// Because of bug in setcheckedWithoutUpdate, which sets to true no matter what the state is, we need
-			// to accumulate the checked elements and re-set them again after this so that they will be correct.	
-			ArrayList exported = new ArrayList();
-
-			for (Iterator entries = elements.iterator(); entries.hasNext();) {
-				BPListElement currElement = (BPListElement) entries.next();
-
-				boolean isChecked = isChecked(currElement);
-				if (currElement.canExportBeChanged()) {
-					if (isChecked)
-						exported.add(currElement);
-					currElement.setExported(isChecked);
-				} else {
-					//				fSearchOrder.setCheckedWithoutUpdate(currElement, currElement.isExported());
-					if (currElement.isExported())
-						exported.add(currElement);
-				}
-
-				entryMissing = entryMissing || currElement.isMissing();
-			}
-
-			// Now reset the checked states, due to bug
-			setCheckedElements(exported);
-
-			if (entryMissing) {
-				status = new Status(IStatus.WARNING, 
-						JEMUIPlugin.getPlugin().getBundle().getSymbolicName(),
-						IStatus.WARNING,
-						BeanInfoUIMessages.BeaninfoPathsBlock_UI__warning_EntryMissing,
-						null); 
-			}
-		} finally {
-			inUpdate = false;
-		}
-	}
-
-	public IStatus getStatus() {
-		return status;
-	}
-
-	public void setBeaninfoEnabled(boolean enable) {
-		if(top!=null && !top.isDisposed())
-			updateEnabledStates();
-	}
-
-	private void updateEnabledStates() {
-		updateButtons();
-		table.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-		label.setEnabled(beaninfoPathsBlock.isBeaninfoEnabled());
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/StatusHelper.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/StatusHelper.java
deleted file mode 100644
index 2680c22..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/StatusHelper.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: StatusHelper.java,v $
- *  $Revision: 1.1 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
- 
-
-public class StatusHelper {
-
-	public static final IStatus OK_STATUS = createStatus(IStatus.OK, ""); //$NON-NLS-1$
-	public static final IStatus ERROR_STATUS = createStatus(IStatus.ERROR, ""); //$NON-NLS-1$
-	
-	/**
-	 * Creates a status with the provided severity and message
-	 * 
-	 * @param severity
-	 * @param message
-	 * @return
-	 * 
-	 * @since 1.2.0
-	 */
-	public static IStatus createStatus(int severity, String message){
-		return new Status(severity, 
-				JEMUIPlugin.getPlugin().getBundle().getSymbolicName(), 
-				severity, message, null);
-	}
-
-	/**
-	 * Finds the most severe status from a array of stati.
-	 * An error is more severe than a warning, and a warning is more severe
-	 * than ok.
-	 * 
-	 * @param status
-	 * @return
-	 * 
-	 * @since 1.2.0
-	 */
-	public static IStatus getMostSevere(IStatus[] status) {
-		IStatus max= null;
-		for (int i= 0; i < status.length; i++) {
-			IStatus curr= status[i];
-			if (curr.matches(IStatus.ERROR)) {
-				return curr;
-			}
-			if (max == null || curr.getSeverity() > max.getSeverity()) {
-				max= curr;
-			}
-		}
-		return max;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/TypedElementSelectionValidator.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/TypedElementSelectionValidator.java
deleted file mode 100644
index d2de2f6..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/TypedElementSelectionValidator.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: TypedElementSelectionValidator.java,v $
- *  $Revision: 1.1 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.Collection;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jface.util.Assert;
-import org.eclipse.ui.dialogs.ISelectionStatusValidator;
- 
-
-public class TypedElementSelectionValidator implements ISelectionStatusValidator {
-
-	private IStatus fgErrorStatus= StatusHelper.ERROR_STATUS; 
-	private IStatus fgOKStatus= StatusHelper.OK_STATUS;
-
-	private Class[] fAcceptedTypes;
-	private boolean fAllowMultipleSelection;
-	private Collection fRejectedElements;
-	
-	/**
-	 * @param acceptedTypes The types accepted by the validator
-	 * @param allowMultipleSelection If set to <code>true</code>, the validator
-	 * allows multiple selection.
-	 */
-	public TypedElementSelectionValidator(Class[] acceptedTypes, boolean allowMultipleSelection) {
-		this(acceptedTypes, allowMultipleSelection, null);
-	}
-	
-	/**
-	 * @param acceptedTypes The types accepted by the validator
-	 * @param allowMultipleSelection If set to <code>true</code>, the validator
-	 * allows multiple selection.
-	 * @param rejectedElements A list of elements that are not accepted
-	 */
-	public TypedElementSelectionValidator(Class[] acceptedTypes, boolean allowMultipleSelection, Collection rejectedElements) {
-		Assert.isNotNull(acceptedTypes);
-		fAcceptedTypes= acceptedTypes;
-		fAllowMultipleSelection= allowMultipleSelection;
-		fRejectedElements= rejectedElements;
-	}	
-	
-	/*
-	 * @see org.eclipse.ui.dialogs.ISelectionValidator#isValid(java.lang.Object)
-	 */
-	public IStatus validate(Object[] elements) {
-		if (isValid(elements)) {
-			return fgOKStatus;
-		}
-		return fgErrorStatus;
-	}	
-
-	private boolean isOfAcceptedType(Object o) {
-		for (int i= 0; i < fAcceptedTypes.length; i++) {
-			if (fAcceptedTypes[i].isInstance(o)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	private boolean isRejectedElement(Object elem) {
-		return (fRejectedElements != null) && fRejectedElements.contains(elem);
-	}
-	
-	protected boolean isSelectedValid(Object elem) {
-		return true;
-	}
-	
-	private boolean isValid(Object[] selection) {
-		if (selection.length == 0) {
-			return false;
-		}
-		
-		if (!fAllowMultipleSelection && selection.length != 1) {
-			return false;
-		}
-		
-		for (int i= 0; i < selection.length; i++) {
-			Object o= selection[i];	
-			if (!isOfAcceptedType(o) || isRejectedElement(o) || !isSelectedValid(o)) {
-				return false;
-			}
-		}
-		return true;
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/TypedViewerFilter.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/TypedViewerFilter.java
deleted file mode 100644
index d14f6d0..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/TypedViewerFilter.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: TypedViewerFilter.java,v $
- *  $Revision: 1.1 $  $Date: 2005/10/03 23:06:42 $ 
- */
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerFilter;
- 
-
-public class TypedViewerFilter extends ViewerFilter {
-	private Class[] acceptedClasses;
-	private Object[] rejectedFragments;
-	
-	public TypedViewerFilter(Class[] acceptedClasses, Object[] rejectedFragments) {
-		this.acceptedClasses = acceptedClasses;
-		this.rejectedFragments = rejectedFragments;
-	}
-
-	public boolean select(Viewer viewer, Object parentElement, Object element) {
-		if (rejectedFragments != null) {
-			for (int i= 0; i < rejectedFragments.length; i++) {
-				if (element.equals(rejectedFragments[i])) {
-					return false;
-				}
-			}
-		}
-		for (int i= 0; i < acceptedClasses.length; i++) {
-			if (acceptedClasses[i].isInstance(element)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/VariableSelectionBlock.java b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/VariableSelectionBlock.java
deleted file mode 100644
index 341ac53..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/VariableSelectionBlock.java
+++ /dev/null
@@ -1,310 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.beaninfo.ui;
-
-import java.util.List;
-
-import org.eclipse.core.runtime.*;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.ui.wizards.BuildPathDialogAccess;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.CLabel;
-import org.eclipse.swt.events.*;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.*;
-import org.eclipse.ui.PlatformUI;
-/*
- *  $RCSfile: VariableSelectionBlock.java,v $
- *  $Revision: 1.7 $  $Date: 2005/10/03 23:06:42 $ 
- */
-
-public class VariableSelectionBlock {
-	
-	
-	private List fExistingPaths;
-	
-	private Label variableFieldLabel;
-	private Text variableFieldText;
-	private Button variableFieldButton;
-	private String variableFieldTextContent;
-	
-	private Label extensionFieldLabel;
-	private Text extensionFieldText;
-	private Button extensionFieldButton;
-	private String extensionFieldTextContent;
-	
-	private CLabel fFullPath;
-	
-	private IStatus fVariableStatus;
-	private IStatus fExistsStatus;
-	private IStatus fExtensionStatus;
-	
-	private String fVariable;
-	private IStatusChangeListener fContext;
-	
-	private boolean fIsEmptyAllowed;
-	
-	/**
-	 * Constructor for VariableSelectionBlock
-	 */
-	public VariableSelectionBlock(IStatusChangeListener context, List existingPaths, IPath varPath, String lastVarSelection, boolean emptyAllowed) {	
-		fContext= context;
-		fExistingPaths= existingPaths;
-		fIsEmptyAllowed= emptyAllowed;
-		fExistsStatus= StatusHelper.OK_STATUS;
-		
-		//VariableSelectionAdapter adapter= new VariableSelectionAdapter();
-
-		if (varPath != null) {
-			variableFieldTextContent = varPath.segment(0);
-			extensionFieldTextContent = varPath.removeFirstSegments(1).toString();
-		} else {
-			variableFieldTextContent = ""; //$NON-NLS-1$
-			extensionFieldTextContent = ""; //$NON-NLS-1$
-		}
-		updateFullTextField();
-		fVariableStatus= variableUpdated();
-		fExtensionStatus=extensionUpdated();
-	}
-	
-	public IPath getVariablePath() {
-		if (fVariable != null) {
-			return new Path(fVariable).append(extensionFieldTextContent);
-		}
-		return null;
-	}
-	
-	public IPath getResolvedPath() {
-		if (fVariable != null) {
-			IPath entryPath= JavaCore.getClasspathVariable(fVariable);
-			if (entryPath != null) {
-				return entryPath.append(extensionFieldTextContent);
-			}
-		}
-		return null;
-	}	
-			
-	public void setFocus(Display display) {
-		display.asyncExec(new Runnable(){
-			public void run() {
-				variableFieldText.setFocus();
-			}
-		});
-	}
-
-	
-	public Control createControl(Composite parent) {
-		Composite inner= new Composite(parent, SWT.NONE);
-		inner.setLayout(new GridLayout(3, false));
-		GridData gd = new GridData(GridData.FILL_BOTH);
-		inner.setLayoutData(gd);
-		
-		variableFieldLabel = new Label(inner, SWT.NONE);
-		variableFieldLabel.setText(BeanInfoUIMessages.VariableSelectionBlock_variable_label);
-		variableFieldLabel.setLayoutData(new GridData());
-		variableFieldText = new Text(inner, SWT.BORDER|SWT.SINGLE);
-		variableFieldText.setText(variableFieldTextContent);
-		gd = new GridData(GridData.FILL_HORIZONTAL);
-		gd.widthHint = 200;
-		variableFieldText.setLayoutData(gd);
-		variableFieldText.addModifyListener(new ModifyListener(){
-			public void modifyText(ModifyEvent e) {
-				variableFieldTextContent = variableFieldText.getText();
-				fVariableStatus = variableUpdated();
-				fExistsStatus= getExistsStatus();
-				updateFullTextField();
-				fContext.statusChanged(StatusHelper.getMostSevere(new IStatus[] { fVariableStatus, fExtensionStatus, fExistsStatus }));
-			}
-		});
-		variableFieldButton = new Button(inner, SWT.PUSH);
-		variableFieldButton.setText(BeanInfoUIMessages.VariableSelectionBlock_variable_button);
-		variableFieldButton.setLayoutData(new GridData());
-		variableFieldButton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				String variable= chooseVariable();
-				if (variable != null) {
-					variableFieldText.setText(variable);
-				}
-			}
-		});
-		
-		extensionFieldLabel = new Label(inner, SWT.NONE);
-		extensionFieldLabel.setText(BeanInfoUIMessages.VariableSelectionBlock_extension_label);
-		extensionFieldLabel.setLayoutData(new GridData());
-		extensionFieldText = new Text(inner, SWT.BORDER|SWT.SINGLE);
-		extensionFieldText.setText(variableFieldTextContent);
-		extensionFieldText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-		extensionFieldText.addModifyListener(new ModifyListener(){
-			public void modifyText(ModifyEvent e) {
-				extensionFieldTextContent = extensionFieldText.getText();
-				fExtensionStatus= extensionUpdated();
-				fExistsStatus= getExistsStatus();
-				updateFullTextField();
-				fContext.statusChanged(StatusHelper.getMostSevere(new IStatus[] { fVariableStatus, fExtensionStatus, fExistsStatus }));
-			}
-		});
-		extensionFieldButton = new Button(inner, SWT.PUSH);
-		extensionFieldButton.setText(BeanInfoUIMessages.VariableSelectionBlock_extension_button);
-		extensionFieldButton.setLayoutData(new GridData());
-		extensionFieldButton.setEnabled(fVariable!=null);
-		extensionFieldButton.addSelectionListener(new SelectionAdapter(){
-			public void widgetSelected(SelectionEvent e) {
-				IPath filePath= chooseExtJar();
-				if (filePath != null) {
-					extensionFieldText.setText(filePath.toString());
-				}
-			}
-		});
-		
-		Label label= new Label(inner, SWT.LEFT);
-		label.setLayoutData(new GridData());
-		label.setText(BeanInfoUIMessages.VariableSelectionBlock_fullpath_label); 
-		
-		fFullPath= new CLabel(inner, SWT.NONE);
-		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
-		gd.horizontalSpan=2;
-		fFullPath.setLayoutData(gd);
-		
-		updateFullTextField();
-		
-		setFocus(parent.getDisplay());
-		
-		return inner;
-	}
-
-	private IStatus variableUpdated() {
-		fVariable= null;
-		
-		IStatus status= StatusHelper.OK_STATUS;
-		
-		String name = variableFieldTextContent;
-		if (name.length() == 0) {
-			if (!fIsEmptyAllowed) {
-				status = StatusHelper.createStatus(IStatus.ERROR, BeanInfoUIMessages.VariableSelectionBlock_error_entername_ERROR_); 
-			} else {
-				fVariable= ""; //$NON-NLS-1$
-			}
-		} else if (JavaCore.getClasspathVariable(name) == null) {
-			status = StatusHelper.createStatus(IStatus.ERROR, BeanInfoUIMessages.VariableSelectionBlock_error_namenotexists_ERROR_); 
-		} else {
-			fVariable= name;
-		}
-		if(extensionFieldButton!=null)
-			extensionFieldButton.setEnabled(fVariable != null);
-		return status;
-	}
-	
-	private IStatus extensionUpdated() {
-		IStatus status= StatusHelper.OK_STATUS;
-		String extension = extensionFieldTextContent;
-		if (extension.length() > 0 && !Path.ROOT.isValidPath(extension)) {
-			status = StatusHelper.createStatus(IStatus.ERROR, BeanInfoUIMessages.VariableSelectionBlock_error_invalidextension_ERROR_); 
-		}
-		return status;
-	}
-		
-	private IStatus getExistsStatus() {
-		IStatus status = StatusHelper.OK_STATUS;
-		IPath path= getResolvedPath();
-		if (path != null) {
-			if (findPath(path)) {
-				status = StatusHelper.createStatus(IStatus.ERROR,  BeanInfoUIMessages.VariableSelectionBlock_error_pathexists_ERROR_); 
-			} else if (!path.toFile().isFile()) {
-				status = StatusHelper.createStatus(IStatus.WARNING,  BeanInfoUIMessages.VariableSelectionBlock_warning_pathnotexists_WARN_); 
-			}
-		} else {
-			status = StatusHelper.createStatus(IStatus.WARNING,  BeanInfoUIMessages.VariableSelectionBlock_warning_pathnotexists_WARN_); 
-		}
-		return status;
-	}
-	
-	private boolean findPath(IPath path) {
-		for (int i= fExistingPaths.size() -1; i >=0; i--) {
-			IPath curr= (IPath) fExistingPaths.get(i);
-			if (curr.equals(path)) {
-				return true;
-			}
-		}
-		return false;
-	}	
-
-	private void updateFullTextField() {
-		if (fFullPath != null && !fFullPath.isDisposed()) {
-			IPath resolvedPath= getResolvedPath();
-			if (resolvedPath != null) {
-				fFullPath.setText(resolvedPath.toOSString());
-			} else {
-				fFullPath.setText(""); //$NON-NLS-1$
-			}
-		}
-	}
-	
-	private Shell getShell() {
-		if (fFullPath != null) {
-			return fFullPath.getShell();
-		}
-		return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
-	}	
-	
-	public static boolean isArchivePath(IPath path){
-		final String[] archiveExtensions = {"jar", "zip"};
-		String ext= path.getFileExtension();
-		if (ext != null && ext.length() != 0) {
-			for (int i= 0; i < archiveExtensions.length; i++) {
-				if (ext.equalsIgnoreCase(archiveExtensions[i])) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-	
-	private IPath chooseExtJar() {
-		String lastUsedPath= ""; //$NON-NLS-1$
-		IPath entryPath= getResolvedPath();
-		if (entryPath != null) {
-			if (isArchivePath(entryPath)) {
-				lastUsedPath= entryPath.removeLastSegments(1).toOSString();
-			} else {
-				lastUsedPath= entryPath.toOSString();
-			}
-		}
-		
-		FileDialog dialog= new FileDialog(getShell(), SWT.SINGLE);
-		dialog.setFilterExtensions(new String[] {"*.jar;*.zip"}); //$NON-NLS-1$
-		dialog.setFilterPath(lastUsedPath);
-		dialog.setText(BeanInfoUIMessages.VariableSelectionBlock_ExtJarDialog_title); 
-		String res= dialog.open();
-		if (res == null) {
-			return null;
-		}
-		IPath resPath= new Path(res).makeAbsolute();
-		IPath varPath= JavaCore.getClasspathVariable(fVariable);
-		
-		if (!varPath.isPrefixOf(resPath)) {
-			return new Path(resPath.lastSegment());
-		} else {
-			return resPath.removeFirstSegments(varPath.segmentCount()).setDevice(null);
-		}
-	}
-
-	private String chooseVariable() {
-		IPath[] varPaths = BuildPathDialogAccess.chooseVariableEntries(variableFieldButton.getShell(), new IPath[0]);
-		String variable = null;
-		if(varPaths!=null && varPaths.length>0){
-			variable = varPaths[0].toString();
-		}
-		return variable;
-	}
-		
-
-}
diff --git a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/messages.properties b/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/messages.properties
deleted file mode 100644
index e0573eb..0000000
--- a/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/messages.properties
+++ /dev/null
@@ -1,108 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.ui/beaninfoui/org/eclipse/jem/internal/beaninfo/ui/Attic/messages.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $
-#
-
-
-SearchPathDialog_ChoosePackages                         = &Choose Packages
-SearchPathDialog_Remove                                 = &Remove
-SearchPathDialog_Desc_Label                             = &Modify search path of packages within this BeanInfo classes JAR/folder
-SearchPathDialog_ModifySearchPaths                      = Modify Search Paths - {0}
-SearchPathDialog_NotEditable_INFO_                      = IWAV0075I Plugin type BeanInfo classes locations are not editable
-SearchPathDialog_PackagePresent_INFO_                   = IWAV0076I Package already in the search path
-SearchPathDialog_InputDialog_Title                      = Package
-SearchPathDialog_InputDialog_Message                    = &Enter a package:
-BeanInfoPathsBlock_ExportAll                            = E&xport all
-BeanInfoPathsBlock_UnexportAll                          = U&nexport all
-BeanInfoPathsBlock_Page_Tab_Packages                    = &Packages
-BeanInfoPathsBlock_Page_Tab_Classes                     = &BeanInfo classes
-BeanInfosWorkbookPage_AddFolders                        = &Add Folders
-BeanInfosWorkbookPage_AddJARs                           = Add &JARs
-BeanInfosWorkbookPage_AddExternalJAR                    = Add E&xternal JARs
-BeanInfosWorkbookPage_AddVariable                       = Add &Variable
-BeanInfosWorkbookPage_AddProjects                       = Add Projec&ts
-BeanInfosWorkbookPage_ModifyPaths                       = &Modify Paths
-BeanInfosWorkbookPage_Remove                            = &Remove
-BeanInfosWorkbookPage_List_Text                         = &Choose locations of BeanInfo classes (BeanInfo classes locations not in current project)
-BeanInfosWorkbookPage_SelectionDialog_Classes_Title     = BeanInfo Class Folders Selection
-BeanInfosWorkbookPage_SelectionDialog_JARs_Title        = JAR Selection
-BeanInfosWorkbookPage_SelectionDialog_JARs_Message      = &Choose JARs to be added as BeanInfo classes JARs
-BeanInfosWorkbookPage_SelectionDialog_ExtJARs_Text      = JAR Selection
-BeanInfosWorkbookPage_SelectionDialog_Projects_Title    = BeanInfo Projects Selection
-BeanInfosWorkbookPage_SelectionDialog_Classes_Prompt    = &Choose folders to be added as BeanInfo classes folders.
-BeanInfosWorkbookPage_SelectionDialog_Projects_Prompt   = &Choose projects to be added as BeanInfo projects.
-PackagesWorkbook_ChoosePackages                         = &Choose packages
-PackagesWorkbook_ChooseDefinedPaths                     = Choose &defined paths
-PackagesWorkbook_Remove                                 = &Remove
-PackagesWorkbook_LabelText                              = Choose BeanInfo &packages from the class path
-PackagesWorkbook_SelectionDialog_DefinedPaths_Title     = Choose Defined Paths
-PackagesWorkbook_SelectionDialog_DefinedPaths_Message   = Choose the pre-defined paths to add to the search path
-LabelProvider_Library_Folder                            = {0} (class folder)
-LabelProvider_Library__PathLastSegment_PathRelative_    = {0} - {1}
-LabelProvider_Library__PathLastSegment_PathExceptLast_  = {0} - {1}
-LabelProvider_Variable__name_PathOSString_              = {0} - {1}
-LabelProvider__packageName_Path_                        = {0}: {1}
-
-VariableSelectionBlock_variable_label                   = &Variable Name:
-VariableSelectionBlock_variable_button                  = &Browse...
-VariableSelectionBlock_extension_label                  = Path E&xtension:
-VariableSelectionBlock_extension_button                 = Bro&wse...
-VariableSelectionBlock_fullpath_label                   = Resolved Path:
-
-VariableSelectionBlock_error_entername_ERROR_           = IWAV0077E Variable name must be entered.
-VariableSelectionBlock_error_namenotexists_ERROR_       = IWAV0078E Variable does not exist.
-VariableSelectionBlock_error_pathexists_ERROR_          = IWAV0079E Class path entry already exists.
-VariableSelectionBlock_error_invalidextension_ERROR_    = IWAV0080E Extension is not a valid path.
-
-VariableSelectionBlock_warning_pathnotexists_WARN_      = IWAV0081W Resolved path is not an existing JAR file.
-
-VariableSelectionBlock_ExtJarDialog_title               = JAR Selection
-
-
-
-
-#
-# Properties for the com.ibm.etools.beaninfo.ui plugin
-#
-
-# This shows up as the title of a message dialog
-Beaninfo_UI__errortitle                                 = Error
-
-Beaninfo_UI__error                                      = Error while setting BeanInfo configuration.
-
-BeaninfoPropertiesPage_INFO__nojavaproject              = IWAV0019I BeanInfo is only applicable to Java projects.
-BeaninfoPropertiesPage_INFO__closedproject              = IWAV0020I BeanInfo is not available for a closed project.
-
-# This is a checkbox on a preference page. The label is to indicate whether introspection is enabled to run or not.
-BeaninfoPathsBlock_UI__enablebeaninfo                   = &Enable BeanInfo Introspection on this Project
-
-# This is a header line for a page of preferences.
-BeaninfoPathsBlock_UI__searchpath_label                 = Build BeanInfo &search path order and exported entries:\n(Exported entries are contributed to dependent projects)
-BeaninfoPathsBlock_UI__searchpath_up_button             = &Up
-BeaninfoPathsBlock_UI__searchpath_down_button           = &Down
-BeaninfoPathsBlock_UI__searchpath_remove_button         = &Remove
-BeaninfoPathsBlock_UI__serachpath_tab_order             = &Order and Export
-
-BeaninfoPathsBlock_UI__warning_EntryMissing             = Project class path entries, or BeanInfo class files are missing.
-
-# {0} will be the package name, e.g. java.lang
-BeaninfoPathsBlock_WARN__searchpath_missing_path_format = IWAV0021W {0} - Package path not found.
-
-# This is a message on a progress dialog.
-BeaninfoPathsBlock_UI__searchpath_operationdescription  = Setting BeanInfo search paths...
-
-BeaninfoPathsBlock_UI__addsearchpath_title              = Select Packages
-BeaninfoPathsBlock_UI__addsearchpath_description        = &Select packages to add to search path:
-
-BeaninfoPathsBlock_UI__warning_EntryMissing             = Project class path entries, or BeanInfo class files are missing.
-BeaninfoPathsBlock_UI__searchpath_add_button            = Add Package...
diff --git a/plugins/org.eclipse.jem.ui/build.properties b/plugins/org.eclipse.jem.ui/build.properties
deleted file mode 100644
index b96ba1e..0000000
--- a/plugins/org.eclipse.jem.ui/build.properties
+++ /dev/null
@@ -1,22 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = plugin.xml,\
-               plugin.properties,\
-               icons/,\
-               about.html,\
-               .options,\
-               META-INF/,\
-               .
-src.includes = about.html
-output.. = bin/
-source.. = ui/,\
-           beaninfoui/
-jars.compile.order = .
diff --git a/plugins/org.eclipse.jem.ui/icons/blank.gif b/plugins/org.eclipse.jem.ui/icons/blank.gif
deleted file mode 100644
index 21f9d02..0000000
--- a/plugins/org.eclipse.jem.ui/icons/blank.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/cp_order_obj.gif b/plugins/org.eclipse.jem.ui/icons/cp_order_obj.gif
deleted file mode 100644
index b2fa4ce..0000000
--- a/plugins/org.eclipse.jem.ui/icons/cp_order_obj.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/full/ctool16/run_exc.gif b/plugins/org.eclipse.jem.ui/icons/full/ctool16/run_exc.gif
deleted file mode 100644
index 57f4102..0000000
--- a/plugins/org.eclipse.jem.ui/icons/full/ctool16/run_exc.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/full/obj16/file_obj.gif b/plugins/org.eclipse.jem.ui/icons/full/obj16/file_obj.gif
deleted file mode 100644
index 061161a..0000000
--- a/plugins/org.eclipse.jem.ui/icons/full/obj16/file_obj.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/full/wizban/run_wiz.gif b/plugins/org.eclipse.jem.ui/icons/full/wizban/run_wiz.gif
deleted file mode 100644
index e3bd462..0000000
--- a/plugins/org.eclipse.jem.ui/icons/full/wizban/run_wiz.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/javabean.gif b/plugins/org.eclipse.jem.ui/icons/javabean.gif
deleted file mode 100644
index 1885261..0000000
--- a/plugins/org.eclipse.jem.ui/icons/javabean.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/package_obj_missing.gif b/plugins/org.eclipse.jem.ui/icons/package_obj_missing.gif
deleted file mode 100644
index 78d7e20..0000000
--- a/plugins/org.eclipse.jem.ui/icons/package_obj_missing.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/icons/plugin_obj.gif b/plugins/org.eclipse.jem.ui/icons/plugin_obj.gif
deleted file mode 100644
index 8493df4..0000000
--- a/plugins/org.eclipse.jem.ui/icons/plugin_obj.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem.ui/plugin.properties b/plugins/org.eclipse.jem.ui/plugin.properties
deleted file mode 100644
index 415fb5e..0000000
--- a/plugins/org.eclipse.jem.ui/plugin.properties
+++ /dev/null
@@ -1,33 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.ui/Attic/plugin.properties,v $
-# $Revision: 1.4 $  $Date: 2005/08/24 21:07:12 $
-#
-
-
-pluginName=Java EMF Model UI
-providerName = Eclipse.org
-
-proxyLaunchGroup.label=Proxy
-
-ActionSet.proxyTools=Proxy Tools
-ActionSet.proxyTools.Description=Actions for working with Proxy and Proxy Launchers.
-Action.proxyLaunch=Proxy...
-Action.proxyLaunchTip=Proxy Launch Manager
-Action.selectDefault=Select Default Proxy Configuration...
-Action.selectDefaultTip=Select default for {0}.
-Menu.run=&Run
-
-Editors.OverrideEditor = Override Editor
-
-# This is the title of the Properties page for setting properties of BeanInfo paths.
-BeaninfoPath_Title_UI_ = BeanInfo Path
diff --git a/plugins/org.eclipse.jem.ui/plugin.xml b/plugins/org.eclipse.jem.ui/plugin.xml
deleted file mode 100644
index 4c54836..0000000
--- a/plugins/org.eclipse.jem.ui/plugin.xml
+++ /dev/null
@@ -1,134 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-
-     <extension
-         point="org.eclipse.debug.ui.launchGroups">
-      <launchGroup
-            label="%proxyLaunchGroup.label"
-            bannerImage="icons/full/wizban/run_wiz.gif"
-            category="org.eclipse.jem.proxy"
-            image="icons/full/ctool16/run_exc.gif"
-            mode="run"
-            id="org.eclipse.jem.proxy">
-      </launchGroup>
-   </extension>
-   <extension
-         point="org.eclipse.debug.ui.launchConfigurationTypeImages">
-      <launchConfigurationTypeImage
-            icon="icons/full/ctool16/run_exc.gif"
-            configTypeID="org.eclipse.jem.proxy.LocalProxyLaunchConfigurationType"
-            id="org.eclipse.jem.proxy.launchConfigurationTypeImage.localProxy">
-      </launchConfigurationTypeImage>
-   </extension>
-   <extension
-         point="org.eclipse.debug.ui.launchConfigurationTabGroups">
-      <launchConfigurationTabGroup
-            type="org.eclipse.jem.proxy.LocalProxyLaunchConfigurationType"
-            class="org.eclipse.jem.internal.ui.proxy.remote.LocalLaunchTabGroup"
-            id="org.eclipse.jem.ui.remote.LocalLaunchTabGroup1">
-      </launchConfigurationTabGroup>
-   </extension>
-   <extension
-         point="org.eclipse.ui.actionSets">
-      <actionSet
-            label="%ActionSet.proxyTools"
-            description="%ActionSet.proxyTools.Description"
-            id="org.eclipse.jem.ui.ProxyToolsSet">
-         <menu
-               label="%Menu.run"
-               path="additions"
-               id="org.eclipse.ui.run">
-         </menu>
-         <action
-               class="org.eclipse.jem.internal.ui.proxy.ProxyLaunchToolbarDelegate"
-               icon="icons/full/ctool16/run_exc.gif"
-               id="org.eclipse.jem.ui.proxy.ProxyLaunchToolbarDelegateAction"
-               label="%Action.proxyLaunch"
-               style="pulldown"
-               toolbarPath="org.eclipse.debug.ui.launchActionSet/proxyLaunch"
-               tooltip="%Action.proxyLaunchTip">
-         </action>
-         <action
-               label="%Action.selectDefault"
-               class="org.eclipse.jem.internal.ui.proxy.SelectDefaultConfigurationActionDelegate"
-               menubarPath="org.eclipse.ui.run/"
-               enablesFor="1"
-               id="org.eclipse.jem.ui.proxy.SelectDefaultMenuDelegateAction">
-            <enablement>
-               <or>
-                  <objectClass
-                        name="org.eclipse.core.resources.IProject">
-                  </objectClass>
-                  <objectClass
-                        name="org.eclipse.jdt.core.IJavaProject">
-                  </objectClass>
-               </or>
-            </enablement>
-         </action>
-         <action
-               label="%Action.proxyLaunch"
-               icon="icons/full/ctool16/run_exc.gif"
-               tooltip="%Action.proxyLaunchTip"
-               class="org.eclipse.jem.internal.ui.proxy.ProxyLaunchMenuDelegate"
-               menubarPath="org.eclipse.ui.run/"
-               id="org.eclipse.jem.ui.proxy.ProxyLaunchMenuDelegateAction">
-         </action>
-      </actionSet>
-   </extension>
-   <extension
-         point="org.eclipse.ui.popupMenus">
-      <objectContribution
-            adaptable="true"
-            objectClass="org.eclipse.core.resources.IProject"
-            id="org.eclipse.jem.ui.select.default.objectcontibution">
-         <action
-               label="%Action.selectDefault"
-               class="org.eclipse.jem.internal.ui.proxy.SelectDefaultConfigurationActionDelegate"
-               enablesFor="1"
-               id="org.eclipse.jem.ui.select.object.action">
-         </action>
-         <visibility>
-            <objectState
-                  name="persistentProperty"
-                  value="org.eclipse.jem.proxy.proxyLaunchConfiguration">
-            </objectState>
-         </visibility>
-      </objectContribution>
-   </extension>
-   <extension
-         point="org.eclipse.ui.propertyPages">
-      <page
-            objectClass="org.eclipse.core.resources.IProject"
-            name="%BeaninfoPath_Title_UI_"
-            class="org.eclipse.jem.internal.beaninfo.ui.BeaninfosPropertyPage"
-            id="BeaninfoPropertiesPage">
-         <filter
-               name="nature"
-               value="org.eclipse.jdt.core.javanature">
-         </filter>
-      </page>
-      <page
-            objectClass="org.eclipse.jdt.core.IJavaProject"
-            name="%BeaninfoPath_Title_UI_"
-            class="org.eclipse.jem.internal.beaninfo.ui.BeaninfosPropertyPage"
-            id="BeaninfoPropertiesPage">
-         <filter
-               name="nature"
-               value="org.eclipse.jdt.core.javanature">
-         </filter>
-      </page>
-   </extension>
-   <extension
-         point="org.eclipse.ui.editors">
-      <editor
-            name="%Editors.OverrideEditor"
-            extensions="override"
-            icon="icons/full/obj16/file_obj.gif"
-            class="org.eclipse.ui.editors/org.eclipse.ui.editors.text.TextEditor"
-            contributorClass="org.eclipse.ui.editors/org.eclipse.ui.editors.text.TextEditorActionContributor"
-            id="org.eclipse.jem.beaninfo.OverrideEditor">
-      </editor>
-   </extension>
-
-</plugin>
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/core/JEMUIPlugin.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/core/JEMUIPlugin.java
deleted file mode 100644
index 13fccac..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/core/JEMUIPlugin.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JEMUIPlugin.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $ 
- */
-package org.eclipse.jem.internal.ui.core;
-
-
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jem.util.logger.proxyrender.EclipseLogger;
-
- 
-/**
- * 
- * @since 1.0.0
- */
-public class JEMUIPlugin extends AbstractUIPlugin {
-
-	private static JEMUIPlugin PLUGIN;
-	public static final String PI_BEANINFO_UI = "org.eclipse.jem.internal.beaninfo.ui";	// Key for dialog settings.	 //$NON-NLS-1$
-	
-	/**
-	 * @param descriptor
-	 * 
-	 * @since 1.0.0
-	 */
-	public JEMUIPlugin() {
-		PLUGIN = this;
-	}
-	
-	/**
-	 * Return the plugin.
-	 * 
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public static JEMUIPlugin getPlugin() {
-		return PLUGIN;
-	}
-	
-	private Logger logger;
-	public Logger getLogger() {
-		if (logger == null)
-			logger = EclipseLogger.getEclipseLogger(this);
-		return logger;
-	}	
-
-}
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyLaunchMenuDelegate.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyLaunchMenuDelegate.java
deleted file mode 100644
index bf6af9d..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyLaunchMenuDelegate.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ProxyLaunchMenuDelegate.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 21:07:12 $ 
- */
-package org.eclipse.jem.internal.ui.proxy;
-
-import org.eclipse.debug.ui.actions.OpenLaunchDialogAction;
-
-import org.eclipse.jem.internal.proxy.core.IProxyConstants;
- 
-/**
- * Menu delegate to launch the Proxy Launch Manager.
- * @since 1.0.0
- */
-public class ProxyLaunchMenuDelegate extends OpenLaunchDialogAction {
-	
-	public ProxyLaunchMenuDelegate() {
-		super(IProxyConstants.ID_PROXY_LAUNCH_GROUP);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyLaunchToolbarDelegate.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyLaunchToolbarDelegate.java
deleted file mode 100644
index 1bfc716..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyLaunchToolbarDelegate.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ProxyLaunchToolbarDelegate.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $ 
- */
-package org.eclipse.jem.internal.ui.proxy;
-
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Menu;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.IWorkbenchWindowPulldownDelegate2;
-
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
- 
-/**
- * The toolbar delegate for proxy launch.
- * @since 1.0.0
- */
-public class ProxyLaunchToolbarDelegate implements IWorkbenchWindowPulldownDelegate2 {
-
-	private Menu menu;
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWindowPulldownDelegate2#getMenu(org.eclipse.swt.widgets.Menu)
-	 */
-	public Menu getMenu(Menu parent) {
-		setMenu(new Menu(parent));
-		fillMenu(menu);
-		return menu;
-	}
-	
-	private void setMenu(Menu menu) {
-		if (this.menu != null) {
-			this.menu.dispose();
-		}
-		this.menu = menu;
-	}	
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWindowPulldownDelegate#getMenu(org.eclipse.swt.widgets.Control)
-	 */
-	public Menu getMenu(Control parent) {
-		setMenu(new Menu(parent));
-		fillMenu(menu);
-		return menu;
-	}
-	
-	private void fillMenu(Menu menu) {
-		addToMenu(menu, proxyLaunchDelegate, -1);	
-		addToMenu(menu, selectDelegate, -1);
-	}
-	
-	/**
-	 * Adds the given action to the specified menu with an accelerator specified
-	 * by the given number.
-	 * 
-	 * @param menu the menu to add the action to
-	 * @param action the action to add
-	 * @param accelerator the number that should appear as an accelerator
-	 */
-	protected void addToMenu(Menu menu, IAction action, int accelerator) {
-		StringBuffer label= new StringBuffer();
-		if (accelerator >= 0 && accelerator < 10) {
-			//add the numerical accelerator
-			label.append('&');
-			label.append(accelerator);
-			label.append(' ');
-		}
-		label.append(action.getText());
-		action.setText(label.toString());
-		ActionContributionItem item= new ActionContributionItem(action);
-		item.fill(menu, -1);
-	}	
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
-	 */
-	public void dispose() {
-		setMenu(null);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
-	 */
-	public void init(IWorkbenchWindow window) {
-		selectDelegate.init(window);
-	}
-
-	protected SelectDefaultConfigurationActionDelegate selectDelegate = new SelectDefaultConfigurationActionDelegate();
-	protected ProxyLaunchMenuDelegate proxyLaunchDelegate = new ProxyLaunchMenuDelegate();
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
-	 */
-	public void run(IAction action) {
-		if (selectDelegate.isEnabled())
-			selectDelegate.run(action);
-		else
-			proxyLaunchDelegate.run(action);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
-	 */
-	public void selectionChanged(IAction action, ISelection selection) {
-		selectDelegate.selectionChanged(null, selection);
-		if (selectDelegate.isEnabled())
-			action.setToolTipText(selectDelegate.getToolTipText());
-		else
-			action.setToolTipText(Platform.getResourceString(JEMUIPlugin.getPlugin().getBundle(), "%Action.proxyLaunchTip")); //$NON-NLS-1$
-			
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyUIMessages.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyUIMessages.java
deleted file mode 100644
index 26ed81e..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/ProxyUIMessages.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.ui.proxy;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class ProxyUIMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.ui.proxy.messages";//$NON-NLS-1$
-
-	private ProxyUIMessages() {
-		// Do not instantiate
-	}
-
-	public static String Select_title;
-	public static String Select_message;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, ProxyUIMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/SelectDefaultConfigurationActionDelegate.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/SelectDefaultConfigurationActionDelegate.java
deleted file mode 100644
index d2498e3..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/SelectDefaultConfigurationActionDelegate.java
+++ /dev/null
@@ -1,244 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: SelectDefaultConfigurationActionDelegate.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 21:07:12 $ 
- */
-package org.eclipse.jem.internal.ui.proxy;
-
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.debug.core.DebugPlugin;
-import org.eclipse.debug.core.ILaunchConfiguration;
-import org.eclipse.debug.ui.DebugUITools;
-import org.eclipse.debug.ui.IDebugUIConstants;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.dialogs.ErrorDialog;
-import org.eclipse.jface.viewers.*;
-import org.eclipse.jface.window.Window;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.ui.*;
-import org.eclipse.ui.dialogs.CheckedTreeSelectionDialog;
-
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.ui.core.JEMUIPlugin;
- 
-/**
- * 
- * @since 1.0.0
- */
-public class SelectDefaultConfigurationActionDelegate extends Action implements IWorkbenchWindowActionDelegate, IObjectActionDelegate {
-	
-
-	/**
-	 * Helper to get single selected java project out of selection.
-	 * Used by ProxyLaunchToolbarDelegate too.
-	 * 
-	 * @param selection
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected static IJavaProject getSelectedJavaProject(ISelection selection) {
-		if (selection.isEmpty() || !(selection instanceof IStructuredSelection) || ((IStructuredSelection) selection).size() > 1)
-			return null;	// Can't handle it.
-		else {
-			Object sel = ((IStructuredSelection) selection).getFirstElement();
-			if (sel instanceof IProject && ((IProject) sel).isOpen()) {
-				return JavaCore.create((IProject) sel);	// Will return null if not exist.
-			} else if (sel instanceof IJavaProject && ((IJavaProject) sel).isOpen())
-				return (IJavaProject) sel;
-			else
-				return null;
-		}
-	}
-	
-	/**
-	 * 
-	 * 
-	 * @since 1.0.0
-	 */
-	public SelectDefaultConfigurationActionDelegate() {
-		super(Platform.getResourceString(JEMUIPlugin.getPlugin().getBundle(), "%Action.selectDefault")); //$NON-NLS-1$
-		setEnabled(false);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
-	 */
-	public void dispose() {
-	}
-
-	private IWorkbenchWindow window;
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
-	 */
-	public void init(IWorkbenchWindow window) {
-		this.window = window;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IActionDelegate#run()
-	 */
-	public void run() {
-		selectDialog();
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
-	 */
-	public void run(IAction action) {
-		run();
-	}	
-
-	protected IJavaProject javaproject;
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
-	 */
-	public void selectionChanged(IAction action, ISelection selection) {
-		javaproject = getSelectedJavaProject(selection);
-		try {
-			setEnabled(
-				javaproject != null
-					&& javaproject.getProject().getPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION) != null);
-		} catch (Exception e) {
-			setEnabled(false);	// Some error, so not enabled.
-		}
-		if (action != null)			
-			action.setEnabled(isEnabled());
-		if (javaproject != null)
-			setToolTipText(MessageFormat.format(Platform.getResourceString(JEMUIPlugin.getPlugin().getBundle(), "%Action.selectDefaultTip"), new Object[] {javaproject.getElementName()})); //$NON-NLS-1$
-		else
-			setToolTipText(getText());
-	}
-	
-	private static final Object[] EMPTY = new Object[0];
-	protected void selectDialog() {
-		try {
-			ILabelProvider labelProvider = DebugUITools.newDebugModelPresentation();
-			
-			CheckedTreeSelectionDialog dialog = new CheckedTreeSelectionDialog(window.getShell(), labelProvider, new ITreeContentProvider() {
-				public Object[] getChildren(Object parentElement) {
-					return EMPTY;
-				}
-
-				public Object getParent(Object element) {
-					return null;
-				}
-
-				public boolean hasChildren(Object element) {
-					return false;
-				}
-
-				public Object[] getElements(Object inputElement) {
-					if (inputElement != null && inputElement instanceof Object[])
-						return (Object[]) inputElement;
-					else 
-						return null;
-				}
-
-				public void dispose() {
-				}
-
-				public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
-				}
-			}) {
-				protected CheckboxTreeViewer createTreeViewer(Composite parent) {
-					final CheckboxTreeViewer treeViewer = super.createTreeViewer(parent);
-					treeViewer.addCheckStateListener(new ICheckStateListener() {
-						boolean processingCheck = false;
-						public void checkStateChanged(CheckStateChangedEvent event) {
-							if (!processingCheck) {
-								try {
-									processingCheck = true;
-									if (event.getChecked()) {
-										// We are checking something, make sure old one unchecked.
-										Object[] checked = treeViewer.getCheckedElements();
-										for (int i = 0; i < checked.length; i++) {
-											if (checked[i] != event.getElement())
-												treeViewer.setChecked(checked[i], false);
-										}
-									}
-								} finally {
-									processingCheck = false;
-								}
-							}
-
-						}
-					});
-					return treeViewer;
-				}
-				
-				protected Composite createSelectionButtons(Composite composite) {
-					return new Composite(composite, SWT.NONE);	// We don't want selection buttons since only one can be selected at a time.
-				}
-			};
-			dialog.setTitle(ProxyUIMessages.Select_title); 
-			dialog.setMessage(MessageFormat.format(ProxyUIMessages.Select_message, new Object[] { javaproject.getElementName()})); 
-
-			ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations();
-			List configsList = new ArrayList(configs.length+1);
-			String jpName = javaproject.getElementName();
-			for (int i = 0; i < configs.length; i++) {
-				if (IProxyConstants.ID_PROXY_LAUNCH_GROUP.equals(configs[i].getCategory()) && !configs[i].getAttribute(IDebugUIConstants.ATTR_PRIVATE, false) && jpName.equals(configs[i].getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""))) //$NON-NLS-1$
-					configsList.add(configs[i]);
-			}
-			configs = (ILaunchConfiguration[]) configsList.toArray(new ILaunchConfiguration[configsList.size()]);
-			dialog.setInput(configs);
-
-			String launchName = javaproject.getProject().getPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION);
-			ILaunchConfiguration config = null;
-			if (launchName != null) {
-				for (int i = 0; i < configs.length; i++) {
-					if (configs[i].getName().equals(launchName)) {
-						config = configs[i];
-						break;
-					}
-				}
-				if (config != null) {
-					dialog.setInitialSelections(new Object[] { config });
-				}
-			}
-			if (dialog.open() == Window.OK) {
-				config = (ILaunchConfiguration) dialog.getFirstResult();
-				if (config != null)
-					javaproject.getProject().setPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION, config.getName());
-				else
-					javaproject.getProject().setPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION, ProxyLaunchSupport.NOT_SET);
-			} 
-			
-		} catch (CoreException e) {
-			ErrorDialog.openError(window.getShell(), null, null, e.getStatus());
-			ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
-		}					
-		
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
-	 */
-	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
-		// This is called instead of init(WorkbenchWindow) when this is on popup menu.
-		window = targetPart.getSite().getWorkbenchWindow();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/messages.properties b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/messages.properties
deleted file mode 100644
index b8828e0..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/messages.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/Attic/messages.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 21:07:12 $
-#
-
-Select_title=Select Default
-Select_message=Select default configuration for project "{0}":
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/LocalLaunchProjectTab.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/LocalLaunchProjectTab.java
deleted file mode 100644
index 9b846a2..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/LocalLaunchProjectTab.java
+++ /dev/null
@@ -1,267 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: LocalLaunchProjectTab.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 21:07:12 $ 
- */
-package org.eclipse.jem.internal.ui.proxy.remote;
-
-import java.text.MessageFormat;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.debug.core.ILaunchConfiguration;
-import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jdt.internal.debug.ui.launcher.JavaLaunchConfigurationTab;
-import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
-import org.eclipse.jdt.ui.JavaElementLabelProvider;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.window.Window;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.*;
-import org.eclipse.swt.graphics.Font;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.*;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.dialogs.ElementListSelectionDialog;
-import org.eclipse.ui.ide.IDE;
-
-import org.eclipse.jem.internal.proxy.core.ProxyPlugin;
- 
-/**
- * 
- * @since 1.0.0
- */
-public class LocalLaunchProjectTab extends JavaLaunchConfigurationTab {
-		
-	// Project UI widgets
-	protected Label fProjLabel;
-	protected Text fProjText;
-	protected Button fProjButton;
-			
-	
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(Composite)
-	 */
-	public void createControl(Composite parent) {
-		Font font = parent.getFont();
-		
-		Composite comp = new Composite(parent, SWT.NONE);
-		setControl(comp);
-		GridLayout topLayout = new GridLayout();
-		comp.setLayout(topLayout);		
-		GridData gd;
-		
-		createVerticalSpacer(comp, 1);
-		
-		Composite projComp = new Composite(comp, SWT.NONE);
-		GridLayout projLayout = new GridLayout();
-		projLayout.numColumns = 2;
-		projLayout.marginHeight = 0;
-		projLayout.marginWidth = 0;
-		projComp.setLayout(projLayout);
-		gd = new GridData(GridData.FILL_HORIZONTAL);
-		projComp.setLayoutData(gd);
-		projComp.setFont(font);
-		
-		fProjLabel = new Label(projComp, SWT.NONE);
-		fProjLabel.setText(ProxyRemoteUIMessages.LocalLaunchProjectTab_Project); 
-		gd = new GridData();
-		gd.horizontalSpan = 2;
-		fProjLabel.setLayoutData(gd);
-		fProjLabel.setFont(font);
-		
-		fProjText = new Text(projComp, SWT.SINGLE | SWT.BORDER);
-		gd = new GridData(GridData.FILL_HORIZONTAL);
-		fProjText.setLayoutData(gd);
-		fProjText.setFont(font);
-		fProjText.addModifyListener(new ModifyListener() {
-			public void modifyText(ModifyEvent evt) {
-				updateLaunchConfigurationDialog();
-			}
-		});
-		
-		fProjButton = createPushButton(projComp, ProxyRemoteUIMessages.LocalLaunchProjectTab_Browse, null); 
-		fProjButton.addSelectionListener(new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent evt) {
-				handleProjectButtonSelected();
-			}
-		});
-				
-	}
-		
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(ILaunchConfiguration)
-	 */
-	public void initializeFrom(ILaunchConfiguration config) {
-		updateProjectFromConfig(config);
-	}
-	
-	protected void updateProjectFromConfig(ILaunchConfiguration config) {
-		String projectName = ""; //$NON-NLS-1$
-		try {
-			projectName = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "");	 //$NON-NLS-1$
-		} catch (CoreException ce) {
-			ProxyPlugin.getPlugin().getLogger().log(ce);
-		}
-		fProjText.setText(projectName);
-	}
-			
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(ILaunchConfigurationWorkingCopy)
-	 */
-	public void performApply(ILaunchConfigurationWorkingCopy config) {
-		config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, fProjText.getText());		
-	}
-			
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#dispose()
-	 */
-	public void dispose() {
-	}
-			
-		
-	/**
-	 * Show a dialog that lets the user select a project.  This in turn provides
-	 * context for the main type, allowing the user to key a main type name, or
-	 * constraining the search for main types to the specified project.
-	 */
-	protected void handleProjectButtonSelected() {
-		IJavaProject project = chooseJavaProject();
-		if (project == null) {
-			return;
-		}
-		
-		String projectName = project.getElementName();
-		fProjText.setText(projectName);		
-	}
-	
-	/**
-	 * Realize a Java Project selection dialog and return the first selected project,
-	 * or null if there was none.
-	 */
-	protected IJavaProject chooseJavaProject() {
-		IJavaProject[] projects;
-		try {
-			projects= JavaCore.create(getWorkspaceRoot()).getJavaProjects();
-		} catch (JavaModelException e) {
-			ProxyPlugin.getPlugin().getLogger().log(e);
-			projects= new IJavaProject[0];
-		}
-		
-		ILabelProvider labelProvider= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
-		ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), labelProvider);
-		dialog.setTitle(ProxyRemoteUIMessages.LocalLaunchProjectTab_Project_Selection); 
-		dialog.setMessage(ProxyRemoteUIMessages.LocalLaunchProjectTab_ChooseProject); 
-		dialog.setElements(projects);
-		
-		IJavaProject javaProject = getJavaProject();
-		if (javaProject != null) {
-			dialog.setInitialSelections(new Object[] { javaProject });
-		}
-		if (dialog.open() == Window.OK) {			
-			return (IJavaProject) dialog.getFirstResult();
-		}			
-		return null;		
-	}
-	
-	/**
-	 * Return the IJavaProject corresponding to the project name in the project name
-	 * text field, or null if the text does not match a project name.
-	 */
-	protected IJavaProject getJavaProject() {
-		String projectName = fProjText.getText().trim();
-		if (projectName.length() < 1) {
-			return null;
-		}
-		return getJavaModel().getJavaProject(projectName);		
-	}
-	
-	/**
-	 * Convenience method to get the workspace root.
-	 */
-	private IWorkspaceRoot getWorkspaceRoot() {
-		return ResourcesPlugin.getWorkspace().getRoot();
-	}
-	
-	/**
-	 * Convenience method to get access to the java model.
-	 */
-	private IJavaModel getJavaModel() {
-		return JavaCore.create(getWorkspaceRoot());
-	}
-
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#isValid(ILaunchConfiguration)
-	 */
-	public boolean isValid(ILaunchConfiguration config) {
-		
-		setErrorMessage(null);
-		setMessage(null);
-		
-		String name = fProjText.getText().trim();
-		if (name.length() > 0) {
-			IWorkspace workspace = ResourcesPlugin.getWorkspace();
-			IStatus status = workspace.validateName(name, IResource.PROJECT);
-			if (status.isOK()) {
-				IProject project= ResourcesPlugin.getWorkspace().getRoot().getProject(name);
-				if (!project.exists()) {
-					setErrorMessage(MessageFormat.format(ProxyRemoteUIMessages.LocalLaunchProjectTab_ProjectNotExist_ERROR_, new String[] {name})); 
-					return false;
-				}
-				if (!project.isOpen()) {
-					setErrorMessage(MessageFormat.format(ProxyRemoteUIMessages.LocalLaunchProjectTab_ProjectNotOpen_ERROR_, new String[] {name})); 
-					return false;
-				}
-			} else {
-				setErrorMessage(MessageFormat.format(ProxyRemoteUIMessages.LocalLaunchProjectTab_ProjectValidateError_ERROR_, new String[]{status.getMessage()})); 
-				return false;
-			}
-		}
-		
-		return false;	// Kludge. We always return false so that "Run" button is never enabled. We can't launch these configurations using the standard way. Only through ProxyLaunchSupport.
-	}
-
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#setDefaults(ILaunchConfigurationWorkingCopy)
-	 */
-	public void setDefaults(ILaunchConfigurationWorkingCopy config) {
-		IJavaElement javaElement = getContext();
-		if (javaElement != null) {
-			initializeJavaProject(javaElement, config);
-		} else {
-			// We set empty attributes for project so that when one config is
-			// compared to another, the existence of empty attributes doesn't cause an
-			// incorrect result (the performApply() method can result in empty values
-			// for these attributes being set on a config if there is nothing in the
-			// corresponding text boxes)
-			config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); //$NON-NLS-1$
-		}
-	}
-
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName()
-	 */
-	public String getName() {
-		return ProxyRemoteUIMessages.LocalLaunchProjectTab_name; 
-	}
-
-	/**
-	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getImage()
-	 */
-	public Image getImage() {
-		return PlatformUI.getWorkbench().getSharedImages().getImage(IDE.SharedImages.IMG_OBJ_PROJECT);
-	}
-}
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/LocalLaunchTabGroup.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/LocalLaunchTabGroup.java
deleted file mode 100644
index 1162f2c..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/LocalLaunchTabGroup.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * $RCSfile: LocalLaunchTabGroup.java,v $ $Revision: 1.5 $ $Date: 2005/08/24 21:07:12 $
- */
-package org.eclipse.jem.internal.ui.proxy.remote;
-
-import org.eclipse.debug.ui.*;
-import org.eclipse.debug.ui.sourcelookup.SourceLookupTab;
-import org.eclipse.jdt.debug.ui.launchConfigurations.*;
-
-/**
- * Launch Tab Group for the Local Launch of a Remote Proxy Configuration.
- * 
- * @since 1.0.0
- */
-public class LocalLaunchTabGroup extends AbstractLaunchConfigurationTabGroup {
-
-	/**
-	 * Constructs a new Java applet tab group.
-	 */
-	public LocalLaunchTabGroup() {
-	}
-
-	/*
-	 * @see ILaunchConfigurationTabGroup#createTabs(ILaunchConfigurationDialog, String)
-	 */
-	public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
-		ILaunchConfigurationTab[] tabs =
-			new ILaunchConfigurationTab[] {
-				new LocalLaunchProjectTab(),
-				new JavaArgumentsTab(),
-				new JavaJRETab(),
-				new JavaClasspathTab(),
-				new SourceLookupTab(),	// TODO Need to see why SourceLookupTab didn't work. Until then use this.
-				new EnvironmentTab(),
-				new CommonTab()};
-		setTabs(tabs);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/ProxyRemoteUIMessages.java b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/ProxyRemoteUIMessages.java
deleted file mode 100644
index 822126c..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/ProxyRemoteUIMessages.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.ui.proxy.remote;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class ProxyRemoteUIMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.ui.proxy.remote.messages";//$NON-NLS-1$
-
-	private ProxyRemoteUIMessages() {
-		// Do not instantiate
-	}
-
-	public static String LocalLaunchProjectTab_name;
-	public static String LocalLaunchProjectTab_Project;
-	public static String LocalLaunchProjectTab_Browse;
-	public static String LocalLaunchProjectTab_Project_Selection;
-	public static String LocalLaunchProjectTab_ChooseProject;
-	public static String LocalLaunchProjectTab_ProjectNotExist_ERROR_;
-	public static String LocalLaunchProjectTab_ProjectNotOpen_ERROR_;
-	public static String LocalLaunchProjectTab_ProjectValidateError_ERROR_;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, ProxyRemoteUIMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/messages.properties b/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/messages.properties
deleted file mode 100644
index b7ca012..0000000
--- a/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/messages.properties
+++ /dev/null
@@ -1,23 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.ui/ui/org/eclipse/jem/internal/ui/proxy/remote/Attic/messages.properties,v $
-# $Revision: 1.8 $  $Date: 2005/08/24 21:07:12 $
-#
-
-LocalLaunchProjectTab_name                        = &Project
-LocalLaunchProjectTab_Project                     = &Project
-LocalLaunchProjectTab_Browse                      = &Browse...
-LocalLaunchProjectTab_Project_Selection           = Project Selection
-LocalLaunchProjectTab_ChooseProject               = Choose a &project to for the launch:
-LocalLaunchProjectTab_ProjectNotExist_ERROR_      = IWAV0174E Project "{0}" doesn''t exist.
-LocalLaunchProjectTab_ProjectNotOpen_ERROR_       = IWAV0175E Project "{0}" is not open.
-LocalLaunchProjectTab_ProjectValidateError_ERROR_ = IWAV0176E Project validation error. Msg is "{0}."
diff --git a/plugins/org.eclipse.jem.workbench/.classpath b/plugins/org.eclipse.jem.workbench/.classpath
deleted file mode 100644
index 7682dad..0000000
--- a/plugins/org.eclipse.jem.workbench/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-    <classpathentry kind="src" path="workbench/"/>
-    <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-    <classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/plugins/org.eclipse.jem.workbench/.cvsignore b/plugins/org.eclipse.jem.workbench/.cvsignore
deleted file mode 100644
index 60463af..0000000
--- a/plugins/org.eclipse.jem.workbench/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-bin
-build.xml
diff --git a/plugins/org.eclipse.jem.workbench/.project b/plugins/org.eclipse.jem.workbench/.project
deleted file mode 100644
index 81862bd..0000000
--- a/plugins/org.eclipse.jem.workbench/.project
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem.workbench</name>
-	<comment></comment>
-	<projects>
-		<project>org.eclipse.core.resources</project>
-		<project>org.eclipse.core.runtime.compatibility</project>
-		<project>org.eclipse.emf.ecore.xmi</project>
-		<project>org.eclipse.jdt.core</project>
-		<project>org.eclipse.jem</project>
-		<project>org.eclipse.jem.proxy</project>
-	</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/plugins/org.eclipse.jem.workbench/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.jem.workbench/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 106382e..0000000
--- a/plugins/org.eclipse.jem.workbench/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,282 +0,0 @@
-#Thu Jun 16 13:23:32 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=error
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=1
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=0
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
-org.eclipse.jdt.core.formatter.comment.format_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
-org.eclipse.jdt.core.formatter.comment.line_length=150
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=150
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=tab
-org.eclipse.jdt.core.formatter.tabulation.size=4
diff --git a/plugins/org.eclipse.jem.workbench/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.jem.workbench/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 4cff627..0000000
--- a/plugins/org.eclipse.jem.workbench/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed May 11 16:20:15 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.ignorelowercasenames=true
-org.eclipse.jdt.ui.importorder=java;javax;org;org.eclipse.wtp;org.eclipse.jem;org.eclipse.ve.internal.cdm;org.eclipse.ve.internal.cde;org.eclipse.ve.internal.jcm;org.eclipse.ve.internal.java;org.eclipse.ve;com;
-org.eclipse.jdt.ui.ondemandthreshold=3
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/plugins/org.eclipse.jem.workbench/META-INF/MANIFEST.MF b/plugins/org.eclipse.jem.workbench/META-INF/MANIFEST.MF
deleted file mode 100644
index dd964fe..0000000
--- a/plugins/org.eclipse.jem.workbench/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,18 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jem.workbench; singleton:=true
-Bundle-Version: 1.2.0
-Bundle-Activator: org.eclipse.jem.internal.plugin.JavaPlugin
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Export-Package: org.eclipse.jem.internal.adapters.jdom;x-friends:="org.eclipse.jem.beaninfo,org.eclipse.jem.tests",
- org.eclipse.jem.internal.plugin;x-friends:="org.eclipse.jem.beaninfo",
- org.eclipse.jem.workbench.utility
-Require-Bundle: org.eclipse.jem,
- org.eclipse.jdt.core,
- org.eclipse.core.resources,
- org.eclipse.emf.ecore.xmi,
- org.eclipse.core.runtime,
- org.eclipse.jem.util
-Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jem.workbench/about.html b/plugins/org.eclipse.jem.workbench/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/plugins/org.eclipse.jem.workbench/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.workbench/build.properties b/plugins/org.eclipse.jem.workbench/build.properties
deleted file mode 100644
index 11e482e..0000000
--- a/plugins/org.eclipse.jem.workbench/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-bin.includes = plugin.xml,\
-               plugin.properties,\
-               about.html,\
-               META-INF/,\
-               .
-src.includes = about.html
-
-source.. = workbench/
-output.. = bin/
-jars.compile.order = .
diff --git a/plugins/org.eclipse.jem.workbench/plugin.properties b/plugins/org.eclipse.jem.workbench/plugin.properties
deleted file mode 100644
index ee32234..0000000
--- a/plugins/org.eclipse.jem.workbench/plugin.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem.workbench/plugin.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 21:13:53 $
-#
-
-
-pluginName=Java EMF Model Workbench Support
-providerName = Eclipse.org
-
-JavaEMFNatureName=JavaEMFNature Properties
diff --git a/plugins/org.eclipse.jem.workbench/plugin.xml b/plugins/org.eclipse.jem.workbench/plugin.xml
deleted file mode 100644
index 1508905..0000000
--- a/plugins/org.eclipse.jem.workbench/plugin.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-
-     <extension
-         id="JavaEMFNature"
-         name="%JavaEMFNatureName"
-         point="org.eclipse.core.resources.natures">
-      <runtime>
-         <run
-               class="org.eclipse.jem.internal.plugin.JavaEMFNature">
-         </run>
-      </runtime>
-   </extension>
-   
-   <extension
-         point="org.eclipse.jem.util.nature_registration">
-      <nature
-            id="org.eclipse.jem.workbench.JavaEMFNature">
-      </nature>
-   </extension>   
-
-</plugin>
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMAdaptor.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMAdaptor.java
deleted file mode 100644
index 372b839..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMAdaptor.java
+++ /dev/null
@@ -1,351 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JDOMAdaptor.java,v $
- *  $Revision: 1.8 $  $Date: 2005/10/18 14:58:18 $ 
- */
-
-import java.io.File;
-import java.util.Map;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-import org.eclipse.jem.java.internal.impl.JavaRefFactoryImpl;
-/**
- * Insert the type's description here.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public abstract class JDOMAdaptor extends JavaReflectionAdaptor {
-
-	protected final static JavaRefPackage JAVA_PACK = JavaRefFactoryImpl.getPackage();
-	protected IJavaProject sourceProject;
-	final public static int INVALID_LINENO = -1;
-	final protected Integer fLINENOLock = new Integer(INVALID_LINENO);
-	// This object is not static, as it is used as synchronization element.
-	private int fResolvedLineNo = INVALID_LINENO; // Line offset in source file
-	private int fResolvedColNo = INVALID_LINENO; // Column offset in source file
-	public JDOMAdaptor(Notifier target, IJavaProject workingProject) {
-		super(target);
-		setSourceProject(workingProject);
-	}
-	protected void clearSource() {
-		// To be overidden if needed.
-	}
-	
-	/**
-	 * Called by subclasses in canReflect(). If the target is not in a resource, or the
-	 * resource is not loaded, then it can't reflect. Mustn't reflect if the target
-	 * has been unloaded.
-	 * 
-	 * @return
-	 */
-	protected boolean isResourceLoaded() {
-		Resource res = ((EObject) getTarget()).eResource();
-		return res != null && res.isLoaded();
-	}
-	
-	/**
-	 * Scan for CRs and LFs within a character buffer
-	 * Creation date: (8/17/2001 2:14:13 PM)
-	 * @return int  LineNo at charOffset
-	 * @param charOffset int
-	 * @param buffer org.eclipse.jdt.core.IBuffer
-	 */
-	private void computeLineOffset(int charOffset, IBuffer buffer) {
-
-		fResolvedColNo = fResolvedLineNo = INVALID_LINENO;
-
-		if (buffer == null)
-			return;
-
-		char[] charBuff = buffer.getCharacters();
-
-		if (charBuff == null)
-			return;
-
-		int LineCount = 0;
-		int ColNo = 0;
-		for (int i = 0; i <= charOffset; i++) {
-			ColNo++;
-			if (charBuff[i] == '\r') {
-				LineCount++;
-				ColNo = 0;
-				if (charBuff[i + 1] == '\n')
-					i++; // skip LineFeed followed  a CR
-			} else if (charBuff[i] == '\n') {
-				LineCount++;
-				ColNo = 0;
-			}
-
-		}
-		fResolvedColNo = ColNo;
-		fResolvedLineNo = LineCount;
-	}
-	/**
-	 * computeMethodID - generate the unique ID to be used to identify a method.
-	 * Similar to a Signature, but hopefully more readable.
-	 * The name format will be:
-	 * 	simpleTypeName.methodName(my.package.Parm_Type1,parmType2
-	 * Note: This implementation is tightly coupled with ReflectionAdapter.getTypeNamesFromMethodID().
-	 */
-	public static String computeMethodID(IMethod jdomMethod) {
-		return computeMethodID(jdomMethod, jdomMethod.getDeclaringType(), null);
-	}
-	/**
-	 * computeMethodID - generate the unique ID to be used to identify a method.
-	 * Similar to a Signature, but hopefully more readable.
-	 * The name format will be:
-	 * 	simpleTypeName.methodName(my.package.Parm_Type1,parmType2
-	 * Note: This implementation is tightly coupled with ReflectionAdapter.getTypeNamesFromMethodID().
-	 */
-	public static String computeMethodID(IMethod jdomMethod, IType type, Map typeCache) {
-		StringBuffer out = new StringBuffer();
-		out.append(type.getTypeQualifiedName());
-		out.append(C_CLASS_MEMBER_DELIMITER);
-		out.append(jdomMethod.getElementName());
-		out.append(C_METHOD_PARM_DELIMITER);
-		String[] parmTypeNames = jdomMethod.getParameterTypes();
-		String parmName;
-		for (int i = 0; i < parmTypeNames.length; i++) {
-			parmName = convertJDOMtypeName(parmTypeNames[i]);
-			parmName = JDOMSearchHelper.getResolvedTypeName(parmName, type, typeCache);
-			out.append(parmName);
-			if (i < (parmTypeNames.length - 1))
-				out.append(C_PARM_PARM_DELIMITER);
-		}
-		try {
-			if (jdomMethod.isConstructor())
-				out.append(S_CONSTRUCTOR_TOKEN);
-		} catch (JavaModelException e) {
-		}
-		return out.toString();
-	}
-	/**
-	 * computeMethodName - generate the name to be used to identify a method.
-	 * For the moment, names are simple, and UUID's are complex.
-	 */
-	public static String computeMethodName(IMethod jdomMethod) {
-		return jdomMethod.getElementName();
-	}
-	/**
-	 * Java content has changed, but no structural changes that require
-	 * to reflectValues();  e.g., the body of a method has changed.
-	 * Creation date: (8/17/2001 10:47:58 AM)
-	 */
-	public void contentChanged() {
-		synchronized (fLINENOLock) {
-			fResolvedLineNo = INVALID_LINENO;
-			fResolvedColNo = INVALID_LINENO;
-		}
-	}
-	/**
-	 * computeMethodID - generate the unique ID to be used to identify a method.
-	 * Similar to a Signature, but hopefully more readable.
-	 * The name format will be:
-	 * 	methodName_parmType1_parmType2
-	 */
-	public static String convertJDOMtypeName(String jdomTypeName) {
-		return signatureToString(jdomTypeName);
-	}
-	/**
-	 * createJavaField - instantiate a Java Field based on the passed Java Model IField
-	 * We are deferring field contents assuming that its adaptor will reflect its details.
-	 */
-	public Field createJavaField(IField jdomField, XMIResource resource) {
-		String name = jdomField.getElementName();
-		Field newField = getJavaFactory().createField();
-		newField.setName(name);
-		resource.setID(newField, ((JavaClass) getTarget()).getName() + C_CLASS_MEMBER_DELIMITER + name);
-		return newField;
-	}
-	/**
-	 * createJavaMethod - instantiate a Java Method based on the passed Java Model IMethod
-	 * We are deferring method contents assuming that its adaptor will reflect its details.
-	 * We need to store enough info in the empty Method to find its Java source.
-	 * The UUID will eventually hold enough info to identify the source, so we use it.
-	 */
-	public Method createJavaMethod(IMethod jdomMethod, XMIResource resource) {
-		Method newMethod = getJavaFactory().createMethod();
-		// We use a simple name, but a complex ID 
-		newMethod.setName(computeMethodName(jdomMethod));
-		resource.setID(newMethod, computeMethodID(jdomMethod, getType(), getTypeResolutionCache()));
-		return newMethod;
-	}
-	protected IPath getBinaryPathFromQualifiedName(String qualifiedName) {
-		return new Path(qualifiedName.replace('.', File.separatorChar) + ".class"); //$NON-NLS-1$
-	}
-	public IType getBinaryType(String qualifiedName) {
-		try {
-			if (getSourceProject() != null) {
-				IJavaElement found = getSourceProject().findElement(getBinaryPathFromQualifiedName(qualifiedName));
-				if (found != null)
-					return ((IClassFile) found).getType();
-			}
-		} catch (JavaModelException jme) {
-			System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] { qualifiedName, jme.getMessage()}))); //$NON-NLS-1$ = "Error looking up type: "
-		}
-		return null;
-	}
-	/**
-	 * Compute a column number from the ISourceRange offset
-	 * Cache the line number thereafter.  Source change will
-	 * Invoke the contentChanged() method.
-	 * Creation date: (8/17/2001 11:16:51 AM)
-	 * @return int
-	 */
-	public int getColNo() {
-
-		synchronized (fLINENOLock) {
-			if (fResolvedColNo == INVALID_LINENO)
-				resolveLineColNo();
-		}
-		return fResolvedColNo;
-	}
-	/**
-	 * Compute a line number from the ISourceRange offset
-	 * Cache the line number thereafter.  Source change will
-	 * Invoke the contentChanged() method.
-	 * Creation date: (8/17/2001 11:16:51 AM)
-	 * @return int
-	 */
-	public int getLineNo() {
-
-		synchronized (fLINENOLock) {
-			if (fResolvedLineNo == INVALID_LINENO)
-				resolveLineColNo();
-		}
-		return fResolvedLineNo;
-	}
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (8/17/2001 1:18:29 PM)
-	 */
-	public abstract Object getReflectionSource();
-	/* 
-	 * Resolve a type name in the context of a Type.
-	 * (Borrowed from org.eclipse.jdt.ui.codemanipulation.StubUtility.getResolvedTypeName())
-	 * The input is a simple or qualified name, NOT a signature
-	 * The output will be a qualified name, NOT a signature
-	 */
-	public static String getResolvedTypeName(String typeName, IType declaringType) {
-		String name = typeName;
-		try {
-			name = JDOMSearchHelper.resolveSimpleTypeName(declaringType, typeName);
-		} catch (JavaModelException e) {
-			// ignore
-		}
-		return name;
-	}
-
-	protected IJavaProject getSourceProject() {
-		return sourceProject;
-	}
-	protected abstract IType getType();
-	protected abstract Map getTypeResolutionCache();
-
-	public void releaseSourceType() {
-		flushReflectedValuesIfNecessary(true); // induce clients to get Notified.
-	}
-
-	public Notification releaseSourceTypeNoNotification() {
-		return flushReflectedValuesIfNecessaryNoNotification(true); // induce clients to get Notified.
-	}
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (8/21/2001 8:09:34 AM)
-	 */
-	private void resolveLineColNo() {
-
-		IMember rs = (IMember) getReflectionSource();
-		if (rs != null) {
-			int offset = INVALID_LINENO;
-			try {
-				ISourceRange sr = rs.getNameRange();
-				if (sr.getLength() <= 0)
-					return;
-				offset = sr.getOffset();
-			} catch (JavaModelException je) {
-				return;
-			}
-			ICompilationUnit cu = rs.getCompilationUnit();
-			if (cu != null) {
-				try {
-					IBuffer buffer = cu.getBuffer();
-					computeLineOffset(offset, buffer);
-				} catch (JavaModelException je) {
-				}
-			}
-		}
-	}
-	protected void setSourceProject(IJavaProject workingProject) {
-		sourceProject = workingProject;
-	}
-	/**
-	 * Converts a type signature to a readable string.
-	 *
-	 * Uses Signature.toString(), then tries to undo bad replacement for inner classes.
-	 *
-	 */
-	public static String signatureToString(String signature) throws IllegalArgumentException {
-		boolean hasDollar = (signature.indexOf(Signature.C_DOLLAR) != -1);
-		String result = Signature.toString(signature);
-		if (hasDollar) {
-			int newPos = result.lastIndexOf("."); //$NON-NLS-1$
-			if (newPos != -1) {
-				result = result.substring(0, newPos) + "$" + result.substring(newPos + 1); //$NON-NLS-1$
-			}
-		}
-		return result;
-	}
-	/**
-	 * setType - set our type here
-	 */
-	protected String typeNameFromSignature(String sig) {
-		return typeNameFromSignature(sig, getType());
-	}
-	/**
-	 * setType - set our type here
-	 */
-	protected String typeNameFromSignature(String sig, IType parent) {
-		return typeNameFromSignature(sig, parent, getTypeResolutionCache());
-	}
-	/**
-	 * setType - set our type here
-	 */
-	public static String typeNameFromSignature(String sig, IType parent, Map typeCache) {
-		String result;
-		String componentSignature = Signature.getElementType(sig);
-		int arrayDimensions = Signature.getArrayCount(sig);
-		result = JDOMSearchHelper.getResolvedTypeName(signatureToString(componentSignature), parent, typeCache);
-		for (int i = 0; i < arrayDimensions; i++) {
-			result = result + "[]"; //$NON-NLS-1$
-		}
-		return result;
-	}
-	/**
-	 * @deprecated
-	 * @see org.eclipse.jem.internal.adapters.jdom.JDOMSearchHelper#findType(String, boolean, IJavaProject, JDOMAdaptor)
-	 */
-	public IType getType(String qualifiedName) {
-		return JDOMSearchHelper.findType(qualifiedName, false, getSourceProject(), this);
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMClassFinder.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMClassFinder.java
deleted file mode 100644
index 012f699..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMClassFinder.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JDOMClassFinder.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 21:13:53 $ 
- */
-
-import java.io.File;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-/**
- * Insert the type's description here.
- * Creation date: (8/16/2000 11:06:46 PM)
- * @author: Administrator
- */
-public class JDOMClassFinder {
-	
-	private static JDOMClassFinder instance;
-/**
- * JDOMClassFinder constructor comment.
- */
-public JDOMClassFinder() {
-	super();
-}
-protected IPath getBinaryPathFromQualifiedName(String qualifiedName) {
-	return new Path(qualifiedName.replace('.', File.separatorChar) + ".class");//$NON-NLS-1$
-}
-public IType getBinaryType(String qualifiedName) {
-	try {
-		IJavaElement found = getJavaElement(qualifiedName);
-		return ((IClassFile) found).getType();
-	} catch (JavaModelException jme) {
-		System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] {qualifiedName, jme.getMessage()}))); //$NON-NLS-1$ = "Error looking up type: "
-	}
-	return null;
-}
-public IJavaElement getJavaElement(String qualifiedName) {
-	try {
-		if (getSourceProject() != null)
-			return getSourceProject().findElement(getPathFromQualifiedName(qualifiedName));
-	} catch (JavaModelException jme) {
-		System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] {qualifiedName, jme.getMessage()}))); //$NON-NLS-1$ = "Error looking up type: "
-	}
-	return null;
-}
-protected IPath getPathFromQualifiedName(String qualifiedName) {
-	return new Path(qualifiedName.replace('.', File.separatorChar) + ".java");//$NON-NLS-1$
-}
-protected IJavaProject getSourceProject() {
-	//return (IJavaProject) ((JavaRefPackage)EPackage.Registry.INSTANCE.getEPackage(JavaRefPackage.eNS_URI)).getJavaRefFactory().getJavaContext();
-	return null;
-}
-public IType getType(String qualifiedName) {
-	try {
-		IJavaElement found = getJavaElement(qualifiedName);
-		if (found != null)
-			if (found instanceof IClassFile)
-				return ((IClassFile) found).getType();
-			else
-				if (found instanceof ICompilationUnit) {
-					ICompilationUnit foundCU = (ICompilationUnit) found;
-					// strip the ".java", lifted from CompilationUnit.getMainTypeName()
-					String cuMainTypeName = foundCU.getElementName();
-					cuMainTypeName = cuMainTypeName.substring(0, cuMainTypeName.length() - 5);
-					return foundCU.getType(cuMainTypeName);
-				}
-	} catch (JavaModelException jme) {
-		System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] {qualifiedName, jme.getMessage()}))); //$NON-NLS-1$ = "Error looking up type: "
-	}
-	return null;
-}
-/**
- * Insert the method's description here.
- * Creation date: (8/16/2000 11:19:48 PM)
- * @return com.ibm.etools.java.adapters.JDOMClassFinder
- */
-public static JDOMClassFinder instance() {
-	if (instance == null)
-		instance = new JDOMClassFinder();
-	return instance;
-}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMSearchHelper.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMSearchHelper.java
deleted file mode 100644
index 6a861ac..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JDOMSearchHelper.java
+++ /dev/null
@@ -1,358 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JDOMSearchHelper.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 21:13:53 $ 
- */
-
-import java.io.File;
-import java.util.*;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-/**
- * Insert the type's description here.
- * Creation date: (9/26/2001 11:09:30 AM)
- * @author: Administrator
- */
-public class JDOMSearchHelper {
-	
-	private static final String RESOLVED_NAME = " :: RESOLVED_NAME :: "; //$NON-NLS-1$
-	private static final String PERIOD = "."; //$NON-NLS-1$
-	private static final String BOOLEAN = "boolean"; //$NON-NLS-1$
-	private static final String BYTE = "byte"; //$NON-NLS-1$
-	private static final String CHAR = "char"; //$NON-NLS-1$
-	private static final String SHORT = "short"; //$NON-NLS-1$
-	private static final String INT = "int"; //$NON-NLS-1$
-	private static final String LONG = "long"; //$NON-NLS-1$
-	private static final String FLOAT = "float"; //$NON-NLS-1$
-	private static final String DOUBLE = "double"; //$NON-NLS-1$
-	private static final String VOID = "void"; //$NON-NLS-1$
-	/**
-	 * JDOMSearchHelper constructor comment.
-	 */
-	public JDOMSearchHelper() {
-		super();
-	}
-	/**
-	 * If the @simpleName is an inner class, we need to resolve only the declaring class.
-	 */
-	private static String[][] getTypeNameInfo(IType type, String simpleName, boolean isForReflection) throws JavaModelException {
-		String[][] result = null;
-		String declaringName, typeName;
-		typeName = simpleName;
-		if (type != null) {
-			if (isForReflection)
-				typeName = typeName.replace('.', '$');
-			int index = typeName.indexOf("$"); //$NON-NLS-1$
-			if (index > 0) {
-				declaringName = typeName.substring(0, index);
-				result = type.resolveType(declaringName);
-				if (result != null) {
-					if (isForReflection)
-						result[0][1] = result[0][1].replace('.', '$');
-					result[0][1] += typeName.substring(index, typeName.length());
-				}
-			} else {
-				index = typeName.indexOf("["); //$NON-NLS-1$
-				if (index > 0) {
-					declaringName = typeName.substring(0, index);
-					result = type.resolveType(declaringName);
-					if (result != null)
-						result[0][1] = result[0][1] + typeName.substring(index);
-				} else
-					result = type.resolveType(typeName);
-			}
-		}
-		return result;
-	}
-	/**
-	 * Returns true if the type is a primitive.
-	 */
-	public final static boolean isPrimitive(String type) {
-		return (BOOLEAN.equals(type) || INT.equals(type) || CHAR.equals(type) || SHORT.equals(type) || LONG.equals(type) || FLOAT.equals(type) || DOUBLE.equals(type) || BYTE.equals(type));
-	}
-	/**
-	 * Returns true if the type is a primitive.
-	 */
-	public final static boolean isPrimitiveOrVoid(String type) {
-		return isPrimitive(type) || isVoid(type);
-	}
-	/**
-	 * Returns true if the type is a primitive.
-	 */
-	public final static boolean isVoid(String type) {
-		return VOID.equals(type);
-	}
-	/**
-	 * Returns true if the two signatures match within the scope of the specified type.
-	 */
-	public static boolean matchTypeSignatures(IType type, String signature1, String signature2) throws JavaModelException {
-		return matchTypeSignatures(type, signature1, signature2, null);
-	}
-	/**
-	 * Returns true if the two signatures match within the scope of the specified type.
-	 */
-	public static boolean matchTypeSignatures(IType type, String signature1, String signature2, Map resolvedNameCache) throws JavaModelException {
-		boolean result = false;
-		String sig1 = signature1;
-		String sig2 = signature2;
-		// First check array count.
-		if (Signature.getArrayCount(sig1) == Signature.getArrayCount(sig2)) {
-			// We have the same array count, get the element types for consideration.
-			sig1 = Signature.getElementType(sig1);
-			sig2 = Signature.getElementType(sig2);
-
-			// There are three cases:
-			//		1) Both are unqualified (both being primitive will fall into this),
-			//		2) Both are qualified, and
-			//		3) One is qualified and the other is not (one could be primitive).
-
-			// For the first two cases a compare of the readable names will always do.
-			if (!((sig1.indexOf('.') == -1) ^ (sig2.indexOf('.') == -1))) {
-				result = Signature.toString(sig1).equals(Signature.toString(sig2));
-			} else {
-				// This is case 3.
-				// First root out one being primitive.
-				if (((sig1.charAt(0) == 'Q') || (sig1.charAt(0) == 'L')) && ((sig2.charAt(0) == 'Q') || (sig2.charAt(0) == 'L'))) {
-					// Get the readable name of the qualified signature
-					// and the simple name of the other.
-					String qualifiedName = null;
-					String simpleName = null;
-					if (sig1.indexOf('.') == -1) {
-						qualifiedName = Signature.toString(sig2);
-						simpleName = Signature.toString(sig1);
-					} else {
-						qualifiedName = Signature.toString(sig1);
-						simpleName = Signature.toString(sig2);
-					}
-
-					// If the simple name resolves to the qualified name, we have a match.
-					result = qualifiedName.equals(resolveSimpleTypeName(type, simpleName, resolvedNameCache));
-				}
-			}
-		}
-
-		return result;
-	}
-	private static boolean needsToResolveName(IType type, String simpleName, boolean isForReflection) {
-		return !(type.isBinary() || (!isForReflection && simpleName.indexOf(PERIOD) > -1) || isPrimitiveOrVoid(simpleName));
-	}
-	/**
-	 * Returns the qualified name for the simple name within the scope of the type.
-	 * Returns null if the name can not be resolved.
-	 */
-	public static String resolveSimpleTypeName(IType type, String simpleName) throws JavaModelException {
-		return resolveSimpleTypeName(type, simpleName, null);
-	}
-	/**
-	 * Returns the qualified name for the simple name within the scope of the type.
-	 * Returns null if the name can not be resolved.
-	 */
-	public static String resolveSimpleTypeName(IType type, String simpleName, Map resolvedNameCache) throws JavaModelException {
-		return resolveSimpleTypeName(type, simpleName, resolvedNameCache, false);
-	}
-
-	/**
-	 * Returns the qualified name for the simple name within the scope of the type.
-	 * Returns null if the name can not be resolved.
-	 */
-	public static String resolveSimpleTypeName(IType type, String simpleName, Map resolvedNameCache, boolean isForReflection) throws JavaModelException {
-		if (!needsToResolveName(type, simpleName, isForReflection))
-			return simpleName;
-		String key = null, qualifiedName = null;
-		if (resolvedNameCache != null) {
-			key = type.getFullyQualifiedName() + RESOLVED_NAME + simpleName;
-			qualifiedName = (String) resolvedNameCache.get(key);
-		}
-		if (qualifiedName == null) {
-			String[][] result = getTypeNameInfo(type, simpleName, isForReflection);
-			if (result != null) {
-				String packName = result[0][0];
-				if (packName.length() == 0) {
-					qualifiedName = result[0][1];
-					if (isForReflection)
-						qualifiedName = qualifiedName.replace('.', '$');					
-				} else {
-					StringBuffer b = new StringBuffer();
-					b.append(result[0][0]).append(PERIOD);
-					String typeName = result[0][1];
-					if (isForReflection)
-						typeName = typeName.replace('.', '$');
-					b.append(typeName);
-					qualifiedName = b.toString();
-				}
-			} else {
-				qualifiedName = simpleName;
-			}
-			if (resolvedNameCache != null)
-				resolvedNameCache.put(key, qualifiedName);
-		}
-		return qualifiedName;
-	}
-	/**
-	 * Searches for a matching method and sets it in the
-	 * descriptor if found.
-	 */
-	public static IMethod searchForMatchingMethod(IType type, String methodName, String[] parmSigs) throws JavaModelException {
-		return searchForMatchingMethod(type, methodName, parmSigs, null);
-	}
-	/**
-	 * Searches for a matching method and sets it in the
-	 * descriptor if found.
-	 */
-	public static IMethod searchForMatchingMethod(IType type, String methodName, String[] parmSigs, Map resolvedNameCache) throws JavaModelException {
-
-		// First get all the methods by this name and with this many parms.
-		IMethod[] allMethods = type.getMethods();
-		List candidateMethods = new ArrayList();
-		for (int i = 0; i < allMethods.length; i++) {
-			int parmSigsLength = (parmSigs != null ? parmSigs.length : 0);
-			if ((allMethods[i].getElementName().equals(methodName)) && (allMethods[i].getNumberOfParameters() == parmSigsLength))
-				candidateMethods.add(allMethods[i]);
-		}
-
-		// For each candidate consider each parm for a match.
-		// Take the first one that matches on all parms.
-		IMethod next = null;
-		String[] nextParmSigs = null;
-		boolean found = false;
-		Iterator candidateIter = candidateMethods.iterator();
-		while (!found && (candidateIter.hasNext())) {
-			next = (IMethod) candidateIter.next();
-			nextParmSigs = next.getParameterTypes();
-			found = true;
-			for (int i = 0;(found && (i < nextParmSigs.length)); i++)
-				found &= matchTypeSignatures(type, parmSigs[i], nextParmSigs[i], resolvedNameCache);
-		}
-		return found ? next : null;
-	}
-
-	/**
-	* The returned Object[] will contain two entries.  The
-	* first will be the IJavaElement that was found and the
-	* second will be the qualifiedName used to find it.
-	*/
-	protected static Object[] findActualJavaElement(String qualifiedName, IJavaProject javaProject, JDOMAdaptor adaptor) {
-		Object[] result = new Object[2];
-		if (adaptor == null)
-			result[1] = qualifiedName;
-		else 
-			//Ensure the name is qualified
-			result[1] = getResolvedTypeName(qualifiedName, adaptor.getType(), adaptor.getTypeResolutionCache());
-		
-		result[0] = findJavaElement((String) result[1], javaProject, adaptor);
-		if (result[0] == null)
-			findInnerJavaElement(result, javaProject, adaptor);
-		return result;
-	}
-
-	/**
-	 * The returned Object[] will contain two entries.  The
-	 * first will be the IJavaElement that was found and the
-	 * second will be the qualifiedName used to find it.
-	 */
-	protected static void findInnerJavaElement(Object[] info, IJavaProject javaProject, JDOMAdaptor adaptor) {
-		String qualifiedName, innerName;
-		qualifiedName = (String) info[1];
-		int index = qualifiedName.lastIndexOf("."); //$NON-NLS-1$
-		if (index > 0) {
-			innerName = qualifiedName.substring(0, index);
-			innerName += "$"; //$NON-NLS-1$
-			innerName += qualifiedName.substring(index + 1, qualifiedName.length());
-			if (adaptor != null) {
-				//Ensure the name is qualified which it may not be if an inner class
-				innerName = getResolvedTypeName(innerName, adaptor.getType(), adaptor.getTypeResolutionCache());
-			}
-			info[1] = innerName;
-			info[0] = findJavaElement(innerName, javaProject, adaptor);
-			if (info[0] == null)
-				findInnerJavaElement(info, javaProject, adaptor);
-		}
-	}
-
-	protected static IJavaElement findJavaElement(String qualifiedName, IJavaProject javaProject, JDOMAdaptor adaptor) {
-		try {
-			if (javaProject != null) {
-				return javaProject.findElement(getPathFromQualifiedName(qualifiedName));
-			}
-		} catch (JavaModelException jme) {
-			System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] { qualifiedName, jme.getMessage()}))); //$NON-NLS-1$ = "Error looking up type: "
-		}
-		return null;
-	}
-	
-	protected static IPath getPathFromQualifiedName(String qualifiedName) {
-		return new Path(qualifiedName.replace('.', File.separatorChar) + ".java"); //$NON-NLS-1$
-	}
-	/* 
-	* Resolve a type name in the context of a Type.
-	* (Borrowed from org.eclipse.jdt.ui.codemanipulation.StubUtility.getResolvedTypeName())
-	* The input is a simple or qualified name, NOT a signature
-	* The output will be a qualified name, NOT a signature
-	*/
-	public static String getResolvedTypeName(String typeName, IType declaringType, Map typeCache) {
-		String name = typeName;
-		try {
-			name = JDOMSearchHelper.resolveSimpleTypeName(declaringType, typeName, typeCache, true);
-		} catch (JavaModelException e) {
-			// ignore
-		}
-		return name;
-	}
-
-	public static IType findType(String qualifiedName, boolean useAdvancedForInners, IJavaProject javaProject, JDOMAdaptor adaptor) {
-		try {
-			IJavaElement found = null;
-			String resolvedName = qualifiedName;
-			if (useAdvancedForInners) {
-				Object[] result = findActualJavaElement(qualifiedName, javaProject, adaptor);
-				found = (IJavaElement) result[0];
-				resolvedName = (String) result[1];
-			} else
-				found = findJavaElement(qualifiedName, javaProject, adaptor);
-			if (found != null)
-				if (found instanceof IClassFile)
-					return ((IClassFile) found).getType();
-				else if (found instanceof ICompilationUnit) {
-					ICompilationUnit foundCU = (ICompilationUnit) found;
-					// strip the ".java", lifted from CompilationUnit.getMainTypeName()
-					String cuMainTypeName = foundCU.getElementName();
-					cuMainTypeName = cuMainTypeName.substring(0, cuMainTypeName.length() - 5);
-					return foundCU.getType(cuMainTypeName);
-				} else if (found instanceof IType) {
-					int index = resolvedName.lastIndexOf('$'); //$NON-NLS-1$
-					if (index > -1)
-						return ((IType) found).getType(resolvedName.substring(index + 1, resolvedName.length()));
-					else
-						return (IType) found;
-				}
-		} catch (JavaModelException jme) {
-			System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] { qualifiedName, jme.getMessage()}))); //$NON-NLS-1$ = "Error looking up type: "
-		}
-		return null;
-	}
-	
-	public static IType findType(String packageName, String qualifiedTypeName, IJavaProject javaProject) {
-		try {
-			if (javaProject != null) {
-				return javaProject.findType(packageName, qualifiedTypeName.replace('$', '.'));
-			}
-		} catch (JavaModelException jme) {
-			System.out.println(ResourceHandler.getString("Error_Looking_Up_Type_ERROR_", (new Object[] { packageName + "." + qualifiedTypeName, jme.getMessage()}))); //$NON-NLS-1$ //$NON-NLS-2$ = "Error looking up type: "
-		}
-		return null;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaClassJDOMAdaptor.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaClassJDOMAdaptor.java
deleted file mode 100644
index 4393013..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaClassJDOMAdaptor.java
+++ /dev/null
@@ -1,672 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JavaClassJDOMAdaptor.java,v $
- *  $Revision: 1.22 $  $Date: 2005/10/18 14:58:18 $ 
- */
-
-import java.util.*;
-import java.util.logging.Level;
-
-import org.eclipse.core.resources.IResource;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.common.util.BasicEList;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.jdt.core.*;
-
-
-import org.eclipse.jem.internal.java.adapters.*;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-import org.eclipse.jem.internal.plugin.JavaPlugin;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.internal.impl.JavaClassImpl;
-import org.eclipse.jem.util.TimerTests;
-import org.eclipse.jem.util.UIContextDetermination;
-import org.eclipse.jem.util.logger.proxy.Logger;
-
-
-public class JavaClassJDOMAdaptor extends JDOMAdaptor implements IJavaClassAdaptor {
-	private static final String OBJECT_TYPE_NAME = "java.lang.Object"; //$NON-NLS-1$
-
-	/*
-	 * Step ids used for TimerTests of performance testing.
-	 */
-	public static final String REFLECT_CLASS = "Reflect JDOM Class"; //$NON-NLS-1$
-	public static final String REFLECT_METHODS = "Reflect all JDOM methods for a class"; //$NON-NLS-1$
-	public static final String REFLECT_FIELDS = "Reflect all JDOM fields for a class"; //$NON-NLS-1$
-	
-	
-	protected IType sourceType = null;
-	protected JavaReflectionAdapterFactory adapterFactory;
-	private Map typeResolutionCache = new HashMap(25);
-	private boolean hasReflectedFields, isReflectingFields;
-	private boolean hasReflectedMethods, isReflectingMethods;
-	
-	public JavaClassJDOMAdaptor(Notifier target, IJavaProject workingProject, JavaReflectionAdapterFactory inFactory) {
-		super(target, workingProject);
-		setAdapterFactory(inFactory);
-	}
-	
-	private Map existingFields = new HashMap(); 
-	/*
-	 * addFields - reflect our fields
-	 */
-	protected boolean addFields() {
-
-		// The algorithm we will use is:
-		// 1) Pass through the IField's of this class
-		//    a) If it is in existingFields, then add to newExisting the entry from
-		//       oldExisting (deleting from oldExisting at the same time), and flush the field. This is so next we re-get any changed parts of it.
-		//    b) else not existing, then create new field and add to the new fields list.
-		// 2) Remove from the fields list any still left in oldExisting. These are ones that no longer exist.
-		// 3) Add all of the news ones to the fields.
-		//       
-		IField[] fields = null;
-		try {
-			fields = getSourceType().getFields();
-		} catch (JavaModelException e) {
-			Logger.getLogger().log(e, Level.WARNING);
-			return false;	
-		}
-		XMIResource resource = (XMIResource) getJavaClassTarget().eResource();		
-		Field field = null;
-		JavaFieldJDOMAdaptor adapter = null;
-		Map newExisting = new HashMap(fields.length);
-		List newFields = new ArrayList();
-		for (int i = 0; i < fields.length; i++) {
-			IField ifield = fields[i];
-			field = (Field) existingFields.remove(ifield);	// Get the existing field (which is the value) from the collection keyed by IField.
-			if (field != null) {
-				// It is an existing method. So just put over to newExisting. Then flush it.
-				newExisting.put(ifield, field);
-				// Since this is a new method, it is not attached to a resource, so we need to explicitly create the adapter.
-				adapter = (JavaFieldJDOMAdaptor) EcoreUtil.getExistingAdapter(field, ReadAdaptor.TYPE_KEY);
-				if (adapter == null)
-					adapter = (JavaFieldJDOMAdaptor) getAdapterFactory().adaptNew(field, ReadAdaptor.TYPE_KEY);
-				else
-					adapter.flushReflectedValuesIfNecessaryNoNotification(true);
-				adapter.setSourceField(ifield);	// Give it this new IField
-			} else {
-				// It is a new method. Create the new method, add to newExisting, and add to newMethods list.
-				field = createJavaField(ifield, resource);
-				newExisting.put(ifield, field);				
-				newFields.add(field);
-				adapter = (JavaFieldJDOMAdaptor) getAdapterFactory().adaptNew(field, ReadAdaptor.TYPE_KEY);
-				if (adapter != null)
-					adapter.setSourceField(ifield);
-			}
-		}
-		
-		BasicEList fieldsList = (BasicEList) getJavaClassTarget().getFieldsGen();
-		if (!existingFields.isEmpty()) {
-			// Now any still left in old existing are deleted. So we make them proxies and then remove them from fields list.			
-			URI baseURI = resource.getURI();
-			Collection toDelete = existingFields.values();
-			for (Iterator itr = toDelete.iterator(); itr.hasNext();) {
-				InternalEObject m = (InternalEObject) itr.next();
-				String id = resource.getID(m);
-				if (id != null)
-					m.eSetProxyURI(baseURI.appendFragment(id));
-			}
-			fieldsList.removeAll(toDelete);
-		}
-		
-		if (!newFields.isEmpty()) {
-			// Now add in the news ones
-			fieldsList.addAllUnique(newFields);
-		}
-		
-		// Finally set current existing to the new map we created.
-		existingFields = newExisting;
-		return true;			
-	}
-	
-	private Map existingMethods = new HashMap(); 
-	/*
-	 * addMethods - reflect our methods. Merge in with the previous.
-	 */
-	protected boolean addMethods() {
-		// The algorithm we will use is:
-		// 1) Pass through the IMethod's of this class
-		//    a) If it is in existingMethods, then add to newExisting the entry from
-		//       oldExisting (deleting from oldExisting at the same time), and flush the method. This is so next we re-get any changed parts of it.
-		//    b) else not existing, then create new method and add to the new methods list.
-		// 2) Remove from the methods list any still left in oldExisting. These are ones that no longer exist.
-		// 3) Add all of the news ones to the methods.
-		//       
-		IMethod[] methods = null;
-		try {
-			methods = getSourceType().getMethods();
-		} catch (JavaModelException e) {
-			Logger.getLogger().log(e, Level.WARNING);
-			return false;	
-		}
-		XMIResource resource = (XMIResource) getJavaClassTarget().eResource();		
-		Method method = null;
-		JavaMethodJDOMAdaptor adapter = null;
-		Map newExisting = new HashMap(methods.length);
-		List newMethods = new ArrayList();
-		for (int i = 0; i < methods.length; i++) {
-			IMethod im = methods[i];
-			method = (Method) existingMethods.remove(im);	// Get the existing method (which is the value) from the collection keyed by IMethod.
-			if (method != null) {
-				// It is an existing method. So just put over to newExisting. Then flush it.
-				newExisting.put(im, method);
-				adapter = (JavaMethodJDOMAdaptor) retrieveAdaptorFrom(method);
-				if (adapter != null) {
-					adapter.flushReflectedValuesIfNecessaryNoNotification(true);
-					adapter.setSourceMethod(im);	// Give it this new IMethod
-				}
-			} else {
-				// It is a new method. Create the new method, add to newExisting, and add to newMethods list.
-				method = createJavaMethod(im, resource);
-				newExisting.put(im, method);				
-				newMethods.add(method);
-				// Since this is a new method, it is not attached to a resource, so we need to explicitly create the adapter.
-				adapter = (JavaMethodJDOMAdaptor) getAdapterFactory().adaptNew(method, ReadAdaptor.TYPE_KEY);
-				if (adapter != null)
-					adapter.setSourceMethod(methods[i]);
-			}
-		}
-		
-		BasicEList methodsList = (BasicEList) getJavaClassTarget().getMethodsGen();
-		if (!existingMethods.isEmpty()) {
-			// Now any still left in old existing are deleted. So we make them proxies and then remove them from methods list.
-			URI baseURI = resource.getURI();
-			Collection toDelete = existingMethods.values();
-			for (Iterator itr = toDelete.iterator(); itr.hasNext();) {
-				InternalEObject m = (InternalEObject) itr.next();
-				String id = resource.getID(m);
-				if (id != null)
-					m.eSetProxyURI(baseURI.appendFragment(id));
-			}
-			methodsList.removeAll(toDelete);
-		}
-		
-		if (!newMethods.isEmpty()) {
-			// Now add in the news ones
-			methodsList.addAllUnique(newMethods);
-		}
-		
-		// Finally set current existing to the new map we created.
-		existingMethods = newExisting;
-		return true;
-	}
-	/**
-	 * Clear source Type ;
-	 */
-	protected void clearSource() {
-		sourceType = null;
-	}
-
-	/**
-	 * Clear the reflected fields list.
-	 */
-	protected boolean flushFields() {
-		// First turn them all into proxies so that any holders will re-resolve to maybe the new one if class comes back.
-		existingFields.clear();
-		XMIResource res = (XMIResource) getJavaClassTarget().eResource();
-		URI baseURI = res.getURI();
-		List fields = getJavaClassTarget().getFieldsGen();
-		int msize = fields.size();
-		for (int i = 0; i < msize; i++) {
-			InternalEObject f = (InternalEObject) fields.get(i);
-			String id = res.getID(f);
-			if (id != null)
-				f.eSetProxyURI(baseURI.appendFragment(id));
-		}
-		fields.clear();	// Now we can clear it.
-		return true;
-		}
-	/**
-	 * Clear the implements list.
-	 */
-	protected boolean flushImplements() {
-		getJavaClassTarget().getImplementsInterfacesGen().clear();
-		return true;
-	}
-	/**
-	 * Clear the reflected methods list.
-	 */
-	protected boolean flushMethods() {
-		// First turn them all into proxies so that any holders will re-resolve to maybe the new one if class comes back.
-		existingMethods.clear();
-		XMIResource res = (XMIResource) getJavaClassTarget().eResource();
-		URI baseURI = res.getURI();
-		List methods = getJavaClassTarget().getMethodsGen();
-		int msize = methods.size();
-		for (int i = 0; i < msize; i++) {
-			InternalEObject m = (InternalEObject) methods.get(i);
-			String id = res.getID(m);
-			if (id != null)
-				m.eSetProxyURI(baseURI.appendFragment(id));
-		}
-		methods.clear();	// Now we can clear it.
-		return true;
-	}
-	protected boolean flushModifiers() {
-		JavaClass javaClassTarget = (JavaClass) getTarget();
-		javaClassTarget.setAbstract(false);
-		javaClassTarget.setFinal(false);
-		javaClassTarget.setPublic(false);
-		javaClassTarget.setKind(TypeKind.UNDEFINED_LITERAL);
-		return true;
-	}
-	protected boolean flushInnerClasses() {
-		getJavaClassTarget().getDeclaredClassesGen().clear();
-		return true;
-	}
-	/**
-	 * Clear the reflected values.
-	 */
-	protected boolean flushReflectedValues(boolean clearCachedModelObject) {
-		if (clearCachedModelObject)
-			setSourceType(null);
-		typeResolutionCache.clear();
-		flushModifiers();
-		flushSuper();
-		flushImplements();
-		if (clearCachedModelObject) {
-			// Don't flush these yet. We will try to reuse them on the next reflush. If clear model too, then flush them. This usually means class has been deleted, so why keep them around.
-			flushMethods();
-			flushFields();
-		}
-		// Even if we didn't flush the fields/methods, we do need to mark as not reflected so on next usage we will merge in the changes.
-		hasReflectedMethods = false;
-		hasReflectedFields = false;
-		
-		flushInnerClasses();
-		return true;
-	}
-
-	/**
-	 * @see com.ibm.etools.java.adapters.JavaReflectionAdaptor#postFlushReflectedValuesIfNecessary()
-	 */
-	protected void postFlushReflectedValuesIfNecessary(boolean isExisting) {
-		getJavaClassTarget().setReflected(false);
-		super.postFlushReflectedValuesIfNecessary(isExisting);
-	}
-
-	/**
-	 * Set the supertype to be null.
-	 */
-	protected boolean flushSuper() {
-		List targetSupers = getJavaClassTarget().primGetESuperTypes();
-		targetSupers.clear();
-		return true;
-	}
-	protected JavaReflectionAdapterFactory getAdapterFactory() {
-		return adapterFactory;
-	}
-	/**
-	 * getBinaryType - return the IType which describes our existing Java class file
-	 */
-	protected IType getBinaryType() {
-		return this.getBinaryType(((JavaClass) getTarget()).getQualifiedName());
-	}
-	/**
-	 * Return the target typed to a JavaClass.
-	 */
-	protected JavaClassImpl getJavaClassTarget() {
-		return (JavaClassImpl) getTarget();
-	}
-	public Object getReflectionSource() {
-		return getSourceType();
-	}
-	
-    /* (non-Javadoc)
-     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-     */
-    public boolean hasCachedReflectionSource() {
-        return sourceType != null;
-    }
-	/**
-	 * getSourceType - return the IType which describes our existing Java class or source file
-	 */
-	public IType getSourceType() {
-		if (sourceType == null) {
-			JavaClassImpl javaClass = (JavaClassImpl) getTarget();
-			sourceType = JDOMSearchHelper.findType(javaClass.getJavaPackage().getName(), javaClass.primGetName(), getSourceProject());
-		}
-		return sourceType;
-	}
-	/**
-	 * getSourceType - return the IType which describes our existing Java class or source file
-	 */
-	protected IType getType() {
-		return getSourceType();
-	}
-	protected Map getTypeResolutionCache() {
-		return typeResolutionCache;
-	}
-	/**
-	 * getValueIn method comment.
-	 */
-	public Object getValueIn(EObject object, EObject attribute) {
-		// At this point, this adapter does not dynamically compute any values,
-		// all values are pushed back into the target on the initial call.
-		return super.getValueIn(object, attribute);
-	}
-	/**
-	 * Return true if the sourceType is null or if
-	 * it is a binary type.
-	 */
-	public boolean isSourceTypeFromBinary() {
-		if (getSourceType() == null)
-			return false; //must be new?
-		return getSourceType().isBinary();
-	}
-
-
-	protected JavaClass reflectJavaClass(String qualifiedName) {
-		IType type = JDOMSearchHelper.findType(qualifiedName, true, getSourceProject(), this);
-		if (type != null)
-			return reflectJavaClass(type);
-		else
-			return createJavaClassRef(qualifiedName);
-	}
-	protected JavaClass reflectJavaClass(IType aType) {
-		if (aType != null) {
-			JavaClass javaClass = (JavaClass) JavaRefFactory.eINSTANCE.reflectType(aType.getFullyQualifiedName(), (EObject) getTarget());
-			if (javaClass != null) {
-				JavaClassJDOMAdaptor adaptor = (JavaClassJDOMAdaptor) EcoreUtil.getAdapter(javaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
-				if (adaptor != null)
-					adaptor.setSourceType(aType);
-			}
-			return javaClass;
-		}
-		return null;
-	}
-	/**
-	 * reflectValues - template method, subclasses override to pump values into target.
-	 * on entry: name, containing package (and qualified name), and document must be set.
-	 * Return true always and the JavaReflectionSynchronizer will flush with the type can
-	 * be found again.  In headless mode, return true only if the type is found.  This is
-	 * needed becauce most headless tasks are done under one operation and the JavaReflectionSynchronizer
-	 * may not have a chance to flush a bad reflection before the real type needs to be found and can be found.
-	 * JavaClass adaptor:
-	 * - set modifiers
-	 * - set name
-	 * - set reference to super
-	 * - create methods
-	 * - create fields
-	 * - add imports
-	 */
-	public boolean reflectValues() {
-		super.reflectValues();
-		boolean isHeadless = UIContextDetermination.getCurrentContext() == UIContextDetermination.HEADLESS_CONTEXT;
-		if (canReflect()) {
-			TimerTests.basicTest.startCumulativeStep(REFLECT_CLASS);
-			try {
-				ICompilationUnit cu = getSourceType().getCompilationUnit();
-				boolean isWC = cu != null ? cu.isWorkingCopy() : false;
-				IResource res = isWC ? getSourceType().getResource() : null;
-				// We are only interested in physical classes. If still just in working copy and not yet put out to
-				// disk, we don't should treat as not exist. Anything else is considered existing because we got past
-				// getSourceType.exists. This will return the truth for non-wc. But for wc types it will return true,
-				// even though not physically on disk (such as just creating it and hadn't saved it yet). So for wc types
-				// we need to test the actual resource.
-				// Test is OK if not wc, or if wc, then there is a res. and it is accessible.
-				if (!isWC || (res != null && res.isAccessible())) {
-					setModifiers();
-					setNaming();
-					try {
-						setSuper();
-					} catch (InheritanceCycleException e) {
-						JavaPlugin.getDefault().getLogger().log(e);
-					}
-					setImplements();
-					reflectInnerClasses();
-					//addImports();
-					if (isHeadless) {
-						registerWithFactory();
-						return true;
-					}
-				}
-			} finally {
-				TimerTests.basicTest.stopCumulativeStep(REFLECT_CLASS);
-			}
-		}
-		if (isHeadless)
-			return false;
-		else {
-			registerWithFactory();
-			return true;
-		}
-	}
-	
-	
-	/**
-	 * @return
-	 */
-	private boolean canReflect() {
-		return isResourceLoaded() && getSourceProject() != null && getSourceType() != null && getSourceType().exists();
-	}
-	public synchronized boolean reflectFieldsIfNecessary() {
-		if (reflectValuesIfNecessary() && canReflect()) {
-			if (!hasReflectedFields && !isReflectingFields) {
-				isReflectingFields = true;
-				try {
-					TimerTests.basicTest.startCumulativeStep(REFLECT_FIELDS);
-					addFields();
-					hasReflectedFields = true;
-				} catch (Throwable e) {
-					hasReflectedFields = false;
-					Logger logger = Logger.getLogger();
-					if (logger.isLoggingLevel(Level.WARNING)) {
-						logger.log(ResourceHandler.getString("Failed_reflecting_values_ERROR_"), Level.WARNING); //$NON-NLS-1$ = "Failed reflecting values!!!"
-						logger.logWarning(e); 
-					}					
-				} finally {
-					isReflectingFields = false;
-					TimerTests.basicTest.stopCumulativeStep(REFLECT_FIELDS);
-				}
-			}
-			return hasReflectedFields;
-		} else
-			return false;	// Couldn't reflect the base values, so couldn't do fields either
-	}
-	public synchronized boolean reflectMethodsIfNecessary() {
-		if (reflectValuesIfNecessary() && canReflect()) {
-			if (!hasReflectedMethods && !isReflectingMethods) {
-				isReflectingMethods = true;
-				try {
-					TimerTests.basicTest.startCumulativeStep(REFLECT_METHODS);
-					hasReflectedMethods = addMethods();
-				} catch (Throwable e) {
-					hasReflectedMethods = false;
-					Logger logger = Logger.getLogger();
-					if (logger.isLoggingLevel(Level.WARNING)) {
-						logger.log(ResourceHandler.getString("Failed_reflecting_values_ERROR_"), Level.WARNING); //$NON-NLS-1$ = "Failed reflecting values!!!"
-						logger.logWarning(e); 
-					}					
-				} finally {
-					isReflectingMethods = false;
-					if (!hasReflected)
-						flushMethods();	// Something bad happened, so we will do a complete flush to be on safe side.
-					TimerTests.basicTest.stopCumulativeStep(REFLECT_METHODS);
-				}
-			}
-			return hasReflectedMethods;
-		} else
-			return false;	// Couldn't reflect the base values, so couldn't do fields either
-	}
-	
-	private void registerWithFactory() {
-		getAdapterFactory().registerReflection(getJavaClassTarget().getQualifiedNameForReflection(), this);
-	}
-
-	/**
-	 * @see com.ibm.etools.java.adapters.ReflectionAdaptor#notifyChanged(new ENotificationImpl((InternalEObject)Notifier, int,(EStructuralFeature) EObject, Object, Object, int))
-	 */
-	public void notifyChanged(Notification notification) {
-		if (notification.getEventType() == Notification.REMOVING_ADAPTER
-			&& notification.getOldValue() == this
-			&& notification.getNotifier() == getTarget())
-			getAdapterFactory().unregisterReflection(getJavaClassTarget().getQualifiedNameForReflection());
-
-	}
-
-	protected void setAdapterFactory(JavaReflectionAdapterFactory inFactory) {
-		adapterFactory = inFactory;
-	}
-	/**
-	 * setImplements - set our implemented/super interfaces here
-	 * For an interface, these are superclasses.
-	 * For a class, these are implemented interfaces.
-	 */
-	protected void setImplements() {
-		try {
-			String[] interfaceNames = getSourceType().getSuperInterfaceNames();
-			JavaClass ref;
-			// needs work, the names above will be simple names if we are relfecting from a source file
-			List list = getJavaClassTarget().getImplementsInterfacesGen();
-			for (int i = 0; i < interfaceNames.length; i++) {
-				ref = reflectJavaClass(interfaceNames[i]);
-				list.add(ref);
-			}
-		} catch (JavaModelException npe) {
-			// name stays null and we carry on
-		}
-	}
-	/**
-	 * setModifiers - set the attribute values related to modifiers here
-	 */
-	protected void setModifiers() {
-		JavaClass javaClassTarget = (JavaClass) getTarget();
-		try {
-			javaClassTarget.setAbstract(Flags.isAbstract(getSourceType().getFlags()));
-			javaClassTarget.setFinal(Flags.isFinal(getSourceType().getFlags()));
-			javaClassTarget.setPublic(Flags.isPublic(getSourceType().getFlags()));
-			// Set type to class or interface, not yet handling EXCEPTION
-			if (getSourceType().isClass())
-				javaClassTarget.setKind(TypeKind.CLASS_LITERAL);
-			else
-				javaClassTarget.setKind(TypeKind.INTERFACE_LITERAL);
-		} catch (JavaModelException npe) {
-			Logger logger = JavaPlugin.getDefault().getLogger();
-			if (logger.isLoggingLevel(Level.WARNING))
-				logger.log(ResourceHandler.getString("Error_Introspecting_Flags_ERROR_", new Object[] { javaClassTarget.getQualifiedName(), npe.getMessage()}), Level.WARNING); //$NON-NLS-1$ = "error introspecting flags on {0}"
-		}
-	}
-	/**
-	 * setNaming - set the naming values here
-	 * 	- qualified name (package name + name) must be set first, that is the path to the real Java class
-	 *	- ID - simple name, identity within a package document
-	 * 	- null UUID
-	 */
-	protected void setNaming() {
-		/* Naming has been provided by the JavaReflectionKey 
-		JavaClass javaClassTarget = (JavaClass) getTarget();
-		String packageName = getSourceType().getPackageFragment().getElementName();
-		javaClassTarget.refSetUUID((String)null);
-		((XMIResource)javaClassTarget.eResource()).setID(javaClassTarget,getSourceType().getElementName());
-		*/
-	}
-	protected void setSourceType(IType aType) {
-		sourceType = aType;
-	}
-	/**
-	 * setSuper - set our supertype here, implemented interface are handled separately
-	 */
-	protected void setSuper() throws InheritanceCycleException {
-		String superName = null;
-		IType superType = null;
-		try {
-			if (!getSourceType().isInterface()) {
-				superName = getSourceType().getSuperclassName();
-				// binary types will always have fully-qualified super names, so no need to do any searching.
-				if (!getSourceType().isBinary() && superName != null && isTargetInner()) {
-					IType declaringType = getSourceType().getDeclaringType();
-					if (declaringType != null) {
-						//Get all parent InnerTypes
-						IType[] inners = declaringType.getTypes();
-						for (int i = 0; i < inners.length; i++) {
-							IType type = inners[i];
-							if (superName.equals(type.getElementName())) {
-								superName = declaringType.getElementName() + '.' + superName;
-								reflectInnerClasses(declaringType);
-								superType = type;
-								break;
-							}
-						}
-					}
-				}
-				
-				//Source files return null if extends does not exist.
-				if (superName == null && !getSourceType().getFullyQualifiedName().equals(OBJECT_TYPE_NAME))
-					superName = OBJECT_TYPE_NAME;
-				if (superName != null) {
-					JavaClass javaClassTarget = (JavaClass) getTarget();
-					if (superType != null)
-						javaClassTarget.setSupertype(reflectJavaClass(superType));
-					else
-						javaClassTarget.setSupertype(reflectJavaClass(superName));
-				}
-			}
-		} catch (JavaModelException npe) {
-		}
-	}
-	private boolean isTargetInner() {
-		JavaClassImpl javaClass = (JavaClassImpl) getTarget();
-		return (javaClass.getName().indexOf('$') != -1);
-	}
-	/**
-	 * Return true if the sourceType can be found.
-	 */
-	public boolean sourceTypeExists() {
-		return getSourceType() != null;
-	}
-	protected void reflectInnerClasses() {
-		IType[] innerClasses = null;
-		try {
-			innerClasses = getSourceType().getTypes();
-		} catch (JavaModelException e) {
-		}
-		if (innerClasses != null && innerClasses.length != 0) {
-			List declaredClasses = getJavaClassTarget().getDeclaredClassesGen();
-			JavaClass inner;
-			ResourceSet set = getTargetResource().getResourceSet();
-			String packageName = getSourceType().getPackageFragment().getElementName();
-			for (int i = 0; i < innerClasses.length; i++) {
-				inner = (JavaClass) JavaRefFactory.eINSTANCE.reflectType(packageName, innerClasses[i].getTypeQualifiedName(), set);
-				declaredClasses.add(inner);
-			}
-		}
-	}
-	protected void reflectInnerClasses(IType aType) {
-		IType[] innerClasses = null;
-		try {
-			innerClasses = aType.getTypes();
-		} catch (JavaModelException e) {
-		}
-		if (innerClasses != null && innerClasses.length != 0) {
-			ResourceSet set = getTargetResource().getResourceSet();
-			String packageName = aType.getPackageFragment().getElementName();
-			JavaClassImpl parentType = (JavaClassImpl) JavaRefFactory.eINSTANCE.reflectType(packageName, aType.getTypeQualifiedName(), set);
-			List declaredClasses = parentType.getDeclaredClassesGen();
-			JavaClass inner;
-			
-			
-			for (int i = 0; i < innerClasses.length; i++) {
-				inner = (JavaClass) JavaRefFactory.eINSTANCE.reflectType(packageName, innerClasses[i].getTypeQualifiedName(), set);
-				declaredClasses.add(inner);
-			}
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaFieldJDOMAdaptor.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaFieldJDOMAdaptor.java
deleted file mode 100644
index df005d6..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaFieldJDOMAdaptor.java
+++ /dev/null
@@ -1,291 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JavaFieldJDOMAdaptor.java,v $
- *  $Revision: 1.13 $  $Date: 2005/10/18 14:58:18 $ 
- */
-import java.util.Map;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.jdt.core.*;
-
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.internal.impl.FieldImpl;
-/**
- * Insert the type's description here.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public class JavaFieldJDOMAdaptor extends JDOMAdaptor {
-	private static final String BEGIN_COMMENT = "/*"; //$NON-NLS-1$
-	private static final String END_COMMENT = "*/"; //$NON-NLS-1$
-	protected IField sourceField = null;
-	protected IType parentType = null;
-	public JavaFieldJDOMAdaptor(Notifier target, IJavaProject workingProject) {
-		super(target, workingProject);
-	}
-	protected void clearSource() {
-		sourceField = null;
-	}
-	
-	protected boolean flushReflectedValues(boolean clearCachedModelObject) {
-		if (clearCachedModelObject)
-			clearSource();
-		FieldImpl field = getTargetField();
-		field.setInitializer(null);
-		field.setFinal(false);
-		field.setStatic(false);
-		field.setTransient(false);
-		field.setVolatile(false);
-		field.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
-		field.setEType(null);
-		return true;
-	}
-	
-	protected void postFlushReflectedValuesIfNecessary(boolean isExisting) {
-		getTargetField().setReflected(false);
-		super.postFlushReflectedValuesIfNecessary(isExisting);
-	}
-	/**
-	 * Return a String for the source starting after the field's name to the end of
-	 * the source range.  This will be the source after the name which could include comments.
-	 */
-	protected String getFieldInitializerSource() {
-		IOpenable openable = getSourceField().getOpenable();
-		try {
-			ISourceRange nameRange, sourceRange;
-			int start = -1, length = 0;
-			IBuffer buffer = openable.getBuffer();
-			if (buffer == null) {
-				return ""; //$NON-NLS-1$
-			}
-			nameRange = getSourceField().getNameRange();
-			start = nameRange.getOffset() + nameRange.getLength();
-			if (start != -1) {
-				sourceRange = getSourceField().getSourceRange();
-				if (sourceRange.getOffset() != -1)
-					length = sourceRange.getOffset() + sourceRange.getLength() - start;
-				return buffer.getText(start, length);
-			}
-			return null;
-		} catch (JavaModelException e) {
-			return ""; //$NON-NLS-1$
-		}
-	}
-	/**
-	 * Return the field source string without comments
-	 */
-	protected String getFieldInitializerSourceWithoutComments() {
-		String s = getFieldInitializerSource();
-		int start = 0;
-		int startComment = -1;
-		int endComment = -1;
-		while (start < s.length()) {
-			startComment = s.indexOf(BEGIN_COMMENT, start);
-			if (startComment > 0) {
-				String newString;
-				endComment = s.indexOf(END_COMMENT, start);
-				newString = s.substring(start, startComment);
-				s = newString + s.substring(endComment + END_COMMENT.length(), s.length());
-				start = 0;
-				startComment = -1;
-				endComment = -1;
-			} else {
-				start = s.length();
-			}
-		}
-		return s;
-	}
-	/**
-	 * getFieldInitializerString - parse the source for our source field 
-	 * 	and return the initialization string.
-	 *  Return null if no initialization string or constant value is present.
-	 * i.e. - public String foo = "foo default"; should return "foo default" (including quotes)
-	 */
-	protected String getFieldInitializerString() {
-		String result = null;
-		try {
-			if (!getParentType().isBinary()) {
-				String source = getFieldInitializerSourceWithoutComments();
-				if (source != null && source.length() != 0) {
-					int equalsPos = source.indexOf('=');//$NON-NLS-1$
-					int endPos = source.indexOf(',');//$NON-NLS-1$
-					if (endPos == -1)
-						endPos = source.length() - 1;
-					if (equalsPos != -1) {
-						// Copy from after "=" to before ";" or ","
-						result = source.substring(equalsPos + 1, endPos);
-						result = result.trim();
-					}
-				}
-			} else {
-				// Binary type, see if we can use the constant
-				// it's not clear from the API's, but this is probably only
-				// available for statics.
-				Object constantValue = getSourceField().getConstant();
-				// Need to convert the constant to a String
-				if (constantValue != null) {
-					result = constantValue.toString();
-					if (constantValue instanceof String) {
-						result = "\"" + result + "\""; //$NON-NLS-2$//$NON-NLS-1$
-					}
-				}
-			}
-		} catch (JavaModelException e) {
-			// punt
-		}
-		return result;
-	}
-	/**
-	 * getParentType - return the IType which corresponds to our parent JavaClass
-	 * we're going to do this a lot, so cache it.
-	 */
-	protected IType getParentType() {
-		if (parentType == null) {
-			Field targetField = (Field) getTarget();
-			JavaClass parentJavaClass = targetField.getJavaClass();
-			if (parentJavaClass != null) {
-				JavaClassJDOMAdaptor pa = (JavaClassJDOMAdaptor) EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
-				if (pa != null)
-					parentType = pa.getSourceType();
-			}
-		}
-		return parentType;
-	}
-	public Object getReflectionSource() {
-		return getSourceField();
-	}
-	
-    /* (non-Javadoc)
-     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-     */
-    public boolean hasCachedReflectionSource() {
-        return sourceField != null;
-    }
-	
-	/*
-	 * Used by Java Class JDOM adapter to create and set with a source field
-	 */	
-	public void setSourceField(IField field) {
-		sourceField = field;
-	}	
-	/**
-	 * getSourceField - return the IField which describes our implementing field
-	 */
-	protected IField getSourceField() {
-		if (sourceField == null || !sourceField.exists()) {
-			IType parent = this.getParentType();
-			if (parent != null)
-				sourceField = parent.getField(((Field) getTarget()).getName());
-		}
-		return sourceField;
-	}
-	public FieldImpl getTargetField() {
-		return (FieldImpl) getTarget();
-	}
-	protected IType getType() {
-		return getParentType();
-	}
-	protected Map getTypeResolutionCache() {
-		Field field = getTargetField();
-		if (field != null) {
-			JavaClass javaClass = field.getJavaClass();
-			if (javaClass != null) {
-				JDOMAdaptor classAdaptor = (JDOMAdaptor) retrieveAdaptorFrom(javaClass);
-				if (classAdaptor != null)
-					return classAdaptor.getTypeResolutionCache();
-			}
-		}
-		return null;
-	}
-	/**
-	 * getValueIn method comment.
-	 */
-	public Object getValueIn(EObject object, EObject attribute) {
-		// At this point, this adapter does not dynamically compute any values,
-		// all values are pushed back into the target on the initial call.
-		return super.getValueIn(object, attribute);
-	}
-	/**
-	 * reflectValues - template method, subclasses override to pump values into target.
-	 * on entry: name, containing package (and qualified name), and document must be set.
-	 * JavaClass adaptor:
-	 *	- set modifiers
-	 *	- set name
-	 * 	- set type
-	 */
-	public boolean reflectValues() {
-		super.reflectValues();
-		if (isResourceLoaded() && getSourceProject() != null && getSourceField() != null) {
-			setModifiers();
-			//	setNaming();
-			setType();
-			return true;
-		}
-		return false;
-	}
-	/**
-	 * setModifiers - set the attribute values related to modifiers here
-	 */
-	protected void setModifiers() {
-		Field javaFieldTarget = (Field) getTarget();
-		try {
-			String initializer = getFieldInitializerString();
-			if (initializer != null)
-				javaFieldTarget.setInitializer(createBlock(javaFieldTarget.getName(), initializer));
-			int flags = getSourceField().getFlags();
-			javaFieldTarget.setFinal(Flags.isFinal(flags));
-			javaFieldTarget.setStatic(Flags.isStatic(flags));
-			javaFieldTarget.setTransient(Flags.isTransient(flags));
-			javaFieldTarget.setVolatile(Flags.isVolatile(flags));
-			// Set visibility
-			if (Flags.isPublic(flags))
-				javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
-			else if (Flags.isPrivate(flags))
-				javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
-			else if (Flags.isProtected(flags))
-				javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
-			else
-				javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
-		} catch (JavaModelException npe) {
-			System.out.println(ResourceHandler.getString("Error_Introspecting_Flags_ERROR_", new Object[] {((XMIResource) javaFieldTarget.eResource()).getID(javaFieldTarget), npe.getMessage()})); //$NON-NLS-1$ = "error introspecting flags on {0}"
-		}
-	}
-	/**
-	 * setNaming - set the naming values here
-	 * 	- qualified name must be set first, that is the path to the real Java class
-	 *	- ID
-	 * 	- null UUID
-	 */
-	protected void setNaming() {
-		Field javaFieldTarget = (Field) getTarget();
-		JavaClass parent = javaFieldTarget.getContainingJavaClass();
-		((XMIResource) javaFieldTarget.eResource()).setID(javaFieldTarget, parent.getName() + "_" + javaFieldTarget.getName()); //$NON-NLS-1$
-	}
-	/**
-	 * setType - set our type here
-	 */
-	protected void setType() {
-		String typeName = null;
-		try {
-			typeName = typeNameFromSignature(getSourceField().getTypeSignature());
-		} catch (JavaModelException npe) {
-			// name stays null and we carry on
-		}
-		setFieldType(getTargetField(), typeName);
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaJDOMAdapterFactory.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaJDOMAdapterFactory.java
deleted file mode 100644
index ca2d2b4..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaJDOMAdapterFactory.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JavaJDOMAdapterFactory.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 21:13:53 $ 
- */
-import java.util.*;
-
-import org.eclipse.emf.common.notify.*;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.jdt.core.*;
-import org.eclipse.jem.internal.java.adapters.*;
-import org.eclipse.jem.internal.java.adapters.JavaReflectionAdapterFactory;
-import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor;
-/**
- * Insert the type's description here.
- * Creation date: (6/13/2000 1:20:31 PM)
- * @author: Administrator
- */
-public class JavaJDOMAdapterFactory extends JavaReflectionAdapterFactory {
-	
-	protected JavaReflectionSynchronizer synchronizer;
-	protected IJavaProject javaProject;
-/**
- * JavaJDOMAdapterFactory constructor comment.
- */
-public JavaJDOMAdapterFactory() {
-	super();
-}
-/**
- * JavaJDOMAdapterFactory constructor comment.
- */
-public JavaJDOMAdapterFactory(IJavaProject aJavaProject) {
-	this();
-	setJavaProject(aJavaProject);
-}
-protected ReflectionAdaptor createJavaClassAdaptor(Notifier target) {
-	return new JavaClassJDOMAdaptor(target, getJavaProject(), this);
-}
-protected ReflectionAdaptor createJavaFieldAdaptor(Notifier target) {
-	return new JavaFieldJDOMAdaptor(target, getJavaProject());
-}
-protected ReflectionAdaptor createJavaMethodAdaptor(Notifier target) {
-	return new JavaMethodJDOMAdaptor(target, getJavaProject());
-}
-/**
- *  Flush ALL adapters, worst case
- * We also want to ensure that the source types are also cleared
- * in this worst case scenario.
- */
-public void flushAll() {
-	doFlush(reflected.values(),true, true);
-}
-
-public List flushAllNoNotification() {
-	return doFlush(reflected.values(),true, false);
-}
-
-public void flushPackage(String packageName, boolean noFlushIfSourceFound) {
-	List adaptors = getReflectedForPackage(packageName, noFlushIfSourceFound);
-	doFlush(adaptors, true, true);
-}
-public List flushPackageNoNotification(String packageName, boolean noFlushIfSourceFound) {
-	List adaptors = getReflectedForPackage(packageName, noFlushIfSourceFound);
-	return doFlush(adaptors, true, false);
-}
-/**
- * Return a List of reflection adaptors that belong to 
- * the packageName.
- * @param packageName
- * @return
- */
-private List getReflectedForPackage(String packageName, boolean filterFoundTypes) {
-	if (packageName != null && !reflected.isEmpty()) {
-		isBusyIteratingReflected = true;
-		List result = null;
-		try {
-			Iterator it = reflected.entrySet().iterator();
-			Map.Entry entry;
-			String key;
-			JavaClassJDOMAdaptor adaptor;
-			while (it.hasNext()) {
-				entry = (Map.Entry) it.next();
-				adaptor = (JavaClassJDOMAdaptor) entry.getValue();
-				if (filterFoundTypes && adaptor.sourceType != null)
-					continue;
-				key = (String) entry.getKey();
-				if (key.startsWith(packageName) && key.indexOf('.', packageName.length() + 1) < 0) {
-					if (result == null)
-						result = new ArrayList();
-					result.add(entry.getValue());
-				}	
-			}
-		} finally {
-			finishedIteratingReflected();
-		}
-		if (result != null)
-			return result;
-	}
-	return Collections.EMPTY_LIST;
-}
-private List doFlush(Collection adaptors, boolean clearSourceType, boolean doNotify) {
-	if (!adaptors.isEmpty()) {
-		isBusyIteratingReflected = true;
-		List notifications = doNotify ? null : new ArrayList(adaptors.size());
-		try {
-			Notification notification;
-			Iterator i = adaptors.iterator();
-			JDOMAdaptor adaptor;
-			while (i.hasNext()) {
-				adaptor = (JDOMAdaptor) i.next();
-				if (doNotify)
-					adaptor.flushReflectedValuesIfNecessary(clearSourceType);
-				else {
-					notification = adaptor.flushReflectedValuesIfNecessaryNoNotification(clearSourceType);
-					if (notification != null)
-						notifications.add(notification);
-				}
-			}
-		} finally {
-			finishedIteratingReflected();
-		}
-		return notifications;
-	}
-	return Collections.EMPTY_LIST;
-}
-// Flush the adapter for a source object
-public void flushReflection(String source) {
-	JDOMAdaptor a = (JDOMAdaptor) reflected.get(source);
-	if (a != null)
-		a.flushReflectedValuesIfNecessary();
-}
-public Notification flushReflectionNoNotification(String source) {
-	JDOMAdaptor a = (JDOMAdaptor) reflected.get(source);
-	if (a != null)
-		return a.flushReflectedValuesIfNecessaryNoNotification(false);
-	return null;
-}
-
-public Notification flushReflectionPlusInnerNoNotification(String source) {
-	isBusyIteratingReflected = true;
-	Notification notification = null;
-	try {
-		String innerName = source + '$';
-		Iterator it = reflected.entrySet().iterator();
-		Map.Entry entry;
-		String key;
-		JavaReflectionAdaptor adaptor;
-		while (it.hasNext()) {
-			entry = (Map.Entry) it.next();
-			key = (String) entry.getKey();
-			if (key.equals(source) || key.startsWith(innerName)) {
-				adaptor = (JavaReflectionAdaptor) reflected.get(key);
-				if (adaptor != null) {
-					if (notification == null)
-						notification = adaptor.flushReflectedValuesIfNecessaryNoNotification(false);
-					else
-						((NotificationChain) notification).add(adaptor.flushReflectedValuesIfNecessaryNoNotification(false));
-				}
-			}
-		}
-	} finally {
-		finishedIteratingReflected();
-	}
-	return notification;
-
-}
-/**
- * Insert the method's description here.
- * Creation date: (11/2/2000 3:02:31 PM)
- * @return org.eclipse.jdt.core.api.IJavaProject
- */
-public IJavaProject getJavaProject() {
-	return javaProject;
-}
-/**
- * Create a Java Model listener which will flush invalidated adaptors.
- * This will cause those adapters to re-reflect their target object's contents.
- */
-protected void initializeSynchronizer() {
-	synchronizer = new JavaReflectionSynchronizer(this);
-}
-/**
- * Notify all JDOMAdapters which use the same target ICompilationUnit
- * Creation date: (8/17/2001 4:45:43 PM)
- */
-public void notifyContentChanged(ICompilationUnit targetCU) {
-
-	if (targetCU == null || reflected.values()==null) return ;
-	isBusyIteratingReflected = true;
-	try {
-		Iterator i = reflected.values().iterator();
-		while (i.hasNext()) {
-			Object a = (ReflectionAdaptor) i.next() ;
-			if (a instanceof JDOMAdaptor) {
-				JDOMAdaptor adaptor = (JDOMAdaptor) a;
-				IMember reflectionSource = (IMember) adaptor.getReflectionSource();
-				ICompilationUnit adapterCU = null ;
-				if (reflectionSource != null) {
-					try {
-					   adapterCU = reflectionSource.getCompilationUnit();
-					} catch (Throwable e) {} 
-				}
-				if (adapterCU != null && targetCU.equals(adapterCU)) {
-			       adaptor.contentChanged();
-				}
-			}
-		}
-	} finally {
-		finishedIteratingReflected();  	
-	}
-}
-/**
- * Insert the method's description here.
- * Creation date: (11/2/2000 3:02:31 PM)
- * @param newJavaProject org.eclipse.jdt.core.IJavaProject
- */
-public void setJavaProject(IJavaProject newJavaProject) {
-	javaProject = newJavaProject;
-	if (newJavaProject != null && synchronizer == null)
-		initializeSynchronizer();
-}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaMethodJDOMAdaptor.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaMethodJDOMAdaptor.java
deleted file mode 100644
index 5497877..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaMethodJDOMAdaptor.java
+++ /dev/null
@@ -1,364 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaMethodJDOMAdaptor.java,v $
- *  $Revision: 1.14 $  $Date: 2005/10/18 14:58:18 $ 
- */
-package org.eclipse.jem.internal.adapters.jdom;
-
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.jdt.core.*;
-
-import org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter;
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.internal.impl.MethodImpl;
-import org.eclipse.jem.util.TimerTests;
-
-/**
- * Java Method Reflection Adapter for JDOM (i.e. JDT model)
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public class JavaMethodJDOMAdaptor extends JDOMAdaptor implements IJavaMethodAdapter  {
-
-	/*
-	 * Step ids used for TimerTests of performance testing.
-	 */
-	public static final String REFLECT_METHOD = "Reflect JDOM Method"; //$NON-NLS-1$
-
-	protected IMethod sourceMethod = null;
-
-	protected IType parentType = null;
-
-	public JavaMethodJDOMAdaptor(Notifier target, IJavaProject workingProject) {
-		super(target, workingProject);
-	}
-
-	
-	protected boolean flushReflectedValues(boolean clearCachedModelObject) {
-		if (clearCachedModelObject)
-			clearSource();
-		MethodImpl method = (MethodImpl) getTarget();
-		method.setIsGenerated(false);
-		method.setFinal(false);
-		method.setNative(false);
-		method.setStatic(false);
-		method.setSynchronized(false);
-		method.setConstructor(false);
-		method.setAbstract(false);
-		method.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
-		method.setEType(null);
-		method.getParametersGen().clear();
-		method.getJavaExceptionsGen().clear();		
-		parentType = null;
-		return true;
-	}
-	
-	protected void postFlushReflectedValuesIfNecessary(boolean isExisting) {
-		((MethodImpl) getTarget()).setReflected(false);
-		super.postFlushReflectedValuesIfNecessary(isExisting);
-	}	
-	/**
-	 * addExceptions - reflect our exception list
-	 */
-	protected void addExceptions() {
-		try {
-			IMethod sourceMethod = getSourceMethod();
-			String[] exceptionNames = sourceMethod.getExceptionTypes();
-			List exceptions = ((MethodImpl) getTarget()).getJavaExceptionsGen();
-			for (int i = 0; i < exceptionNames.length; i++) {
-				exceptions.add(createJavaClassRef(typeNameFromSignature(exceptionNames[i])));
-			}
-		} catch (JavaModelException npe) {
-			// name stays null and we carry on
-		}
-	}
-	
-	
-	protected String[] getParameterNames() {
-		String[] parmNames = new String[0], parmTypeNames = getSourceMethod().getParameterTypes();
-		try {
-			parmNames = getSourceMethod().getParameterNames();
-		} catch (JavaModelException npe) {
-			// name stays null and we carry on
-		}
-		// Temp hack to work around a JavaModel bug, above call on a Binary method may return null
-		if (parmNames == null || parmNames.length == 0) {
-			parmNames = new String[parmTypeNames.length];
-			for (int i = 0; i < parmTypeNames.length; i++) {
-				parmNames[i] = "arg" + i;//$NON-NLS-1$
-			}
-		}	
-		return parmNames;
-	}
-
-	/**
-	 * addParameters - reflect our parms
-	 */
-	protected void addParameters() {
-		String[] parmTypeNames = getSourceMethod().getParameterTypes();
-		MethodImpl javaMethodTarget = (MethodImpl) getTarget();
-		List params = javaMethodTarget.getParametersGen();
-		for (int i = 0; i < parmTypeNames.length; i++) {
-			params.add(createJavaParameter(javaMethodTarget, null, typeNameFromSignature(parmTypeNames[i])));
-		}
-	}
-
-	protected void clearSource() {
-		sourceMethod = null;
-	}
-
-	protected JavaClass getContainingJavaClass() {
-		return ((Method) getTarget()).getContainingJavaClass();
-	}
-
-	/**
-	 * getParentType - return the IType which corresponds to our parent JavaClass we're going to do this a lot, so cache it.
-	 */
-	protected IType getParentType() {
-		if (parentType == null) {
-			Method targetMethod = (Method) getTarget();
-			JavaClass parentJavaClass = targetMethod.getContainingJavaClass();
-			JavaClassJDOMAdaptor pa = (JavaClassJDOMAdaptor) EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
-			if (pa != null)
-				parentType = pa.getSourceType();
-		}
-		return parentType;
-	}
-
-	/**
-	 * getParmTypeSignatures - return an array of Strings (in Signature format) for our parameter types For reflection purposes, we can only rely on
-	 * our UUID, since our parms may not yet be known. see org.eclipse.jdt.core.SourceMapper.convertTypeNamesToSigs()
-	 */
-	protected String[] getParmTypeSignatures() {
-		Method javaMethodTarget = (Method) getTarget();
-		String[] typeNames = getTypeNamesFromMethodID(((XMIResource) javaMethodTarget.eResource()).getID(javaMethodTarget));
-		if (typeNames == null)
-			return emptyStringArray;
-		int n = typeNames.length;
-		if (n == 0)
-			return emptyStringArray;
-		String[] typeSigs = new String[n];
-		try {
-			for (int i = 0; i < n; ++i) {
-				typeSigs[i] = Signature.createTypeSignature(new String(typeNames[i]), getParentType().isBinary());
-			}
-		} catch (IllegalArgumentException e) {
-			e.printStackTrace();
-		}
-		return typeSigs;
-	}
-
-	public Object getReflectionSource() {
-		return getSourceMethod();
-	}
-	
-    /* (non-Javadoc)
-     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-     */
-    public boolean hasCachedReflectionSource() {
-        return sourceMethod != null;
-    }
-
-	/*
-	 * Used by Java Class JDOM adapter to create and set with a source method/
-	 */	
-	public void primSetMethod(IMethod method) {
-		sourceMethod = method;
-	}
-	/**
-	 * getsourceMethod - return the IMethod which describes our implementing method
-	 */
-	public IMethod getSourceMethod() {
-		if ((sourceMethod == null) || (!sourceMethod.exists())) {
-			try {
-				IType parent = this.getParentType();
-				if (parent != null) {
-					String[] parmNames = this.getParmTypeSignatures();
-					sourceMethod = JDOMSearchHelper.searchForMatchingMethod(parent, ((Method) getTarget()).getName(), parmNames);
-				}
-			} catch (JavaModelException e) {
-				//do nothing
-			}
-		}
-		return sourceMethod;
-	}
-
-	protected IType getType() {
-		return getParentType();
-	}
-
-	protected Map getTypeResolutionCache() {
-		Method method = (Method) getTarget();
-		if (method != null) {
-			JavaClass javaClass = method.getJavaClass();
-			if (javaClass != null) {
-				JDOMAdaptor classAdaptor = (JDOMAdaptor) retrieveAdaptorFrom(javaClass);
-				if (classAdaptor != null)
-					return classAdaptor.getTypeResolutionCache();
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * getValueIn method comment.
-	 */
-	public Object getValueIn(EObject object, EObject attribute) {
-		// At this point, this adapter does not dynamically compute any values,
-		// all values are pushed back into the target on the initial call.
-		return super.getValueIn(object, attribute);
-	}
-
-	/**
-	 * reflectValues - template method, subclasses override to pump values into target. on entry: UUID, name, containing package (and qualified name),
-	 * and document must be set. Method adaptor: - set modifiers - set name - set return type - add parameters - add exceptions
-	 */
-	public boolean reflectValues() {
-		super.reflectValues();
-		try {
-			TimerTests.basicTest.startCumulativeStep(REFLECT_METHOD);
-			if (isResourceLoaded() && getSourceProject() != null && getSourceMethod() != null && sourceMethod.exists()) {
-				setModifiers();
-				setNaming();
-				setReturnType();
-				addParameters();
-				addExceptions();
-				return true;
-			}
-		} finally {
-			TimerTests.basicTest.stopCumulativeStep(REFLECT_METHOD);
-		}
-		return false;
-	}
-
-	/**
-	 * Set the generated flag if @generated is found in the source.
-	 */
-	protected void setGeneratedFlag() {
-		Method methodTarget = (Method) getTarget();
-		try {
-			String source = getSourceMethod().getSource();
-			if (source != null) {
-				int index = source.indexOf(Method.GENERATED_COMMENT_TAG);
-				if (index > 0)
-					methodTarget.setIsGenerated(true);
-			}
-		} catch (JavaModelException npe) {
-			//System.out.println(ResourceHandler.getString("Error_Setting_GenFlag_ERROR_", new Object[]
-			// {((XMIResource)methodTarget.eResource()).getID(methodTarget), npe.getMessage()})); //$NON-NLS-1$ = "error setting the generated flag on
-			// {0}, exception: {1}"
-		}
-	}
-
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter#reflectGeneratedIfNecessary()
-	 */
-	public boolean reflectGeneratedIfNecessary() {
-		if (reflectValuesIfNecessary()) {
-			setGeneratedFlag();
-			return true;
-		}
-		return false;
-	}
-	
-	public boolean reflectParamNamesIfNecessary() {
-		if (reflectValuesIfNecessary()) {
-			String [] paramNames = getParameterNames();
-			List param = ((MethodImpl)getTarget()).getParameters();
-			for (int i = 0; i < paramNames.length; i++) {
-				((JavaParameter)param.get(i)).setName(paramNames[i]);				
-			}
-			return true;
-		}
-		return false;
-	}
-	/**
-	 * setModifiers - set the attribute values related to modifiers here
-	 */
-	protected void setModifiers() {
-		Method methodTarget = (Method) getTarget();
-		try {
-			methodTarget.setFinal(Flags.isFinal(getSourceMethod().getFlags()));
-			methodTarget.setNative(Flags.isNative(getSourceMethod().getFlags()));
-			methodTarget.setStatic(Flags.isStatic(getSourceMethod().getFlags()));
-			methodTarget.setSynchronized(Flags.isSynchronized(getSourceMethod().getFlags()));
-			methodTarget.setConstructor(getSourceMethod().isConstructor());
-
-			JavaClass javaClass = getContainingJavaClass();
-			//Set abstract
-			if (javaClass.getKind().getValue() == TypeKind.INTERFACE)
-				methodTarget.setAbstract(true);
-			else
-				methodTarget.setAbstract(Flags.isAbstract(getSourceMethod().getFlags()));
-			// Set visibility
-			if (javaClass.getKind().getValue() == TypeKind.INTERFACE || Flags.isPublic(getSourceMethod().getFlags()))
-				methodTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
-			else if (Flags.isPrivate(getSourceMethod().getFlags()))
-				methodTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
-			else if (Flags.isProtected(getSourceMethod().getFlags()))
-				methodTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
-			else
-				//Visibility must be package
-				methodTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
-		} catch (JavaModelException npe) {
-			System.out
-					.println(ResourceHandler
-							.getString(
-									"Error_Introspecting_Flags_ERROR_", (new Object[] { ((XMIResource) methodTarget.eResource()).getID(methodTarget), npe.getMessage()}))); //$NON-NLS-1$ = "error introspecting flags on {0}, exception: {1}"
-		}
-	}
-
-	/**
-	 * setNaming - set the naming values here - qualified name must be set first, that is the path to the real Java class - ID - name-based UUID
-	 */
-	protected void setNaming() {
-		//
-		//	naming is currently a no-op since the name and UUID must be set prior to reflection
-		//	...and ID is redundant with UUID.
-		//	javaFieldTarget.setID(parent.getQualifiedName() + "_" + javaFieldTarget.getName());
-	}
-
-	/**
-	 * setType - set our return type here
-	 */
-	protected void setReturnType() {
-		String typeName = null;
-		try {
-			typeName = typeNameFromSignature(getSourceMethod().getReturnType());
-		} catch (JavaModelException npe) {
-			// name stays null and we carry on
-		}
-		if (typeName != null) {
-			Method javaMethodTarget = (Method) getTarget();
-			javaMethodTarget.setEType(createJavaClassRef(typeName));
-		}
-	}
-
-	/**
-	 * Insert the method's description here. Creation date: (10/3/2001 10:08:34 AM)
-	 * 
-	 * @param newSourceMethod
-	 *            org.eclipse.jdt.core.IMethod
-	 */
-	public void setSourceMethod(org.eclipse.jdt.core.IMethod newSourceMethod) {
-		sourceMethod = newSourceMethod;
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaModelListener.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaModelListener.java
deleted file mode 100644
index 11cf2b1..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaModelListener.java
+++ /dev/null
@@ -1,275 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JavaModelListener.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 21:13:53 $ 
- */
-
-import java.util.*;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jdt.core.*;
-
-/**
- * Insert the type's description here.
- * Creation date: (10/31/2000 1:13:12 PM)
- * @author: Administrator
- */
-public abstract class JavaModelListener implements IElementChangedListener {
-	
-/**
- * JavaModelListener constructor comment.
- */
-public JavaModelListener() {
-	this(ElementChangedEvent.POST_CHANGE);
-}
-
-public JavaModelListener(int eventsToListen) {
-	JavaCore.addElementChangedListener(this, eventsToListen);
-}
-/**
- * One or more attributes of one or more elements maintained by
- * the Java model have changed. The specific details of the change
- * are described by the given <code>ElementChangedEvent</code>.
- *
- * @see ElementChangedEvent
- */
-public void elementChanged(ElementChangedEvent event) {
-	processDelta((IJavaElementDelta) event.getSource());
-}
-/**
- * Generically dispatch the children of the delta.
- *
- */
-protected void processChildren(IJavaElement element, IJavaElementDelta delta) {
-	IJavaElementDelta[] children = delta.getAffectedChildren();
-	for (int i = 0; i < children.length; i++) {
-		processDelta(children[i]);
-	}
-}
-/**
- * Source context has been changed.
- * Creation date: (8/17/2001 3:58:31 PM)
- * @param param org.eclipse.jdt.core.IJavaElementDelta
- */
-protected void processContentChanged(IJavaElementDelta delta) {
-	  // override to implement specific behavior
-}
-/**
- * Dispatch the detailed handling of an element changed event.
- *
- * @see ElementChangedEvent
- */
-public void processDelta(IJavaElementDelta delta) {
-	IJavaElement element = delta.getElement();
-	
-	switch (element.getElementType()) {
-		case IJavaElement.JAVA_MODEL :
-			processJavaElementChanged((IJavaModel) element, delta);
-			break;
-		case IJavaElement.JAVA_PROJECT :
-			processJavaElementChanged((IJavaProject) element, delta);
-			break;
-		case IJavaElement.PACKAGE_FRAGMENT_ROOT :
-			processJavaElementChanged((IPackageFragmentRoot) element, delta);
-			break;
-		case IJavaElement.PACKAGE_FRAGMENT :
-			processJavaElementChanged((IPackageFragment) element, delta);
-			break;
-		case IJavaElement.COMPILATION_UNIT :
-			processJavaElementChanged((ICompilationUnit) element, delta);
-			processContentChanged(delta) ;   
-			break;
-		case IJavaElement.CLASS_FILE :
-			processJavaElementChanged((IClassFile) element, delta);
-			break;
-		case IJavaElement.TYPE :
-			processJavaElementChanged((IType) element, delta);
-			break;
-		// Note: if we are to update the Method/Field adapters, we should process the
-		//       IJavaElement.METHOD and IJavaElement.FIELD 
-	}	
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(IClassFile element, IJavaElementDelta delta) {
-	// override to implement specific behavior
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(ICompilationUnit element, IJavaElementDelta delta) {
-	processChildren(element, delta);
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(IJavaModel element, IJavaElementDelta delta) {
-	processChildren(element, delta);
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(IJavaProject element, IJavaElementDelta delta) {
-	processChildren(element, delta);
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(IPackageFragment element, IJavaElementDelta delta) {
-	processChildren(element, delta);
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(IPackageFragmentRoot element, IJavaElementDelta delta) {
-	processChildren(element, delta);
-}
-/**
- * Handle the change for a single element, children will be handled separately.
- *
- */
-protected void processJavaElementChanged(IType element, IJavaElementDelta delta) {
-	// override to implement specific behavior
-}
-
-protected boolean isClassPathChange(IJavaElementDelta delta) {
-	int flags = delta.getFlags();
-	return (delta.getKind() == IJavaElementDelta.CHANGED && ((flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0) || ((flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0) || ((flags & IJavaElementDelta.F_REORDER) != 0));
-}
-
-/**
- * Method isClasspathResourceChange.
- * @param delta
- * @return boolean
- */
-protected boolean isClasspathResourceChange(IJavaElementDelta delta) {
-	if ((delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0)
-		return true;
-	IResourceDelta[] resources = delta.getResourceDeltas();
-	if (resources == null)
-		return false;
-	IPath path = null;
-	for (int i = 0; i < resources.length; i++) {
-		if (resources[i].getKind() == IResourceDelta.CHANGED) {
-			path = resources[i].getProjectRelativePath();
-			if (isAlsoClasspathChange(path))
-				return true;
-		}
-	}
-	return false;
-}
-
-/**
- * Is this path also a classpath change type of resource. If so, return true.
- * Subclasses may override. Default is false.
- * @param path
- * @return
- * 
- * @since 1.0.0
- */
-protected boolean isAlsoClasspathChange(IPath path) {
-	return false;
-}
-
-/**
- * This method will check to see if a <code>javaProject</code> is a project in the
- * classpath of the adapterFactory java project.
- */
-protected boolean isInClasspath(IJavaProject javaProject) {
-	IJavaProject adapterJavaProject = getJavaProject();
-	if (javaProject.equals(adapterJavaProject))
-		return true;
-	return isInClasspath(javaProject, adapterJavaProject, true, new HashSet());
-}
-
-/**
- * Get the java project that we are interested in.
- * @return
- * 
- * @since 1.0.0
- */
-protected abstract IJavaProject getJavaProject();
-
-/*
- * test to see if the testProject is in the classpath (including from any referenced projects) of the target project.
- * Keep track of those already visited so as not to visit again.
- * TODO This should be made private.
- */
-protected boolean isInClasspath(IJavaProject testProject, IJavaProject targetProject, boolean isFirstLevel, Set visited) {
-	if (visited.contains(targetProject))
-		return false;
-	visited.add(targetProject);
-	IClasspathEntry[] entries = null;
-	try {
-		entries = targetProject.getRawClasspath();
-	} catch (JavaModelException e) {
-		return false;
-	}
-	IClasspathEntry entry, resEntry;
-	IJavaProject proj = null;
-	List projects = null;
-	for (int i = 0; i < entries.length; i++) {
-		entry = entries[i];
-		if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
-			resEntry = JavaCore.getResolvedClasspathEntry(entry);
-			proj = getJavaProject(entry);
-			if (isFirstLevel || resEntry.isExported()) {
-				if (proj.equals(testProject))
-					return true;
-				else {
-					if (projects == null)
-						projects = new ArrayList();
-					projects.add(proj);
-				}
-			}
-		}
-	}
-	return isInClasspath(testProject, projects, false, visited);
-}
-
-/*
- * See if the testProject is in the classpath of any of the list of projects or in any project that an entry
- * in the list may of visited.
- * TODO This should be made private.
- */
-protected boolean isInClasspath(IJavaProject testProject, List someJavaProjects, boolean isFirstLevel, Set visited) {
-	if (someJavaProjects == null)
-		return false;
-	int size = someJavaProjects.size();
-	IJavaProject javaProj = null;
-	for (int i = 0; i < size; i++) {
-		javaProj = (IJavaProject) someJavaProjects.get(i);
-		return isInClasspath(testProject, javaProj, isFirstLevel, visited);
-	}
-	return false;
-}
-
-protected IJavaProject getJavaProject(IClasspathEntry entry) {
-	IProject proj = getWorkspaceRoot().getProject(entry.getPath().segment(0));
-	if (proj != null)
-		return JavaCore.create(proj);
-	return null;
-}
-
-protected IWorkspaceRoot getWorkspaceRoot() {
-	return ResourcesPlugin.getWorkspace().getRoot();
-}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaReflectionSynchronizer.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaReflectionSynchronizer.java
deleted file mode 100644
index 6969eb5..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/adapters/jdom/JavaReflectionSynchronizer.java
+++ /dev/null
@@ -1,322 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.adapters.jdom;
-/*
- *  $RCSfile: JavaReflectionSynchronizer.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 21:13:53 $ 
- */
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.jdt.core.*;
-
-import org.eclipse.jem.internal.plugin.JavaPlugin;
-import org.eclipse.jem.util.logger.proxy.Logger;
-
-/**
- * Insert the type's description here.
- * Creation date: (11/1/2000 11:42:05 AM)
- * @author: Administrator
- */
-public class JavaReflectionSynchronizer extends JavaModelListener {
-	
-	protected JavaJDOMAdapterFactory fAdapterFactory;
-
-	protected boolean flushedAll = false;
-	protected List flushTypes = new ArrayList();
-	protected List flushTypePlusInner = new ArrayList();
-	protected List notifications = new ArrayList();
-	/**
-	 * JavaReflectionSynchronizer constructor comment.
-	 */
-	public JavaReflectionSynchronizer(JavaJDOMAdapterFactory synchronizee) {
-		super();
-		fAdapterFactory = synchronizee;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#getJavaProject()
-	 */
-	protected IJavaProject getJavaProject() {
-		return getAdapterFactory().getJavaProject();
-	}	
-	/**
-	 * Tell the reflection factory to flush the passed IType
-	 */
-	protected Notification doFlush(IType element) {
-		return getAdapterFactory().flushReflectionNoNotification(element.getFullyQualifiedName());
-	}
-	
-	/*
-	 * Flush the compilation unit and any inner classes since we don't if they may or may not of changed.
-	 */
-	protected Notification doFlush(ICompilationUnit element) {
-		return getAdapterFactory().flushReflectionPlusInnerNoNotification(getFullNameFromElement(element));
-	}
-	
-	protected void flush(IType element) {
-		if (!flushTypes.contains(element))
-			flushTypes.add(element);
-	}
-	/*
-	 * flush the compilation unit. Since we don't know if inner classes may also
-	 * of been affected, they to will be flushed.
-	 */
-	protected void flush(ICompilationUnit element) {
-		if (!flushTypePlusInner.contains(element))
-			flushTypePlusInner.add(element);		
-	}
-	protected void flushPackage(String packageName, boolean noFlushIfSourceFound) {
-		notifications.addAll(getAdapterFactory().flushPackageNoNotification(packageName, true));
-	}
-	protected JavaJDOMAdapterFactory getAdapterFactory() {
-		return fAdapterFactory;
-	}
-	
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 *
-	 */
-	protected void processJavaElementChanged(ICompilationUnit element, IJavaElementDelta delta) {
-		switch (delta.getKind()) {
-			case IJavaElementDelta.CHANGED : {
-				// A file save had occurred. It doesn't matter if currently working copy or not.
-				// It means something has changed to the file on disk, but don't know what.
-				if ((delta.getFlags() & IJavaElementDelta.F_PRIMARY_RESOURCE) != 0) {
-					flush(element);	// Flush everything, including inner classes.					
-				} else if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) == 0 && 
-						(delta.getFlags() & IJavaElementDelta.F_CHILDREN) != 0)  //A type may have been added or removed.
-					processChildren(element, delta);
-				break;
-			}
-			case IJavaElementDelta.REMOVED :
-			case IJavaElementDelta.ADDED :
-				if (!element.isWorkingCopy())
-					disAssociateSourcePlusInner(getFullNameFromElement(element));
-				break;
-		}
-	}
-	
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 *
-	 */
-	protected void processJavaElementChanged(IJavaProject element, IJavaElementDelta delta) {
-		if (isInClasspath(element)) {
-			if (delta.getKind() == IJavaElementDelta.REMOVED) {
-				if (element.equals(getAdapterFactory().getJavaProject()))
-					stopSynchronizer();
-				else
-					flushAll(); //another dependent project has changed so flush all to be safe
-				return;
-			} else if (delta.getKind() == IJavaElementDelta.ADDED || isClasspathResourceChange(delta)) {
-				flushAll();
-				return;
-			}
-			processChildren(element, delta);
-		}
-	}
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 */
-	protected void processJavaElementChanged(IClassFile element, IJavaElementDelta delta) {
-		int kind = delta.getKind();
-		if (kind == IJavaElementDelta.REMOVED || kind == IJavaElementDelta.ADDED) {
-			// It doesn't matter if totally removed or just moved somewhere else, we will clear out and remove the
-			// adapter because there could be a rename which would be a different class.
-			// Currently the element is already deleted and there is no way to find the types in the unit to remove.
-			// So instead we ask factory to remove all it any that start with it plus for inner classes.
-			disAssociateSourcePlusInner(getFullNameFromElement(element));
-			return; // Since the classfile was removed we don't need to process the children (actually the children list will be empty
-		}
-		IJavaElementDelta[] children = delta.getAffectedChildren();
-		for (int ii = 0; ii < children.length; ii++) {
-			processDelta(children[ii]);
-		}
-	}
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 *
-	 */
-	protected void processJavaElementChanged(IPackageFragmentRoot element, IJavaElementDelta delta) {
-		if (flushedAll)
-			return;
-		if (isClassPathChange(delta))
-			flushAll();
-		else
-			super.processJavaElementChanged(element, delta);
-	}
-	
-	/* 
-	 * We will force the flushing of all adaptors for the given package name.
-	 * This is necessary if a type was reflected prior to the package existing or
-	 * if the package is deleted.
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#processJavaElementChanged(org.eclipse.jdt.core.IPackageFragment, org.eclipse.jdt.core.IJavaElementDelta)
-	 */
-	protected void processJavaElementChanged(IPackageFragment element, IJavaElementDelta delta) {
-		switch (delta.getKind()) {
-			case IJavaElementDelta.ADDED : {
-				if (delta.getAffectedChildren().length == 0)
-					flushPackage(delta.getElement().getElementName(), true);
-				break;
-			}
-			case IJavaElementDelta.REMOVED :{
-				if (delta.getAffectedChildren().length == 0)
-					getAdapterFactory().flushPackage(delta.getElement().getElementName(), false);
-				break;
-			}
-			default :
-				super.processJavaElementChanged(element, delta);
-		}
-	}
-
-	/**
-	 * Handle the change for a single element, children will be handled separately.
-	 *
-	 */
-	protected void processJavaElementChanged(IType element, IJavaElementDelta delta) {
-		int kind = delta.getKind();
-		if (kind == IJavaElementDelta.REMOVED || kind == IJavaElementDelta.ADDED) {
-			disAssociateSourcePlusInner(element.getFullyQualifiedName());
-		} else {
-			flush(element);
-			processChildren(element, delta);
-			// Note, if a method element or a field was changed, there may be delta.getAffectedChildren()
-			//       that will have to be processed if we are to update the JavaMethod/JavaField JDOMAdaptor s.	
-		}
-	}
-	/**
-	 * Given that an IType does not exists anymore, assume
-	 * that the type's name is package.filename (without the .java)
-	 * If we are wrong (if, then a rare case),  we will flush.
-	 * Next access will induce a reflection attempt.
-	 * @deprecated This doesn't look like it is ever called. It someone else calls it, please contact development to see if right method to be called.
-	 */
-	protected void processRemoveOrAdd(ICompilationUnit element) {
-		disAssociateSource(getFullNameFromElement(element));
-	}
-	protected String getFullNameFromElement(IJavaElement element) {
-		String name = element.getElementName();
-		if (element == null || name.length() <= 5 || !name.substring(name.length() - 5).equals(".java")) { //$NON-NLS-1$
-			// Should not be here, 
-			Logger logger = JavaPlugin.getDefault().getLogger();
-			if (logger.isLoggingLevel(Level.FINE))
-				logger.log("Invalid .java file: " + name, Level.FINE); //$NON-NLS-1$
-			// Make a guess, at worst case, nothing will come out of this.
-			int index = name.lastIndexOf("."); //$NON-NLS-1$
-			if (index >= 0)
-				name = name.substring(0, index) + ".java"; // rename the extension to .java //$NON-NLS-1$
-			else
-				name = name + ".java"; //$NON-NLS-1$
-		}
-		if (element.getParent().getElementName() == null || element.getParent().getElementName().length() == 0)
-			return name.substring(0, name.length() - 5);
-		else
-			return element.getParent().getElementName() + "." + name.substring(0, name.length() - 5); //$NON-NLS-1$
-	}
-	/**
-	 * Stop the synchronizer from listening to any more changes.
-	 */
-	public void stopSynchronizer() {
-		JavaCore.removeElementChangedListener(this);
-	}
-	/**
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#elementChanged(ElementChangedEvent)
-	 */
-	public void elementChanged(ElementChangedEvent event) {
-		try {
-			flushTypes.clear();
-			flushTypePlusInner.clear();
-			notifications.clear();
-			super.elementChanged(event);
-			flushTypes();
-			processNotifications();
-		} finally {
-			flushedAll = false;
-			flushTypes.clear();
-			flushTypePlusInner.clear();
-			notifications.clear();
-		}
-	}
-	/**
-	 * 
-	 */
-	private void flushTypes() {
-		if (!flushTypes.isEmpty()) {
-			IType type = null;
-			Notification not;
-			for (int i = 0; i < flushTypes.size(); i++) {
-				type = (IType) flushTypes.get(i);
-				not = doFlush(type);
-				if (not != null)
-					notifications.add(not);
-			}
-		}
-		if (!flushTypePlusInner.isEmpty()) {
-			ICompilationUnit unit = null;
-			Notification not;
-			for (int i = 0; i < flushTypePlusInner.size(); i++) {
-				unit = (ICompilationUnit) flushTypePlusInner.get(i);
-				not = doFlush(unit);
-				if (not != null)
-					notifications.add(not);
-			}
-		}		
-	}
-	/**
-	 * @param notifications
-	 */
-	private void processNotifications() {
-		Notifier notifier;
-		Notification not;
-		for (int i = 0; i < notifications.size(); i++) {
-			not = (Notification) notifications.get(i);
-			notifier = (Notifier) not.getNotifier();
-			if (notifier != null)
-				try {
-					notifier.eNotify(not);
-				} catch (Exception e) {
-					JavaPlugin.getDefault().getLogger().log(e); //catch exceptions so all notifications are processed
-				} 
-		}
-	}
-	protected void disAssociateSource(String qualifiedName) {
-		Notification not = getAdapterFactory().disAssociateSource(qualifiedName, false);
-		if (not != null)
-			notifications.add(not);
-	}
-	protected void disAssociateSourcePlusInner(String qualifiedName) {
-		Notification not = getAdapterFactory().disAssociateSourcePlusInner(qualifiedName, false);
-		if (not != null)
-			notifications.add(not);
-	}
-	protected void flushAll() {
-		notifications.addAll(getAdapterFactory().flushAllNoNotification());
-		flushedAll = true;
-	}
-	/**
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#processChildren(IJavaElement, IJavaElementDelta)
-	 */
-	protected void processChildren(IJavaElement element, IJavaElementDelta delta) {
-		if (!flushedAll)
-			super.processChildren(element, delta);
-	}
-	/**
-	 * @see org.eclipse.jem.internal.adapters.jdom.JavaModelListener#processDelta(IJavaElementDelta)
-	 */
-	public void processDelta(IJavaElementDelta delta) {
-		if (!flushedAll)
-			super.processDelta(delta);
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/IJavaProjectInfo.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/IJavaProjectInfo.java
deleted file mode 100644
index 7ca3108..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/IJavaProjectInfo.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.plugin;
-
-/**
- * Insert the type's description here.
- * Creation date: (05/07/01 10:06:28 PM)
- * @author: Administrator
- */
-public interface IJavaProjectInfo {
-public String getSourcePath();
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaEMFNature.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaEMFNature.java
deleted file mode 100644
index 82f9c33..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaEMFNature.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.plugin;
-/*
- * $RCSfile: JavaEMFNature.java,v $ $Revision: 1.15 $ $Date: 2005/09/14 23:30:27 $
- */
-
-import java.util.List;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.emf.common.notify.AdapterFactory;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.jdt.core.JavaCore;
-
-import org.eclipse.jem.internal.adapters.jdom.JavaJDOMAdapterFactory;
-import org.eclipse.jem.internal.java.adapters.*;
-import org.eclipse.jem.java.adapters.JavaXMIFactory;
-import org.eclipse.jem.util.emf.workbench.EMFWorkbenchContextBase;
-import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverter;
-import org.eclipse.jem.util.emf.workbench.nature.EMFNature;
-import org.eclipse.jem.workbench.utility.IJavaEMFNature;
-import org.eclipse.jem.workbench.utility.JemProjectUtilities;
-
-public class JavaEMFNature extends EMFNature implements IJavaEMFNature {
-/**
- * JavaMOFNatureRuntime constructor comment.
- */
-public JavaEMFNature() {
-	super();
-}
-/**
- * Get a IJavaMOFNatureRuntime that corresponds to the supplied project.
- * @return IJavaMOFNatureRuntime
- * @param project com.ibm.itp.core.api.resources.IProject
- */
-public static JavaEMFNature createRuntime(IProject project) throws CoreException {
-	if(!hasRuntime(project))
-		if (JavaCore.create(project).exists())
-			addNatureToProject(project, IJavaEMFNature.NATURE_ID);
-		else
-			return null;
-
-	return getRuntime(project);
-}
-
-/**
- * Return the nature's ID.
- */
-public java.lang.String getNatureID() {
-	return IJavaEMFNature.NATURE_ID;
-}
-/**
- * Return the ID of the plugin that this nature is contained within.
- */
-protected java.lang.String getPluginID() {
-	return JavaPlugin.getDefault().getBundle().getSymbolicName();
-}
-/**
- * Get a IJavaMOFNatureRuntime that corresponds to the supplied project.
- * First check for registered natures.
- * @return IJavaMOFNatureRuntime
- * @param project com.ibm.itp.core.api.resources.IProject
- */
-public static JavaEMFNature getRuntime(IProject project) {
-	JavaEMFNature nature = null;
-	List runtimes = EMFNature.getRegisteredRuntimes(project);
-	for (int i=0; i<runtimes.size(); i++) {
-		if (runtimes.get(i) instanceof JavaEMFNature)
-			nature = (JavaEMFNature) runtimes.get(i);
-	}
-	if (nature == null)
-		nature = primGetRuntime(project);
-	return nature;
-}
-/**
- * Return whether or not the project has a runtime created on it.
- * Check for registered natures first.
- * @return boolean
- * @param project com.ibm.itp.core.api.resources.IProject
- */
-public static boolean hasRuntime(IProject project) {
-	JavaEMFNature nature = null;
-	List runtimes = EMFNature.getRegisteredRuntimes(project);
-	for (int i=0; i<runtimes.size(); i++) {
-		if (runtimes.get(i) instanceof JavaEMFNature)
-			nature = (JavaEMFNature) runtimes.get(i);
-	}
-	if (nature == null)
-		return primHasRuntime(project);
-	else
-		return true;
-
-}
-/**
- * Get a IJavaMOFNatureRuntime that corresponds to the supplied project.
- * Do not check for other registered types.
- * @return IJavaMOFNatureRuntime
- * @param project com.ibm.itp.core.api.resources.IProject
- */
-public static JavaEMFNature primGetRuntime(IProject project) {
-	try {
-		return (JavaEMFNature) project.getNature(IJavaEMFNature.NATURE_ID);
-	} catch (CoreException e) {
-		return null;
-	}
-}
-/**
- * Return whether or not the project has a runtime created on it.
- * Do not check for registered nature ids.
- * @return boolean
- * @param project com.ibm.itp.core.api.resources.IProject
- */
-public static boolean primHasRuntime(IProject project) {
-	try {
-		return project.hasNature(IJavaEMFNature.NATURE_ID);
-	} catch (CoreException e) {
-		return false;
-	}
-}
-
-/**
- * primary contribute to context
- */
-public void primaryContributeToContext(EMFWorkbenchContextBase aNature) {
-	if (emfContext == aNature) return;
-	emfContext = aNature;
-	ResourceSet set = aNature.getResourceSet();
-	set.getResourceFactoryRegistry().getProtocolToFactoryMap().put(JavaXMIFactory.SCHEME, JavaXMIFactory.INSTANCE);	
-	WorkbenchURIConverter conv = (WorkbenchURIConverter) set.getURIConverter();
-	configureURIConverter(conv);
-	addAdapterFactories(set);	
-}
-
-/**
- * secondary contribute to context
- */
-public void secondaryContributeToContext(EMFWorkbenchContextBase aNature) {
-	primaryContributeToContext(aNature);
-}
-
-/**
- * Remove the project as a container from the converter and add
- * the source folder.
- */
-protected void configureURIConverter(WorkbenchURIConverter conv) {
-	conv.removeInputContainer(getProject());
-	conv.addInputContainer(getEMFRoot());
-}
-
-/**
- * Add Adaptor factories to aContext which is now
- * being used for this nature.
- */
-protected void addAdapterFactories(ResourceSet aSet) {
-	addJavaReflectionAdapterFactories(aSet);
-}
-
-protected void addJavaReflectionAdapterFactories(ResourceSet aSet) {
-	List factories = aSet.getAdapterFactories();
-	// The context may already have a JavaReflection adaptor factory, so remove it
-	if (!factories.isEmpty()) {
-		AdapterFactory factory = EcoreUtil.getAdapterFactory(factories, ReadAdaptor.TYPE_KEY);
-		if (factory != null)
-			factories.remove(factory);
-	}
-	// This should maybe be considered a logic error, but we can recover easily
-	factories.add(new JavaJDOMAdapterFactory(JemProjectUtilities.getJavaProject(project)));
-}
-
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaPlugin.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaPlugin.java
deleted file mode 100644
index 7d60f2f..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaPlugin.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.plugin;
-/*
- * $RCSfile: JavaPlugin.java,v $ $Revision: 1.10 $ $Date: 2005/09/14 23:30:27 $
- */
-
-import org.eclipse.core.runtime.*;
-import org.osgi.framework.BundleContext;
-
-
-import org.eclipse.jem.internal.adapters.jdom.JavaJDOMAdapterFactory;
-import org.eclipse.jem.internal.java.adapters.jdk.JavaJDKAdapterFactory;
-import org.eclipse.jem.java.internal.impl.JavaRefFactoryImpl;
-import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jem.util.logger.proxyrender.EclipseLogger;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
-
-/**
- * This is a top-level class of the java plugin tool.
- * 
- * @see AbstractUIPlugin for additional information on UI plugins
- */
-
-public class JavaPlugin extends Plugin {
-
-	private static JavaPlugin INSTANCE;
-	private Logger logger;
-
-	/**
-	 * Create the Java plugin and cache its default instance
-	 */
-	public JavaPlugin() {
-		INSTANCE = this;
-	}
-
-	public Logger getLogger() {
-		if (logger == null)
-			logger = EclipseLogger.getEclipseLogger(this);
-		return logger;
-	}
-
-	/**
-	 * Get the plugin singleton.
-	 */
-	static public JavaPlugin getDefault() {
-		return INSTANCE;
-	}
-
-		/* (non-Javadoc)
-	 * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
-	 */
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-		JavaRefFactoryImpl.setReflectionAdapterFactoryClass(JavaJDOMAdapterFactory.class);
-		JEMUtilPlugin.getPluginResourceSet().getAdapterFactories().add(new JavaJDKAdapterFactory());		
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaProjectInfo.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaProjectInfo.java
deleted file mode 100644
index d6f3c4f..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/internal/plugin/JavaProjectInfo.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.plugin;
-/*
- *  $RCSfile: JavaProjectInfo.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 21:13:53 $ 
- */
-/**
- * Insert the type's description here.
- * Creation date: (05/07/01 10:09:26 PM)
- * @author: Administrator
- */
-public class JavaProjectInfo implements IJavaProjectInfo {
-	
-	public final static String DEFAULT_JAVA_OUTPUT_PATH = "bin";//$NON-NLS-1$
-	public final static String DEFAULT_SOURCE_PATH = "source";//$NON-NLS-1$
-	protected String sourcePath;
-/**
- * JavaProjectInfo constructor comment.
- */
-public JavaProjectInfo() {
-	super();
-}
-/**
- * Subclasses should override as necessary
- */
-protected String getDefaultSourcePath() {
-	return DEFAULT_SOURCE_PATH;
-}
-/**
- * Get the class path for the reciever. By default ask the template
- * @return java.lang.String
- */
-public String getSourcePath() {
-	if (sourcePath == null)
-		sourcePath = getDefaultSourcePath();
-	return sourcePath;
-}
-public void setSourcePath(String path) {
-	sourcePath = path;
-}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/ASTBoundResolver.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/ASTBoundResolver.java
deleted file mode 100644
index 37afec7..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/ASTBoundResolver.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ASTBoundResolver.java,v $
- *  $Revision: 1.9 $  $Date: 2005/08/24 21:13:53 $ 
- */
-package org.eclipse.jem.workbench.utility;
-
-import java.text.MessageFormat;
-
-import org.eclipse.jdt.core.dom.*;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.InvalidExpressionException;
- 
-/**
- * This works on resolved AST nodes. If the nodes had not been resolved, this will return noting.
- * 
- * @since 1.0.0
- */
-public class ASTBoundResolver extends ParseTreeCreationFromAST.Resolver {
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.IResolver#resolveName(org.eclipse.jdt.core.dom.Name)
-	 */
-	public PTExpression resolveName(Name name) {
-		IBinding binding = name.resolveBinding();
-		if (binding == null)
-			return null;
-		
-		switch (binding.getKind()) {
-			case IBinding.TYPE:
-				String typename = getTypeName((ITypeBinding) binding);
-				PTName ptname = InstantiationFactory.eINSTANCE.createPTName();
-				ptname.setName(typename);
-				return ptname;
-			case IBinding.VARIABLE:
-				IVariableBinding variableBinding = (IVariableBinding) binding;
-				if (variableBinding.isField()) {
-					if (Modifier.isStatic(variableBinding.getModifiers())) {
-						PTFieldAccess fa = InstantiationFactory.eINSTANCE.createPTFieldAccess();
-						// If just a simple name, then it is like this.field, so no receiver. Not sure how to handle this yet.
-						if (name.isQualifiedName()) {
-							// There are parts before this one. Get them as an expression (either a name, or another field access)
-							fa.setReceiver(resolveName(((QualifiedName) name).getQualifier()));
-						}
-						fa.setField(variableBinding.getName());
-						return fa;
-					} else {
-						throwInvalidExpressionException(MessageFormat.format(WorkbenchUtilityMessages.ASTBoundResolver_CannotHandleLocalField_EXC_, new Object[]{variableBinding.getName()})); 
-//						push(new PushFieldVariable(variableId, getTypeSignature(declaringTypeBinding), fCounter));
-//						push(new PushThis(getEnclosingLevel(node, declaringTypeBinding)));
-//						storeInstruction();
-					}
-				} else {
-					throwInvalidExpressionException(MessageFormat.format(WorkbenchUtilityMessages.ASTBoundResolver_CannotHandleLocalVariable_EXC_, new Object[]{variableBinding.getName()})); 
-//					push(new PushLocalVariable(variableId));
-				}				
-		}
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.IResolver#resolveType(org.eclipse.jdt.core.dom.Type)
-	 */
-	public String resolveType(Type type) {
-		ITypeBinding binding = type.resolveBinding();
-		return (binding != null) ? getTypeName(binding) : null; 
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.Resolver#resolveType(org.eclipse.jdt.core.dom.Name)
-	 */
-	public String resolveType(Name name) throws InvalidExpressionException {
-		ITypeBinding binding = name.resolveTypeBinding();
-		return (binding != null) ? getTypeName(binding) : null; 
-	}
-	
-	protected String getTypeName(ITypeBinding typeBinding) {
-		StringBuffer name;
-		if (typeBinding.isArray()) {
-			name= new StringBuffer(getTypeName(typeBinding.getElementType()));
-			int dimensions= typeBinding.getDimensions();
-			for (int i= 0; i < dimensions; i++) {
-				name.append("[]"); //$NON-NLS-1$
-			}
-			return name.toString();
-		}
-		name= new StringBuffer(typeBinding.getName());
-		IPackageBinding packageBinding= typeBinding.getPackage();
-		typeBinding= typeBinding.getDeclaringClass();
-		while(typeBinding != null) {
-			name.insert(0, '$').insert(0, typeBinding.getName());
-			typeBinding= typeBinding.getDeclaringClass();
-		}
-		if (packageBinding != null && !packageBinding.isUnnamed()) {
-			name.insert(0, '.').insert(0, packageBinding.getName());
-		}
-		return name.toString();
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.Resolver#resolveThis()
-	 */
-	public PTExpression resolveThis() throws InvalidExpressionException {
-		return InstantiationFactory.eINSTANCE.createPTThisLiteral();
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/IJavaEMFNature.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/IJavaEMFNature.java
deleted file mode 100644
index 5427833..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/IJavaEMFNature.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IJavaEMFNature.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:27 $ 
- */
-package org.eclipse.jem.workbench.utility;
- 
-/**
- * Interface for Java EMF Nature constants.
- * 
- * @since 1.2.0
- */
-public interface IJavaEMFNature {
-
-	public static final String NATURE_ID = "org.eclipse.jem.workbench.JavaEMFNature"; //$NON-NLS-1$
-
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/JemProjectUtilities.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/JemProjectUtilities.java
deleted file mode 100644
index 4fdb59a..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/JemProjectUtilities.java
+++ /dev/null
@@ -1,746 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.workbench.utility;
-/*
- * $RCSfile: JemProjectUtilities.java,v $ $Revision: 1.10 $ $Date: 2005/09/14 23:30:27 $
- */
-
-import java.net.URL;
-import java.util.*;
-
-import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.*;
-import org.eclipse.jdt.core.*;
-
-import org.eclipse.jem.internal.plugin.JavaEMFNature;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaRefFactory;
-import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
-import org.eclipse.jem.util.emf.workbench.WorkbenchResourceHelperBase;
-import org.eclipse.jem.util.emf.workbench.nature.EMFNature;
-import org.eclipse.jem.util.plugin.JEMUtilPlugin;
-
-/**
- * Project Utilities for JEM and Java.
- * 
- * @since 1.1.0
- */
-public class JemProjectUtilities extends ProjectUtilities {
-	
-	private JemProjectUtilities(){
-	}
-	
-	/**
-	 * The nature id for JEM Nature.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static final String JEM_EMF_NatureID = IJavaEMFNature.NATURE_ID;
-	
-	/**
-	 * Get the EMF nature for JEM for the project. 
-	 * @param project
-	 * @param addNature <code>true</code> if add the nature to the project if not set. <code>false</code> if don't add nature if not already on project.
-	 * @return the EMFNature or <code>null</code> if not found and addNature was <code>false</code> or it was not a java project.
-	 * @throws CoreException 
-	 * 
-	 * @since 1.1.0
-	 */
-	public static EMFNature getJEM_EMF_Nature(IProject project, boolean addNature) throws CoreException {
-		return addNature ? JavaEMFNature.createRuntime(project) : JavaEMFNature.getRuntime(project);
-	}
-
-	/**
-	 * Get the JavaClass from an IFile.
-	 * @param aFile
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public static JavaClass getJavaClass(IFile aFile) {
-		if (aFile == null)
-			return null;
-		IProject project = aFile.getProject();
-		List folders = getSourceContainers(project);
-		folders.addAll(getLibraryContainers(project));
-		IContainer folder = null;
-		IPath folderPath, filePath, javaPath;
-		filePath = aFile.getProjectRelativePath();
-		if (folders != null) {
-			for (int i = 0; i < folders.size(); i++) {
-				folder = (IContainer) folders.get(i);
-				folderPath = folder.getProjectRelativePath();
-				int segments = filePath.matchingFirstSegments(folderPath);
-				if (segments > 0) {
-					javaPath = filePath.removeFirstSegments(segments);
-					javaPath = javaPath.removeFileExtension();
-					String qualifiedName = javaPath.toString().replace('/', '.');
-					return (JavaClass) JavaRefFactory.eINSTANCE.reflectType(qualifiedName, WorkbenchResourceHelperBase.getResourceSet(project));
-				}
-			}
-		}
-		return null;
-	}
-	
-	/**
-	 * Get source containers for the project.
-	 * 
-	 * @param p
-	 *            project
-	 * @return list of source containers.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static List getSourceContainers(IProject p) {
-		try {
-			List sourceContainers = new ArrayList();
-			List sourcePaths = getSourcePaths(p);
-			if (sourcePaths != null && !sourcePaths.isEmpty()) {
-				for (int i = 0; i < sourcePaths.size(); i++) {
-					IPath path = (IPath) sourcePaths.get(i);
-					if (path.isEmpty())
-						sourceContainers.add(p);
-					else
-						sourceContainers.add(p.getFolder(path));
-				}
-			}
-			return sourceContainers;
-		} catch (IllegalArgumentException ex) {
-			return Collections.EMPTY_LIST;
-		}
-	}
-	
-	protected static List getSourcePaths(IProject p) {
-		IJavaProject javaProj = getJavaProject(p);
-		if (javaProj == null)
-			return null;
-		IClasspathEntry[] cp = null;
-		try {
-			cp = javaProj.getRawClasspath();
-		} catch (JavaModelException ex) {
-			JEMUtilPlugin.getLogger().logError(ex);
-			return null;
-		}
-		List sourcePaths = new ArrayList();
-		for (int i = 0; i < cp.length; i++) {
-			if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
-				sourcePaths.add(cp[i].getPath().removeFirstSegments(1));
-			}
-		}
-		return sourcePaths;
-	}
-	
-	/**
-	 * Return list of IContainers that are Libraries in the classpath.
-	 * 
-	 * @param p
-	 *            project
-	 * @return list of library IContainers.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static List getLibraryContainers(IProject p) {
-		try {
-			List libraryContainers = new ArrayList();
-			List libraryPaths = getlibraryPaths(p);
-			if (libraryPaths != null && !libraryPaths.isEmpty()) {
-				for (int i = 0; i < libraryPaths.size(); i++) {
-					IPath path = (IPath) libraryPaths.get(i);
-					if (path.isEmpty())
-						libraryContainers.add(p);
-					else
-						libraryContainers.add(p.getFolder(path));
-				}
-			}
-			return libraryContainers;
-		} catch (IllegalArgumentException ex) {
-			return Collections.EMPTY_LIST;
-		}
-	}
-	
-	
-	protected static List getlibraryPaths(IProject p) {
-		IJavaProject javaProj = getJavaProject(p);
-		if (javaProj == null)
-			return null;
-		IClasspathEntry[] cp = null;
-		try {
-			cp = javaProj.getRawClasspath();
-		} catch (JavaModelException ex) {
-			JEMUtilPlugin.getLogger().logError(ex);
-			return null;
-		}
-		List libraryPaths = new ArrayList();
-		for (int i = 0; i < cp.length; i++) {
-			if (cp[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
-				libraryPaths.add(cp[i].getPath().removeFirstSegments(1));
-			}
-		}
-		return libraryPaths;
-	}
-	
-	/**
-	 * Get the java project nature for the given project.
-	 * 
-	 * @param p
-	 *            project
-	 * @return the java project nature for the project or <code>null</code> if not a java project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IJavaProject getJavaProject(IProject p) {
-		try {
-			return (IJavaProject) p.getNature(JavaCore.NATURE_ID);
-		} catch (CoreException ignore) {
-			return null;
-		}
-	}
-
-	/**
-	 * Touch classpath. It simply takes the classpath and sets it back in.
-	 * 
-	 * @param javaProject
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void updateClasspath(IJavaProject javaProject) throws JavaModelException {
-		if (javaProject != null)
-			javaProject.setRawClasspath(javaProject.getRawClasspath(), new NullProgressMonitor());
-	}
-
-	/**
-	 * Return the location of the binary output files for the JavaProject.
-	 * 
-	 * @param p
-	 *            project
-	 * @return path to binary output folder or <code>null</code> if not java project or other problem.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IPath getJavaProjectOutputLocation(IProject p) {
-		try {
-			IJavaProject javaProj = getJavaProject(p);
-			if (javaProj == null)
-				return null;
-			if (!javaProj.isOpen())
-				javaProj.open(null);
-			return javaProj.getOutputLocation();
-		} catch (JavaModelException e) {
-			return null;
-		}
-	}
-
-	/**
-	 * Get the project's binary output container.
-	 * 
-	 * @param p
-	 *            project
-	 * @return project's output container or <code>null</code> if not java project or some other error.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IContainer getJavaProjectOutputContainer(IProject p) {
-		IPath path = getJavaProjectOutputLocation(p);
-		if (path == null)
-			return null;
-		if (path.segmentCount() == 1)
-			return p;
-		return p.getFolder(path.removeFirstSegments(1));
-	}
-
-	/**
-	 * Get the binary output absolute (local file system) path.
-	 * 
-	 * @param p
-	 *            project
-	 * @return project's output path or <code>null</code> if not java project or some other error.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IPath getJavaProjectOutputAbsoluteLocation(IProject p) {
-		IContainer container = getJavaProjectOutputContainer(p);
-		if (container != null)
-			return container.getLocation();
-		return null;
-	}
-
-	/**
-	 * Get the JDT JavaModel.
-	 * 
-	 * @return JDT's JavaModel
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IJavaModel getJavaModel() {
-		return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
-	}
-
-	/**
-	 * Get all source package fragment roots.
-	 * 
-	 * @param javaProj
-	 * @return source package fragment roots
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static List getSourcePackageFragmentRoots(IJavaProject javaProj) throws JavaModelException {
-		List result = new ArrayList();
-		IPackageFragmentRoot[] roots = javaProj.getPackageFragmentRoots();
-		for (int i = 0; i < roots.length; i++) {
-			IPackageFragmentRoot root = roots[i];
-			if (root.getKind() == IPackageFragmentRoot.K_SOURCE)
-				result.add(result);
-		}
-		return result;
-	}
-
-	/**
-	 * Remove the resource from the classpath
-	 * 
-	 * @param p
-	 *            project
-	 * @param res
-	 *            resource
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void removeFromJavaClassPath(IProject p, IResource res) throws JavaModelException {
-		IClasspathEntry entry = JavaCore.newLibraryEntry(res.getFullPath(), null, null);
-		removeFromJavaClassPath(p, entry);
-	}
-
-	/**
-	 * Remove the path from the classpath
-	 * 
-	 * @param p
-	 *            project
-	 * @param path
-	 *            path to remove
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void removeFromJavaClassPath(IProject p, IPath path) throws JavaModelException {
-		org.eclipse.core.resources.IFile f = p.getFile(path);
-		removeFromJavaClassPath(p, f);
-	}
-
-	/**
-	 * Remove the classpath entry from the project's classpath.
-	 * 
-	 * @param p
-	 * @param entry
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void removeFromJavaClassPath(IProject p, IClasspathEntry entry) throws JavaModelException {
-		IJavaProject javaProject = null;
-		try {
-			javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID);
-		} catch (CoreException ignore) {
-		}
-		if (javaProject != null) {
-			IClasspathEntry[] classpath = javaProject.getRawClasspath();
-			javaProject.setRawClasspath(primRemoveFromJavaClassPath(classpath, entry), new NullProgressMonitor());
-		}
-	}
-
-	/**
-	 * Remove the list of entries from the classpath of the project.
-	 * 
-	 * @param p
-	 *            project
-	 * @param entries
-	 *            list of IClassPathEntry's
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void removeFromJavaClassPath(IProject p, List entries) throws JavaModelException {
-		IJavaProject javaProject = null;
-		try {
-			javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID);
-		} catch (CoreException ignore) {
-		}
-		if (javaProject != null) {
-			IClasspathEntry[] classpath = javaProject.getRawClasspath();
-			javaProject.setRawClasspath(primRemoveFromJavaClassPath(classpath, entries), new NullProgressMonitor());
-		}
-	}
-
-	protected static IClasspathEntry[] primRemoveFromJavaClassPath(IClasspathEntry[] classpath, IClasspathEntry entry) throws JavaModelException {
-		List result = new ArrayList();
-		boolean didRemove = false;
-		for (int i = 0; i < classpath.length; i++) {
-			IClasspathEntry cpEntry = classpath[i];
-			if (!entry.getPath().equals(classpath[i].getPath()))
-				result.add(cpEntry);
-			else
-				didRemove = true;
-		}
-		if (!didRemove)
-			return classpath;
-		return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
-	}
-
-	protected static IClasspathEntry[] primRemoveFromJavaClassPath(IClasspathEntry[] classpath, List entries) throws JavaModelException {
-		List arrayList = Arrays.asList(classpath);
-		List removeable = new ArrayList(arrayList);
-		IClasspathEntry entry;
-		boolean didRemove = false;
-		int size = entries.size();
-		for (int i = 0; i < size; i++) {
-			entry = (IClasspathEntry) entries.get(i);
-			for (int j = 0; j < classpath.length; j++) {
-				IClasspathEntry cpEntry = classpath[j];
-				if (entry.getPath().equals(classpath[j].getPath())) {
-					if (removeable.remove(cpEntry))
-						didRemove = true;
-				}
-			}
-		}
-		if (!didRemove)
-			return classpath;
-		return (IClasspathEntry[]) removeable.toArray(new IClasspathEntry[removeable.size()]);
-	}
-
-	/**
-	 * Get the classpath as an array or URL's.
-	 * 
-	 * @param javaProject
-	 * @return array of URL's or <code>null</code> if javaProject was <code>null</code>.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static URL[] getClasspathAsURLArray(IJavaProject javaProject) {
-		if (javaProject == null)
-			return null;
-		Set visited = new HashSet();
-		List urls = new ArrayList(20);
-		collectClasspathURLs(javaProject, urls, visited, true);
-		URL[] result = new URL[urls.size()];
-		urls.toArray(result);
-		return result;
-	}
-
-	private static void collectClasspathURLs(IJavaProject javaProject, List urls, Set visited, boolean isFirstProject) {
-		if (visited.contains(javaProject))
-			return;
-		visited.add(javaProject);
-		IPath outPath = getJavaProjectOutputAbsoluteLocation(javaProject.getProject());
-		outPath = outPath.addTrailingSeparator();
-		URL out = ProjectUtilities.createFileURL(outPath);
-		urls.add(out);
-		IClasspathEntry[] entries = null;
-		try {
-			entries = javaProject.getResolvedClasspath(true);
-		} catch (JavaModelException e) {
-			return;
-		}
-		IClasspathEntry entry;
-		for (int i = 0; i < entries.length; i++) {
-			entry = entries[i];
-			switch (entry.getEntryKind()) {
-				case IClasspathEntry.CPE_LIBRARY:
-				case IClasspathEntry.CPE_CONTAINER:
-				case IClasspathEntry.CPE_VARIABLE:
-					collectClasspathEntryURL(entry, urls);
-					break;
-				case IClasspathEntry.CPE_PROJECT: {
-					if (isFirstProject || entry.isExported())
-						collectClasspathURLs(getJavaProject(entry), urls, visited, false);
-					break;
-				}
-			}
-		}
-	}
-
-	private static void collectClasspathEntryURL(IClasspathEntry entry, List urls) {
-		IPath path = entry.getPath();
-		if (null == path.getDevice()) {
-			IFile jarFile = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
-			if (jarFile.exists()) {
-				path = jarFile.getLocation();
-			}
-		}
-
-		URL url = ProjectUtilities.createFileURL(path);
-		if (url != null)
-			urls.add(url);
-	}
-
-
-	private static IJavaProject getJavaProject(IClasspathEntry entry) {
-		IProject proj = ResourcesPlugin.getWorkspace().getRoot().getProject(entry.getPath().segment(0));
-		if (proj != null)
-			return getJavaProject(proj);
-		return null;
-	}
-
-	/**
-	 * Is this project a binary project.
-	 * <p>
-	 * Typically a Java project is considered binary if it does not have a source entry in the classpath.
-	 * 
-	 * @param project
-	 *            Project to test
-	 * @return <code>true</code> if project is a binary project.
-	 */
-	public static boolean isBinaryProject(IProject aProject) {
-	
-		IJavaProject javaProj = getJavaProject(aProject);
-		if (javaProj == null)
-			return false;
-		IClasspathEntry[] entries = null;
-		try {
-			entries = javaProj.getRawClasspath();
-		} catch (JavaModelException jme) {
-			return false;
-		}
-		for (int i = 0; i < entries.length; i++) {
-			IClasspathEntry entry = entries[i];
-			if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE)
-				return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Append to java class path.
-	 * <p>
-	 * Append a list of IClasspathEntry's to the build path of the passed project. Updated to remove existing occurrences of the passed entries before
-	 * appending.
-	 * </p>
-	 * 
-	 * @param p
-	 *            project
-	 * @param appendClasspathEntries
-	 *            list of entries
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void appendJavaClassPath(IProject p, List appendClasspathEntries) throws JavaModelException {
-		IJavaProject javaProject = null;
-		try {
-			javaProject = (IJavaProject) p.getNature(JavaCore.NATURE_ID);
-		} catch (CoreException ignore) {
-		}
-		if (javaProject != null) {
-			IClasspathEntry[] classpath = javaProject.getRawClasspath();
-			List newPathList = new ArrayList(classpath.length);
-			for (int i = 0; i < classpath.length; i++) {
-				IClasspathEntry entry = classpath[i];
-				// Skip entries which are in the append list
-				if (appendClasspathEntries.indexOf(entry) < 0)
-					newPathList.add(entry);
-			}
-			newPathList.addAll(appendClasspathEntries);
-			IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList.toArray(new IClasspathEntry[newPathList.size()]);
-			javaProject.setRawClasspath(newClasspath, new NullProgressMonitor());
-		}
-	}
-
-	/**
-	 * Append classpath entry.
-	 * <p>
-	 * Append one IClasspathEntry to the build path of the passed project. If a classpath entry having the same path as the parameter already exists,
-	 * then does nothing.
-	 * </p>
-	 * 
-	 * @param p
-	 *            Project
-	 * @param newEntry
-	 *            Entry
-	 * @throws JavaModelException
-	 * 
-	 * @since 1.0.0
-	 */
-	public static void appendJavaClassPath(IProject p, IClasspathEntry newEntry) throws JavaModelException {
-		IJavaProject javaProject = getJavaProject(p);
-		if (javaProject == null)
-			return;
-		IClasspathEntry[] classpath = javaProject.getRawClasspath();
-		List newPathList = new ArrayList(classpath.length);
-		for (int i = 0; i < classpath.length; i++) {
-			IClasspathEntry entry = classpath[i];
-			// fix dup class path entry for .JETEmitter project
-			// Skip the entry to be added if it already exists
-			if (Platform.getOS().equals(Platform.OS_WIN32)) {
-				if (!entry.getPath().toString().equalsIgnoreCase(newEntry.getPath().toString()))
-					newPathList.add(entry);
-				else
-					return;
-			} else {
-				if (!entry.getPath().equals(newEntry.getPath()))
-					newPathList.add(entry);
-				else
-					return;
-			}
-		}
-		newPathList.add(newEntry);
-		IClasspathEntry[] newClasspath = (IClasspathEntry[]) newPathList.toArray(new IClasspathEntry[newPathList.size()]);
-		javaProject.setRawClasspath(newClasspath, new NullProgressMonitor());
-	}
-
-	/**
-	 * Return the source path matching the parameter; if the parameter is null, or if the source folder is not on the classpath, return the first
-	 * source path on the classpath
-	 * 
-	 * @param p
-	 *            project
-	 * @param defaultSourceName
-	 *            source folder to find if on classpath, or if <code>null</code> the first folder
-	 * @return path searched for or <code>null</code> if not java project or some other problem.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IPath getSourcePathOrFirst(IProject p, String defaultSourceName) {
-		IJavaProject javaProj = getJavaProject(p);
-		if (javaProj == null)
-			return null;
-		IClasspathEntry[] cp = null;
-		try {
-			cp = javaProj.getRawClasspath();
-		} catch (JavaModelException ex) {
-			JEMUtilPlugin.getLogger().logError(ex);
-			return null;
-		}
-		IClasspathEntry firstSource = null;
-		IPath defaultSourcePath = null;
-		if (defaultSourceName != null)
-			defaultSourcePath = ProjectUtilities.createPath(p, defaultSourceName);
-		for (int i = 0; i < cp.length; i++) {
-			if (cp[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
-				if (firstSource == null) {
-					firstSource = cp[i];
-					if (defaultSourcePath == null)
-						break;
-				}
-				if (cp[i].getPath().equals(defaultSourcePath))
-					return defaultSourcePath.removeFirstSegments(1);
-			}
-		}
-		if (firstSource == null)
-			return null;
-		if (firstSource.getPath().segment(0).equals(p.getName()))
-			return firstSource.getPath().removeFirstSegments(1);
-		return null;
-	}
-
-	/**
-	 * Hack to force a reload of the .classpath file
-	 * 
-	 * @param project
-	 *            project to reload
-	 * @since 1.0.0
-	 */
-	public static void forceClasspathReload(IProject project) throws JavaModelException {
-		IJavaProject javaProj = getJavaProject(project);
-		if (javaProj != null) {
-			IClasspathEntry[] entries = javaProj.readRawClasspath();
-			if (entries != null) {
-				IPath output = javaProj.readOutputLocation();
-				if (output != null)
-					javaProj.setRawClasspath(entries, output, null);
-			}
-		}
-	}
-
-	/**
-	 * Get the paths of all of the local jars in the classpath for the project. It does not recurse into referenced projects.
-	 * 
-	 * @param proj
-	 *            project to search (should be a java project).
-	 * @return A list of IPath, where each entry is a project relative path to a JAR contained in the project.
-	 */
-	public static List getLocalJARPathsFromClasspath(IProject proj) {
-		IJavaProject javaProj = getJavaProject(proj);
-		if (javaProj == null)
-			return null;
-		IPath projectPath = proj.getFullPath();
-		List result = new ArrayList();
-		try {
-			IClasspathEntry[] entries = javaProj.getRawClasspath();
-			for (int i = 0; i < entries.length; i++) {
-				IClasspathEntry entry = entries[i];
-				if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
-					IPath path = entry.getPath();
-					int segments = path.matchingFirstSegments(projectPath);
-					if (segments > 0)
-						result.add(path.removeFirstSegments(segments));
-				}
-			}
-		} catch (JavaModelException e) {
-			JEMUtilPlugin.getLogger().logError(e);
-		}
-		return result;
-	}
-
-
-	/**
-	 * Return the source folder matching the parameter; if the parameter is null, or if the source folder is not on the classpath, return the first
-	 * source folder on the classpath
-	 * 
-	 * @param p
-	 *            project
-	 * @param defaultSourceName
-	 *            source folder to find if on classpath, or if <code>null</code> the first folder
-	 * @return container searched for or <code>null</code> if not java project or some other problem.
-	 * 
-	 * @since 1.0.0
-	 */
-	public static IContainer getSourceFolderOrFirst(IProject p, String defaultSourceName) {
-		try {
-			IPath sourcePath = getSourcePathOrFirst(p, defaultSourceName);
-			if (sourcePath == null)
-				return null;
-			else if (sourcePath.isEmpty())
-				return p;
-			else
-				return p.getFolder(sourcePath);
-		} catch (IllegalArgumentException ex) {
-			return null;
-		}
-	}
-
-	/**
-	 * Returns a list of IFolder that represents each source folder in a java project
-	 * 
-	 * @deprecated Use {@link #getSourceContainers(IProject)}because the project itself might be a source container
-	 * 
-	 * @param p
-	 *            project
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public static List getSourceFolders(IProject p) {
-		try {
-			List sourceFolders = new ArrayList();
-			List sourcePaths = getSourcePaths(p);
-			if (sourcePaths != null && !sourcePaths.isEmpty()) {
-				for (int i = 0; i < sourcePaths.size(); i++) {
-					IPath path = (IPath) sourcePaths.get(i);
-					if (!path.isEmpty())
-						sourceFolders.add(p.getFolder(path));
-				}
-			}
-			return sourceFolders;
-		} catch (IllegalArgumentException ex) {
-			return Collections.EMPTY_LIST;
-		}
-	}	
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/NoASTResolver.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/NoASTResolver.java
deleted file mode 100644
index 5c9e1e9..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/NoASTResolver.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: NoASTResolver.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 21:13:53 $ 
- */
-package org.eclipse.jem.workbench.utility;
-
-import org.eclipse.jdt.core.dom.Name;
-import org.eclipse.jdt.core.dom.Type;
-
-import org.eclipse.jem.internal.instantiation.InstantiationFactory;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.InvalidExpressionException;
- 
-
-/**
- * This is used for AST Resolution, but it simply turns Name into PTName. Useful when
- * just creating a parse tree where we know the names are ok and just types. 
- * @since 1.0.0
- */
-public class NoASTResolver extends ASTBoundResolver {
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.Resolver#resolveName(org.eclipse.jdt.core.dom.Name)
-	 */
-	public PTExpression resolveName(Name name) throws InvalidExpressionException {
-		return InstantiationFactory.eINSTANCE.createPTName(name.toString());
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.Resolver#resolveType(org.eclipse.jdt.core.dom.Type)
-	 */
-	public String resolveType(Type type) {
-		return type.toString();
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST.Resolver#resolveType(org.eclipse.jdt.core.dom.Name)
-	 */
-	public String resolveType(Name name) throws InvalidExpressionException {
-		return name.toString();
-	}
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/ParseTreeCreationFromAST.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/ParseTreeCreationFromAST.java
deleted file mode 100644
index 9f7360e..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/ParseTreeCreationFromAST.java
+++ /dev/null
@@ -1,570 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ParseTreeCreationFromAST.java,v $
- *  $Revision: 1.17 $  $Date: 2005/10/28 22:56:44 $ 
- */
-package org.eclipse.jem.workbench.utility;
-
-import java.text.MessageFormat;
-import java.util.HashMap;
-import java.util.List;
-
-import org.eclipse.jdt.core.dom.*;
-import org.eclipse.jdt.core.dom.Expression;
-
-import org.eclipse.jem.internal.instantiation.*;
- 
-/**
- * Create a parse tree from an AST node.
- * @since 1.0.0
- */
-public class ParseTreeCreationFromAST extends ASTVisitor {
-	protected final Resolver resolver;
-	protected PTExpression expression;	// Each visit (or endvisit) will put into expression the result of the visit if it produced an expression.
-	
-	/**
-	 * This is the abstract base class used by ParseTreeCreationFromAST to resolve the types to the appropriate
-	 * types (e.g. "String" to "java.lang.String"). 
-	 * 
-	 * @see org.eclipse.jem.workbench.utility.ParseTreeCreationFromAST
-	 * @since 1.0.0
-	 */
-	public static abstract class Resolver {
-		
-		/**
-		 * Resolve the Name. It can return either a PTName if it is just a classname,
-		 * or a PTFieldAccess if it resolves to a PTFieldAccess. The PTFieldAccess should
-		 * be complete. e.g we have class like:
-		 * <code>
-		 * 	package xyz; 
-		 * 	public class AClass {
-		 * 		public java.awt.Rectangle rect;
-		 * 	} 
-		 * </code>
-		 * Then a Name like <code>AClass.rect.x</code> should resolve to:
-		 * 
-		 * PTFieldAccess:
-		 * 	receiver: 
-		 * 		PTFieldAccess
-		 * 			receiver: xyz.AClass
-		 * 			field: "rect"
-		 * 	field: "x"
-		 *
-		 * Actually it can return any valid expression that has a value (i.e. it cannot be a method invocation with a <code>void</code> return type). 
-		 * 
-		 * @param name
-		 * @return Either a fully-qualified name (as a PTName) or a PTFieldAccess, any other type of expression.
-		 * 
-		 * @since 1.0.0
-		 */
-		public abstract PTExpression resolveName(Name name) throws InvalidExpressionException;
-		
-		/**
-		 * Resolve the type. If it is an array type return it in format "type[][]".
-		 * 
-		 * @param type
-		 * @return The type name, including brackets if array type.
-		 * 
-		 * @since 1.0.0
-		 */
-		public abstract String resolveType(Type type) throws InvalidExpressionException;
-		
-		/**
-		 * This is for resolving "this" literal. It should either return a PTThisLiteral, if it
-		 * can't do resolve, or some PTExpression that can resolve to "this" for evaluation.
-		 * 
-		 * @return If resolvable, a PTExpression, else a PTThisLiteral if not resolvable.
-		 * @throws InvalidExpressionException
-		 * 
-		 * @since 1.0.0
-		 */
-		public abstract PTExpression resolveThis() throws InvalidExpressionException;
-		
-		/**
-		 * Resolve the type specified as a Name. It may be a simple name or it may be
-		 * a qualified name. This is used when we have Name that we know must be a
-		 * type. This is so that there is no confusion with it possibly being a field or variable
-		 * that has the same case and spelling as a type name.
-		 * @param name
-		 * @return the type name.
-		 * @throws InvalidExpressionException
-		 * 
-		 * @since 1.0.0
-		 */
-		public abstract String resolveType(Name name) throws InvalidExpressionException;
-		
-		/**
-		 * This is used by the resolver if it can't resolve for some reason. This will throw
-		 * an invalid expression exception which will be handled by the ParseTreeCreationFromAST.
-		 * 
-		 * @param msg Message to be put into the exception.
-		 * @throws InvalidExpressionException
-		 * 
-		 * @since 1.0.0
-		 */
-		protected final void throwInvalidExpressionException(String msg) throws InvalidExpressionException {
-			throw new InvalidExpressionException(msg);
-		}
-	}
-	
-	/*
-	 * When an invalid expression has been found this exception should be thrown. It will
-	 * be caught at the top and converted into an InvalidExpression and the rest of the parse tree will be
-	 * thrown away. 
-	 * 
-	 * The message will be a message as to why it is invalid.
-	 * 
-	 * @since 1.0.0
-	 */
-	protected static class InvalidExpressionException extends IllegalArgumentException {
-		
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0
-		 */
-		private static final long serialVersionUID = 2429845631915206678L;
-
-		/**
-		 * @param s The message to be used in the final invalid expression.
-		 * 
-		 * @since 1.0.0
-		 */
-		public InvalidExpressionException(String s) {
-			super(s);
-		}
-	}
-
-	/**
-	 * Construct with the given resolver.
-	 * 
-	 * @param resolver
-	 * 
-	 * @since 1.0.0
-	 */
-	public ParseTreeCreationFromAST(Resolver resolver) {
-		this.resolver = resolver;
-	}
-
-	/**
-	 * Process the AST Expression and return a PTExpression. If any part was invalid, then
-	 * only an PTInvalidExpression will be returned.
-	 * 
-	 * @param astExpression
-	 * @return The PTExpression.
-	 * 
-	 * @since 1.0.0
-	 */
-	public final PTExpression createExpression(Expression astExpression) {
-		try {
-			return perform(astExpression);
-		} catch (InvalidExpressionException e) {
-			// Create a msg that is formed of the exception message and the full init string.
-			String msg = MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_0, new Object[] {e.getLocalizedMessage(), astExpression.toString()}); 
-			PTInvalidExpression exp = InstantiationFactory.eINSTANCE.createPTInvalidExpression();
-			exp.setMessage(msg);
-			return exp;
-		}	
-	}
-	
-	/*
-	 * Visit the AST expression and get the ParseTree Expression.
-	 * This is used by the individual visits when parsing a tree.
-	 * It passes to the top method (createExpression), which can
-	 * handle the InvalidExpressionException.
-	 * 
-	 * If any visit doesn't return an expression, then an invalid
-	 * expression exception will be thrown to indicate this. If the
-	 * incoming expression is <code>null</code>, then return of <code>null</code> is ok because
-	 * this would be for an optional expression which didn't exist.
-	 * 
-	 * @return The new ParseTree Expression or <code>null</code> if incoming expression was null. 
-	 * 
-	 * @see createExpression(org.eclipse.jdt.core.dom.Expression)
-	 * @exception InvalidExpressionException
-	 * @since 1.0.0
-	 */
-	protected final PTExpression perform(Expression astExpression) {
-		if (astExpression != null) {
-			expression = null;
-			astExpression.accept(this);
-			if (expression == null)
-				throw new InvalidExpressionException(MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_ExpressionTooComplicated_EXC_, new Object[] {astExpression.toString()})); 
-			return expression;
-		} else
-			return null;	// This is ok. It means an optional expression was being processed and the expression didn't exist.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
-	 */
-	public boolean visit(ArrayAccess node) {
-		PTArrayAccess aa = InstantiationFactory.eINSTANCE.createPTArrayAccess();
-		List indexes = aa.getIndexes();
-		Expression arrayExp = node;
-		while (arrayExp.getNodeType() == ASTNode.ARRAY_ACCESS) {
-			// Visit the index to get the index expression.
-			ArrayAccess array = (ArrayAccess) arrayExp; 
-			indexes.add(0, perform(array.getIndex()));	// We're trying to create the final expression from inside out, the indexes are created in reverse order.
-			arrayExp = array.getArray();
-		}
-		aa.setArray(perform(arrayExp));	// Final arrayExp is the true expression.
-		expression = aa;	// Set the return expression for this visit.
-		return false;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
-	 */
-	public boolean visit(ArrayCreation node) {
-		PTArrayCreation ac = InstantiationFactory.eINSTANCE.createPTArrayCreation();
-		ac.setType(resolver.resolveType(node.getType()));
-		List acDims = ac.getDimensions();
-		List nDims = node.dimensions();
-		int nsize = nDims.size();
-		for (int i = 0; i < nsize; i++) {
-			acDims.add(perform((Expression) nDims.get(i)));
-		}
-		ac.setInitializer((PTArrayInitializer) perform(node.getInitializer()));
-		expression = ac;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
-	 */
-	public boolean visit(ArrayInitializer node) {
-		PTArrayInitializer ai = InstantiationFactory.eINSTANCE.createPTArrayInitializer();
-		List exps = node.expressions();
-		List aiexps = ai.getExpressions();
-		int nexp = exps.size();
-		for (int i = 0; i < nexp; i++) {
-			aiexps.add(perform((Expression) exps.get(i)));
-		}
-		expression = ai;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
-	 */
-	public boolean visit(Assignment node) {
-		return false;	// We can't handle assignment.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
-	 */
-	public boolean visit(BooleanLiteral node) {
-		PTBooleanLiteral bl = InstantiationFactory.eINSTANCE.createPTBooleanLiteral();
-		bl.setBooleanValue(node.booleanValue());
-		expression = bl;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
-	 */
-	public boolean visit(CastExpression node) {
-		PTCastExpression ct	= InstantiationFactory.eINSTANCE.createPTCastExpression();
-		ct.setType(resolver.resolveType(node.getType()));
-		ct.setExpression(perform(node.getExpression()));
-		expression = ct;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
-	 */
-	public boolean visit(CharacterLiteral node) {
-		PTCharacterLiteral cl = InstantiationFactory.eINSTANCE.createPTCharacterLiteral();
-		cl.setEscapedValue(node.getEscapedValue());
-		cl.setCharValue(node.charValue());
-		expression = cl;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
-	 */
-	public boolean visit(ClassInstanceCreation node) {
-		if (node.getAnonymousClassDeclaration() != null) { 
-			PTAnonymousClassDeclaration adecl = InstantiationFactory.eINSTANCE.createPTAnonymousClassDeclaration();
-			adecl.setDeclaration(node.toString());
-			expression = adecl;
-		} else {
-			PTClassInstanceCreation cic = InstantiationFactory.eINSTANCE.createPTClassInstanceCreation();
-			// If ast level = 2, then you must use getName, but the name needs to be turned into a type
-			// so that it can be resolved. If ast level > 2, then it will return a type to be resolved.
-			// Note: can't just use resolve name on the name because if a field and a class were spelled
-			// the same then the codegen resolver would return an instance ref to the field instead.
-			String type = node.getAST().apiLevel() == AST.JLS2 ? resolver.resolveType(node.getName()) : resolver.resolveType(node.getType());
-			if (type == null) {
-				type = node.getAST().apiLevel() == AST.JLS2 ? node.getName().getFullyQualifiedName() : node.getType().toString();
-			}
-			cic.setType(type);
-			List args = cic.getArguments();
-			List nargs = node.arguments();
-			int nsize = nargs.size();
-			for (int i = 0; i < nsize; i++) {
-				args.add(perform((Expression) nargs.get(i)));
-			}
-			expression = cic;
-		}
-		return false;
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
-	 */
-	public boolean visit(ConditionalExpression node) {
-		PTConditionalExpression ce = InstantiationFactory.eINSTANCE.createPTConditionalExpression();
-		ce.setCondition(perform(node.getExpression()));
-		ce.setTrue(perform(node.getThenExpression()));
-		ce.setFalse(perform(node.getElseExpression()));
-		expression = ce;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
-	 */
-	public boolean visit(FieldAccess node) {
-		PTFieldAccess fa = InstantiationFactory.eINSTANCE.createPTFieldAccess();
-		fa.setReceiver(perform(node.getExpression()));
-		fa.setField(node.getName().getIdentifier());
-		expression = fa;
-		return false;
-	}
-
-	private static HashMap infixOperToParseOper;
-	private final PTInfixOperator getParseInfix(InfixExpression.Operator operator) {
-		if (prefixOperToParseOper == null) {
-			infixOperToParseOper = new HashMap(5);
-			infixOperToParseOper.put(InfixExpression.Operator.AND, PTInfixOperator.AND_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.CONDITIONAL_AND, PTInfixOperator.CONDITIONAL_AND_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.CONDITIONAL_OR, PTInfixOperator.CONDITIONAL_OR_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.DIVIDE, PTInfixOperator.DIVIDE_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.EQUALS, PTInfixOperator.EQUALS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.GREATER_EQUALS, PTInfixOperator.GREATER_EQUALS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.GREATER, PTInfixOperator.GREATER_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.LEFT_SHIFT, PTInfixOperator.LEFT_SHIFT_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.LESS_EQUALS, PTInfixOperator.LESS_EQUALS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.LESS, PTInfixOperator.LESS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.MINUS, PTInfixOperator.MINUS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.NOT_EQUALS, PTInfixOperator.NOT_EQUALS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.OR, PTInfixOperator.OR_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.PLUS, PTInfixOperator.PLUS_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.REMAINDER, PTInfixOperator.REMAINDER_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.RIGHT_SHIFT_SIGNED, PTInfixOperator.RIGHT_SHIFT_SIGNED_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED, PTInfixOperator.RIGHT_SHIFT_UNSIGNED_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.TIMES, PTInfixOperator.TIMES_LITERAL);
-			infixOperToParseOper.put(InfixExpression.Operator.XOR, PTInfixOperator.XOR_LITERAL);
-		}
-		return (PTInfixOperator) infixOperToParseOper.get(operator);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
-	 */
-	public boolean visit(InfixExpression node) {
-		PTInfixExpression inf = InstantiationFactory.eINSTANCE.createPTInfixExpression();
-		inf.setLeftOperand(perform(node.getLeftOperand()));
-		PTInfixOperator inoper = getParseInfix(node.getOperator());
-		if (inoper == null) {
-			// It is not one we can handle.
-			throw new InvalidExpressionException(
-					MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_, new Object[] { node.getOperator().toString() })); 
-		}
-		inf.setOperator(inoper);
-		inf.setRightOperand(perform(node.getRightOperand()));
-		List eops = inf.getExtendedOperands();
-		List neops = node.extendedOperands();
-		int nsize = neops.size();
-		for (int i = 0; i < nsize; i++) {
-			eops.add(perform((Expression) neops.get(i)));
-		}
-		expression = inf;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
-	 */
-	public boolean visit(InstanceofExpression node) {
-		PTInstanceof inof = InstantiationFactory.eINSTANCE.createPTInstanceof();
-		inof.setOperand(perform(node.getLeftOperand()));
-		inof.setType(resolver.resolveType(node.getRightOperand()));
-		expression = inof;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
-	 */
-	public boolean visit(PostfixExpression node) {
-		return false;	// We can't handle post fix.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
-	 */
-	public boolean visit(MethodInvocation node) {
-		PTMethodInvocation mi = InstantiationFactory.eINSTANCE.createPTMethodInvocation();
-		mi.setReceiver(perform(node.getExpression()));
-		mi.setName(node.getName().getIdentifier());
-		List args = mi.getArguments();
-		List nargs = node.arguments();
-		int nsize = nargs.size();
-		for (int i = 0; i < nsize; i++) {
-			args.add(perform((Expression) nargs.get(i)));
-		}
-		expression = mi;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
-	 */
-	public boolean visit(NullLiteral node) {
-		expression = InstantiationFactory.eINSTANCE.createPTNullLiteral();
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
-	 */
-	public boolean visit(NumberLiteral node) {
-		PTNumberLiteral nl = InstantiationFactory.eINSTANCE.createPTNumberLiteral();
-		nl.setToken(node.getToken());
-		expression = nl;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
-	 */
-	public boolean visit(ParenthesizedExpression node) {
-		PTParenthesizedExpression pe = InstantiationFactory.eINSTANCE.createPTParenthesizedExpression();
-		pe.setExpression(perform(node.getExpression()));
-		expression = pe;
-		return false;
-	}
-
-	private static HashMap prefixOperToParseOper;
-	private final PTPrefixOperator getParsePrefix(PrefixExpression.Operator operator) {
-		if (prefixOperToParseOper == null) {
-			prefixOperToParseOper = new HashMap(5);
-			prefixOperToParseOper.put(PrefixExpression.Operator.COMPLEMENT, PTPrefixOperator.COMPLEMENT_LITERAL);
-			prefixOperToParseOper.put(PrefixExpression.Operator.MINUS, PTPrefixOperator.MINUS_LITERAL);
-			prefixOperToParseOper.put(PrefixExpression.Operator.NOT, PTPrefixOperator.NOT_LITERAL);
-			prefixOperToParseOper.put(PrefixExpression.Operator.PLUS, PTPrefixOperator.PLUS_LITERAL);
-		}
-		return (PTPrefixOperator) prefixOperToParseOper.get(operator);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
-	 */
-	public boolean visit(PrefixExpression node) {
-		if (node.getOperand().getNodeType() == ASTNode.NUMBER_LITERAL) {
-			// For number literals we see if it is a "+" or "-" prefix, and if it is, we simply
-			// create a PTNumberLiteral with the operator already in it. It is a simplification.
-			// Any other operator we've left alone since those won't be decoded simply by the
-			// Number decoder.
-			// If not a number literal, then leave alone since needs to be handled as a prefix
-			// operation.
-			PrefixExpression.Operator operator = node.getOperator();
-			if (operator == PrefixExpression.Operator.PLUS || operator == PrefixExpression.Operator.MINUS) {
-				PTNumberLiteral nm = InstantiationFactory.eINSTANCE.createPTNumberLiteral();
-				nm.setToken(operator.toString() + ((NumberLiteral) node.getOperand()).getToken());
-				expression = nm;
-				return false;
-			}
-		}
-
-		PTPrefixExpression pe = InstantiationFactory.eINSTANCE.createPTPrefixExpression();
-		PTPrefixOperator ptoper = getParsePrefix(node.getOperator());
-		if (ptoper == null) {
-			// It is not one we can handle.
-			throw new InvalidExpressionException(
-				MessageFormat.format(WorkbenchUtilityMessages.ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_, new Object[] { node.getOperator().toString() })); 
-		}
-		pe.setOperator(ptoper);
-		pe.setExpression(perform(node.getOperand()));
-		expression = pe;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
-	 */
-	public boolean visit(QualifiedName node) {
-		expression = resolver.resolveName(node);
-		return false;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
-	 */
-	public boolean visit(SimpleName node) {
-		expression = resolver.resolveName(node);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
-	 */
-	public boolean visit(StringLiteral node) {
-		PTStringLiteral sl = InstantiationFactory.eINSTANCE.createPTStringLiteral();
-		sl.setEscapedValue(node.getEscapedValue());
-		sl.setLiteralValue(node.getLiteralValue());
-		expression = sl;
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
-	 */
-	public boolean visit(SuperFieldAccess node) {
-		return false;	// We can't handle post fix.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
-	 */
-	public boolean visit(SuperMethodInvocation node) {
-		return false;	// We can't handle post fix.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
-	 */
-	public boolean visit(ThisExpression node) {
-		expression = resolver.resolveThis();
-		return false;	
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
-	 */
-	public boolean visit(TypeLiteral node) {
-		PTTypeLiteral ptl = InstantiationFactory.eINSTANCE.createPTTypeLiteral();
-		ptl.setType(resolver.resolveType(node.getType()));
-		expression = ptl;
-		return false;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/WorkbenchUtilityMessages.java b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/WorkbenchUtilityMessages.java
deleted file mode 100644
index 13f09e2..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/WorkbenchUtilityMessages.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.workbench.utility;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class WorkbenchUtilityMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.workbench.utility.messages";//$NON-NLS-1$
-
-	private WorkbenchUtilityMessages() {
-		// Do not instantiate
-	}
-
-	public static String ParseTreeCreationFromAST_0;
-	public static String ParseTreeCreationFromAST_ExpressionTooComplicated_EXC_;
-	public static String ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_;
-	public static String ASTBoundResolver_CannotHandleLocalField_EXC_;
-	public static String ASTBoundResolver_CannotHandleLocalVariable_EXC_;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, WorkbenchUtilityMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/messages.properties b/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/messages.properties
deleted file mode 100644
index 9917f34..0000000
--- a/plugins/org.eclipse.jem.workbench/workbench/org/eclipse/jem/workbench/utility/messages.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-ParseTreeCreationFromAST_0                                       = {0} - {1}
-ParseTreeCreationFromAST_ExpressionTooComplicated_EXC_           = IWAV0177E Expression "{0}" is too complicated.
-ParseTreeCreationFromAST_OperatorTooComplicatedToHandle_EXC_     = IWAV0179E Operator "{0}" is too complicated to handle.
-ASTBoundResolver_CannotHandleLocalField_EXC_=Cannot handle local field access of "{0}"
-ASTBoundResolver_CannotHandleLocalVariable_EXC_=Cannot handle local variable access of "{0}"
diff --git a/plugins/org.eclipse.jem/.classpath b/plugins/org.eclipse.jem/.classpath
deleted file mode 100644
index 34cd7a6..0000000
--- a/plugins/org.eclipse.jem/.classpath
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-    <classpathentry kind="src" path="javainst/"/>
-    <classpathentry kind="src" path="mofjava/"/>
-    <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-    <classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/plugins/org.eclipse.jem/.cvsignore b/plugins/org.eclipse.jem/.cvsignore
deleted file mode 100644
index 60463af..0000000
--- a/plugins/org.eclipse.jem/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-bin
-build.xml
diff --git a/plugins/org.eclipse.jem/.options b/plugins/org.eclipse.jem/.options
deleted file mode 100644
index 493f8d4..0000000
--- a/plugins/org.eclipse.jem/.options
+++ /dev/null
@@ -1,3 +0,0 @@
-org.eclipse.jem/debug/logtrace=default
-org.eclipse.jem/debug/logtracefile=default
-org.eclipse.jem/debug/loglevel=default
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem/.project b/plugins/org.eclipse.jem/.project
deleted file mode 100644
index 52a566e..0000000
--- a/plugins/org.eclipse.jem/.project
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jem</name>
-	<comment></comment>
-	<projects>
-		<project>org.eclipse.core.runtime.compatibility</project>
-		<project>org.eclipse.emf.ecore.xmi</project>
-		<project>org.eclipse.jem.proxy</project>
-		<project>org.eclipse.osgi</project>
-	</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>
-		<buildCommand>
-			<name>com.ibm.rtp.tools.rose.builder</name>
-			<arguments>
-				<dictionary>
-					<key>rose</key>
-					<value></value>
-				</dictionary>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>com.ibm.rtp.tools.rose.toolnature</nature>
-	</natures>
-</projectDescription>
diff --git a/plugins/org.eclipse.jem/.settings/org.eclipse.jdt.core.prefs b/plugins/org.eclipse.jem/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 45e69a9..0000000
--- a/plugins/org.eclipse.jem/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,282 +0,0 @@
-#Thu Jun 16 12:42:28 EDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=error
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=1
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=1
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=0
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
-org.eclipse.jdt.core.formatter.comment.format_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
-org.eclipse.jdt.core.formatter.comment.line_length=150
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=150
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=tab
-org.eclipse.jdt.core.formatter.tabulation.size=4
diff --git a/plugins/org.eclipse.jem/.settings/org.eclipse.jdt.ui.prefs b/plugins/org.eclipse.jem/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index faeaaf0..0000000
--- a/plugins/org.eclipse.jem/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,7 +0,0 @@
-#Wed May 11 18:32:13 EDT 2005
-eclipse.preferences.version=1
-formatter_settings_version=8
-org.eclipse.jdt.ui.ignorelowercasenames=true
-org.eclipse.jdt.ui.importorder=java;javax;org;org.eclipse.wtp;org.eclipse.jem;org.eclipse.ve.internal.cdm;org.eclipse.ve.internal.cde;org.eclipse.ve.internal.jcm;org.eclipse.ve.internal.java;org.eclipse.ve;com;
-org.eclipse.jdt.ui.ondemandthreshold=3
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/plugins/org.eclipse.jem/META-INF/MANIFEST.MF b/plugins/org.eclipse.jem/META-INF/MANIFEST.MF
deleted file mode 100644
index 6c86df0..0000000
--- a/plugins/org.eclipse.jem/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,27 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jem; singleton:=true
-Bundle-Version: 1.2.0
-Bundle-Activator: org.eclipse.jem.internal.core.JEMPlugin
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Export-Package: org.eclipse.jem.internal.core;x-friends:="org.eclipse.jem.beaninfo,org.eclipse.jem.proxy,org.eclipse.jem.tests,org.eclipse.jem.ui,org.eclipse.jem.util,org.eclipse.jem.workbench",
- org.eclipse.jem.internal.instantiation,
- org.eclipse.jem.internal.instantiation.base,
- org.eclipse.jem.internal.instantiation.impl,
- org.eclipse.jem.internal.java.adapters;x-friends:="org.eclipse.jem.beaninfo,org.eclipse.jem.workbench",
- org.eclipse.jem.internal.java.adapters.jdk;x-friends:="org.eclipse.jem.workbench",
- org.eclipse.jem.internal.java.adapters.nls;x-friends:="org.eclipse.jem.workbench",
- org.eclipse.jem.internal.java.beaninfo,
- org.eclipse.jem.internal.java.init;x-friends:="org.eclipse.jem.beaninfo",
- org.eclipse.jem.internal.java.instantiation,
- org.eclipse.jem.java,
- org.eclipse.jem.java.adapters,
- org.eclipse.jem.java.internal.impl;x-friends:="org.eclipse.jem.beaninfo,org.eclipse.jem.workbench",
- org.eclipse.jem.java.util
-Require-Bundle: org.eclipse.emf.ecore.xmi,
- org.eclipse.jem.proxy;resolution:=optional,
- org.eclipse.core.runtime,
- org.eclipse.jem.util
-Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jem/about.html b/plugins/org.eclipse.jem/about.html
deleted file mode 100644
index 6f6b96c..0000000
--- a/plugins/org.eclipse.jem/about.html
+++ /dev/null
@@ -1,22 +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>February 24, 2005</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>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem/about.ini b/plugins/org.eclipse.jem/about.ini
deleted file mode 100644
index a21a3ec..0000000
--- a/plugins/org.eclipse.jem/about.ini
+++ /dev/null
@@ -1,29 +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 (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/plugins/org.eclipse.jem/about.mappings b/plugins/org.eclipse.jem/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/plugins/org.eclipse.jem/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/plugins/org.eclipse.jem/about.properties b/plugins/org.eclipse.jem/about.properties
deleted file mode 100644
index d91ecc9..0000000
--- a/plugins/org.eclipse.jem/about.properties
+++ /dev/null
@@ -1,28 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem/about.properties,v $
-# $Revision: 1.7 $  $Date: 2005/08/24 20:20:25 $
-#
-
-# 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=Java EMF Model\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others. 2000, 2004.  All rights reserved.\n\
-Visit http://www.eclipse.org/vep
diff --git a/plugins/org.eclipse.jem/build.properties b/plugins/org.eclipse.jem/build.properties
deleted file mode 100644
index 28d04ad..0000000
--- a/plugins/org.eclipse.jem/build.properties
+++ /dev/null
@@ -1,29 +0,0 @@
-###############################################################################
-# Copyright (c) 2004, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-src.excludes = **/.cvsignore
-bin.includes = plugin.xml,\
-               plugin.properties,\
-               about.html,\
-               about.ini,\
-               about.mappings,\
-               about.properties,\
-               eclipse32.gif,\
-               overrides/,\
-               .options,\
-               META-INF/,\
-               .
-jars.compile.order = .
-src.includes = about.html,\
-               model/,\
-               rose/
-output.. = bin/
-source.. = mofjava/,\
-           javainst/
diff --git a/plugins/org.eclipse.jem/eclipse32.gif b/plugins/org.eclipse.jem/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/plugins/org.eclipse.jem/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ImplicitAllocation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ImplicitAllocation.java
deleted file mode 100644
index b6058ee..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ImplicitAllocation.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: ImplicitAllocation.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Implicit Allocation</b></em>'.
- * <p>
- * This class is for an implicit allocation where the object comes from the feature of another object. It is the live Java value from the remote vm.
- * </p> 
- * @since 1.0.0
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This class is for an implicit allocation where the object comes from the feature of another object. It is the live Java value from the remote vm.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation#getParent <em>Parent</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation#getFeature <em>Feature</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getImplicitAllocation()
- * @model
- * @generated
- */
-public interface ImplicitAllocation extends JavaAllocation{
-	/**
-	 * Returns the value of the '<em><b>Parent</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * The parent who is to give up the value.
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Parent</em>' reference.
-	 * @see #setParent(EObject)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getImplicitAllocation_Parent()
-	 * @model required="true"
-	 * @generated
-	 */
-	EObject getParent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation#getParent <em>Parent</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Parent</em>' reference.
-	 * @see #getParent()
-	 * @generated
-	 */
-	void setParent(EObject value);
-
-	/**
-	 * Returns the value of the '<em><b>Feature</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * The feature that will be used to query the live value.
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Feature</em>' reference.
-	 * @see #setFeature(EStructuralFeature)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getImplicitAllocation_Feature()
-	 * @model required="true"
-	 * @generated
-	 */
-	EStructuralFeature getFeature();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation#getFeature <em>Feature</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Feature</em>' reference.
-	 * @see #getFeature()
-	 * @generated
-	 */
-	void setFeature(EStructuralFeature value);
-
-} // ImplicitAllocation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InitStringAllocation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InitStringAllocation.java
deleted file mode 100644
index b2f8973..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InitStringAllocation.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: InitStringAllocation.java,v $
- *  $Revision: 1.8 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Init String Allocation</b></em>'.
- * <p>
- * This is used when the allocation string can be parsed by the remote vm. It uses the allocString. 
- * </p>
- * @see org.eclipse.jem.internal.instantiation.JavaAllocation#getAllocString()
- * @since 1.0.0
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This is used when the allocation string can be parsed by the remote vm. It uses the allocString.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.InitStringAllocation#getInitString <em>Init String</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getInitStringAllocation()
- * @model
- * @generated
- */
-public interface InitStringAllocation extends JavaAllocation{
-	/**
-	 * Returns the value of the '<em><b>Init String</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Init String</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the initialization string for this object.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Init String</em>' attribute.
-	 * @see #setInitString(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getInitStringAllocation_InitString()
-	 * @model
-	 * @generated
-	 */
-	String getInitString();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.InitStringAllocation#getInitString <em>Init String</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Init String</em>' attribute.
-	 * @see #getInitString()
-	 * @generated
-	 */
-	void setInitString(String value);
-
-} // InitStringAllocation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InstantiationFactory.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InstantiationFactory.java
deleted file mode 100644
index 9eed166..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InstantiationFactory.java
+++ /dev/null
@@ -1,520 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: InstantiationFactory.java,v $
- *  $Revision: 1.10 $  $Date: 2005/10/28 22:56:46 $ 
- */
-
-import org.eclipse.emf.ecore.EFactory;
-
-import java.util.List;
-
-import org.eclipse.emf.ecore.*;
-
-import org.eclipse.jem.internal.instantiation.base.IJavaInstance;
-
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage
- * @generated
- */
-public interface InstantiationFactory extends EFactory{
-	/**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	InstantiationFactory eINSTANCE = new org.eclipse.jem.internal.instantiation.impl.InstantiationFactoryImpl();
-
-	/**
-	 * Returns a new object of class '<em>Init String Allocation</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Init String Allocation</em>'.
-	 * @generated
-	 */
-	InitStringAllocation createInitStringAllocation();
-
-	/**
-	 * Returns a new object of class '<em>Implicit Allocation</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Implicit Allocation</em>'.
-	 * @generated
-	 */
-	ImplicitAllocation createImplicitAllocation();
-
-	/**
-	 * Returns a new object of class '<em>Parse Tree Allocation</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Parse Tree Allocation</em>'.
-	 * @generated
-	 */
-	ParseTreeAllocation createParseTreeAllocation();
-
-	/**
-	 * Utility to create a parse tree allocation with an expression.
-	 * 
-	 * @param expression
-	 * @return The new parse tree allocation.
-	 * 
-	 * @since 1.0.0
-	 */
-	ParseTreeAllocation createParseTreeAllocation(PTExpression expression);
-	
-	/**
-	 * Returns a new object of class '<em>PT Array Access</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Array Access</em>'.
-	 * @generated
-	 */
-	PTArrayAccess createPTArrayAccess();
-
-	/**
-	 * Utility to create a new array access with the array and indexes.
-	 * 
-	 * @param array
-	 * @param indexes list of index expressions
-	 * @return The new array access.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTArrayAccess createPTArrayAccess(PTExpression array, List indexes);
-
-	/**
-	 * Returns a new object of class '<em>PT Array Creation</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Array Creation</em>'.
-	 * @generated
-	 */
-	PTArrayCreation createPTArrayCreation();
-
-	/**
-	 * Utility to create an array creation with the type, dimensions, and initializer.
-	 * 
-	 * @param type The type, e.g. <code>java.lang.String</code>.
-	 * @param dimensions The dimension expressions, <code>null</code> if no dimension expressions.
-	 * @param initializer The initializer, <code>null</code> if no initializer.
-	 * @return The new array creation.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTArrayCreation createPTArrayCreation(String type, List dimensions, PTArrayInitializer initializer);
-
-	/**
-	 * Returns a new object of class '<em>PT Array Initializer</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Array Initializer</em>'.
-	 * @generated
-	 */
-	PTArrayInitializer createPTArrayInitializer();
-
-	/**
-	 * Utility to create an array initilizer with initialize expessions.
-	 * @param expressions The list of expressions, <code>null</code> if empty array initializer.
-	 * @return The new array initializer.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTArrayInitializer createPTArrayInitializer(List expressions);
-
-	/**
-	 * Returns a new object of class '<em>PT Boolean Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Boolean Literal</em>'.
-	 * @generated
-	 */
-	PTBooleanLiteral createPTBooleanLiteral();
-
-	/**
-	 * Utility to create a boolean literal with a given value.
-	 * @param booleanValue
-	 * @return The new boolean literal.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTBooleanLiteral createPTBooleanLiteral(boolean booleanValue);
-	
-	/**
-	 * Returns a new object of class '<em>PT Cast Expression</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Cast Expression</em>'.
-	 * @generated
-	 */
-	PTCastExpression createPTCastExpression();
-
-	/**
-	 * Utility to create a new cast expression.
-	 * 
-	 * @param type The type of the expression, e.g. <code>short</code> or <code>java.lang.String</code>
-	 * @param expression The expression being cast.
-	 * @return The new cast expression.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTCastExpression createPTCastExpression(String type, PTExpression expression);
-
-	/**
-	 * Returns a new object of class '<em>PT Character Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Character Literal</em>'.
-	 * @generated
-	 */
-	PTCharacterLiteral createPTCharacterLiteral();
-
-	/**
-	 * Utility to create a new character literal.
-	 * @param escapedValue The escaped value to use.
-	 * @return The new character literal.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTCharacterLiteral createPTCharacterLiteral(String escapedValue);	
-
-	/**
-	 * Returns a new object of class '<em>PT Class Instance Creation</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Class Instance Creation</em>'.
-	 * @generated
-	 */
-	PTClassInstanceCreation createPTClassInstanceCreation();
-
-	/**
-	 * Utility to create a new class instance creation.
-	 * 
-	 * @param type The type of the class, e.g. <code>java.lang.String</code>.
-	 * @param arguments The list of expressions for arguments, or <code>null</code> for no args.
-	 * @return The new class instance creation.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTClassInstanceCreation createPTClassInstanceCreation(String type, List arguments);
-
-	/**
-	 * Returns a new object of class '<em>PT Conditional Expression</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Conditional Expression</em>'.
-	 * @generated
-	 */
-	PTConditionalExpression createPTConditionalExpression();
-
-	/**
-	 * Utility to create a new conditional expression with the condition and true/false expressions.
-	 * 
-	 * @param condition
-	 * @param trueExpressoin
-	 * @param falseExpression
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	PTConditionalExpression createPTConditionalExpression(PTExpression condition, PTExpression trueExpressoin, PTExpression falseExpression);
-
-	/**
-	 * Returns a new object of class '<em>PT Field Access</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Field Access</em>'.
-	 * @generated
-	 */
-	PTFieldAccess createPTFieldAccess();
-
-	/**
-	 * Utility to create a new field access with receiver and field name.
-	 * @param receiver The receiver expression, or <code>null</code> if none.
-	 * @param field The field name.
-	 * @return The new field access.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTFieldAccess createPTFieldAccess(PTExpression receiver, String field);	
-
-	/**
-	 * Returns a new object of class '<em>PT Infix Expression</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Infix Expression</em>'.
-	 * @generated
-	 */
-	PTInfixExpression createPTInfixExpression();
-
-	/**
-	 * Utility to create a new infix expression with the left/right/extended operands and the operator.
-	 * @param leftOperand
-	 * @param operator
-	 * @param rightOperand
-	 * @param extendedOperands The list of extended operands, or <code>null</code> if no extended operands.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	PTInfixExpression createPTInfixExpression(PTExpression leftOperand, PTInfixOperator operator, PTExpression rightOperand, List extendedOperands);
-
-	/**
-	 * Returns a new object of class '<em>PT Instanceof</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Instanceof</em>'.
-	 * @generated
-	 */
-	PTInstanceof createPTInstanceof();
-
-	/**
-	 * Utility to create a new instance of with an operand and a type.
-	 * @param operand
-	 * @param type
-	 * @return The new instance of.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTInstanceof createPTInstanceof(PTExpression operand, String type);
-
-	/**
-	 * Returns a new object of class '<em>PT Method Invocation</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Method Invocation</em>'.
-	 * @generated
-	 */
-	PTMethodInvocation createPTMethodInvocation();
-
-	/**
-	 * Utility to create a new method invocation with a receiver, name, and arguments.
-	 * 
-	 * @param receiver The receiver expression, or <code>null</code> if no receiver.
-	 * @param name The name of the method.
-	 * @param arguments The list of argument expressions, or <code>null</code> if no arguments.
-	 * @return The new method invocation.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTMethodInvocation createPTMethodInvocation(PTExpression receiver, String name, List arguments);
-
-	/**
-	 * Returns a new object of class '<em>PT Name</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Name</em>'.
-	 * @generated
-	 */
-	PTName createPTName();
-
-	/**
-	 * Utility to create a new name with the name.
-	 * 
-	 * @param name
-	 * @return The new name.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTName createPTName(String name);
-
-	/**
-	 * Returns a new object of class '<em>PT Null Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Null Literal</em>'.
-	 * @generated
-	 */
-	PTNullLiteral createPTNullLiteral();
-
-	/**
-	 * Returns a new object of class '<em>PT Number Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Number Literal</em>'.
-	 * @generated
-	 */
-	PTNumberLiteral createPTNumberLiteral();
-
-	/**
-	 * Utility to create a new number literal with the token.
-	 * @param token
-	 * @return The new number literal.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTNumberLiteral createPTNumberLiteral(String token);
-
-	/**
-	 * Returns a new object of class '<em>PT Parenthesized Expression</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Parenthesized Expression</em>'.
-	 * @generated
-	 */
-	PTParenthesizedExpression createPTParenthesizedExpression();
-
-	/**
-	 * Utility to create a new parenthesized expression with the expression.
-	 * @param expression The expression that is in the parenthesis.
-	 * @return The new parenthesized expression.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTParenthesizedExpression createPTParenthesizedExpression(PTExpression expression);
-
-	/**
-	 * Returns a new object of class '<em>PT Prefix Expression</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Prefix Expression</em>'.
-	 * @generated
-	 */
-	PTPrefixExpression createPTPrefixExpression();
-
-	/**
-	 * Utility to create a new prefix expression given an operator and expression.
-	 * @param operator
-	 * @param expression
-	 * @return The new prefix expression.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTPrefixExpression createPTPrefixExpression(PTPrefixOperator operator, PTExpression expression);
-
-	/**
-	 * Returns a new object of class '<em>PT String Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT String Literal</em>'.
-	 * @generated
-	 */
-	PTStringLiteral createPTStringLiteral();
-
-	/**
-	 * Utility to create a new string literal given the escaped literal string.
-	 * @param escapeLiteral
-	 * @return The new string literal.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTStringLiteral createPTStringLiteral(String escapeLiteral);
-
-	/**
-	 * Returns a new object of class '<em>PT This Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT This Literal</em>'.
-	 * @generated
-	 */
-	PTThisLiteral createPTThisLiteral();
-
-	/**
-	 * Returns a new object of class '<em>PT Type Literal</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Type Literal</em>'.
-	 * @generated
-	 */
-	PTTypeLiteral createPTTypeLiteral();
-
-	/**
-	 * Utility to create a new type literal given the type.
-	 * @param type
-	 * @return The new type literal.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTTypeLiteral createPTTypeLiteral(String type);
-
-	/**
-	 * Returns a new object of class '<em>PT Invalid Expression</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Invalid Expression</em>'.
-	 * @generated
-	 */
-	PTInvalidExpression createPTInvalidExpression();
-
-	/**
-	 * Returns a new object of class '<em>PT Instance Reference</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Instance Reference</em>'.
-	 * @generated
-	 */
-	PTInstanceReference createPTInstanceReference();
-
-	/**
-	 * Returns a new object of class '<em>PT Anonymous Class Declaration</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>PT Anonymous Class Declaration</em>'.
-	 * @generated
-	 */
-	PTAnonymousClassDeclaration createPTAnonymousClassDeclaration();
-
-	/**
-	 * Utility to create a new PTInstanceReference with a reference.
-	 * 
-	 * @param instance
-	 * @return a new object of class '<em>PT Instance Reference</em>'.
-	 * 
-	 * @since 1.2.0
-	 */
-	PTInstanceReference createPTInstanceReference(IJavaInstance instance);
-
-	/**
-	 * Utility to create a new invalid expression with a message.
-	 * @param message
-	 * @return The new invalid expression.
-	 * 
-	 * @since 1.0.0
-	 */
-	PTInvalidExpression createPTInvalidExpression(String message);
-
-	/**
-	 * Returns a new object of class '<em>Implicit Allocation</em>' as
-	 * utility with a given init string.
-	 * @param initString - String to put into initialization.
-	 * @return The allocation initialized.
-	 * 
-	 * @since 1.0.0
-	 */
-	InitStringAllocation createInitStringAllocation(String initString);
-	
-	/**
-	 * Returns a new object of class '<em>Implicit Allocation</em>' as
-	 * utility with a given parent and feature.
-	 * @param parent The source to get the value from.
-	 * @param sf The feature on the source for the value.
-	 * @return The allocation initialized.
-	 * 
-	 * @since 1.0.0
-	 */
-	ImplicitAllocation createImplicitAllocation(EObject parent, EStructuralFeature sf);
-
-	/**
-	 * Returns the package supported by this factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the package supported by this factory.
-	 * @generated
-	 */
-	InstantiationPackage getInstantiationPackage();
-
-} //InstantiationFactory
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InstantiationPackage.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InstantiationPackage.java
deleted file mode 100644
index 4f5a95f..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/InstantiationPackage.java
+++ /dev/null
@@ -1,1889 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: InstantiationPackage.java,v $
- *  $Revision: 1.12 $  $Date: 2005/10/28 22:56:46 $ 
- */
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EPackage;
-
-import org.eclipse.emf.ecore.EReference;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
- * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
- * </ul>
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * Java Instantiation Package
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.internal.instantiation.InstantiationFactory
- * @model kind="package"
- * @generated
- */
-public interface InstantiationPackage extends EPackage{
-	/**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNAME = "instantiation"; //$NON-NLS-1$
-
-	/**
-	 * The package namespace URI.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_URI = "http:///org/eclipse/jem/internal/instantiation.ecore"; //$NON-NLS-1$
-
-	/**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_PREFIX = "org.eclipse.jem.internal.instantiation"; //$NON-NLS-1$
-
-	/**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	InstantiationPackage eINSTANCE = org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl.init();
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.base.IJavaInstance <em>IJava Instance</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaInstance
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getIJavaInstance()
-	 * @generated
-	 */
-	int IJAVA_INSTANCE = 1;
-
-	/**
-	 * The number of structural features of the the '<em>IJava Instance</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IJAVA_INSTANCE_FEATURE_COUNT = 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance <em>IJava Object Instance</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getIJavaObjectInstance()
-	 * @generated
-	 */
-	int IJAVA_OBJECT_INSTANCE = 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance <em>IJava Data Type Instance</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getIJavaDataTypeInstance()
-	 * @generated
-	 */
-	int IJAVA_DATA_TYPE_INSTANCE = 0;
-
-
-	/**
-	 * The number of structural features of the the '<em>IJava Data Type Instance</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IJAVA_DATA_TYPE_INSTANCE_FEATURE_COUNT = IJAVA_INSTANCE_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>IJava Object Instance</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IJAVA_OBJECT_INSTANCE_FEATURE_COUNT = IJAVA_INSTANCE_FEATURE_COUNT + 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.JavaAllocationImpl <em>Java Allocation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.JavaAllocationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getJavaAllocation()
-	 * @generated
-	 */
-	int JAVA_ALLOCATION = 3;
-
-	/**
-	 * The number of structural features of the the '<em>Java Allocation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_ALLOCATION_FEATURE_COUNT = 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.InitStringAllocationImpl <em>Init String Allocation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.InitStringAllocationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getInitStringAllocation()
-	 * @generated
-	 */
-	int INIT_STRING_ALLOCATION = 4;
-
-	/**
-	 * The feature id for the '<em><b>Init String</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INIT_STRING_ALLOCATION__INIT_STRING = JAVA_ALLOCATION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>Init String Allocation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INIT_STRING_ALLOCATION_FEATURE_COUNT = JAVA_ALLOCATION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.ImplicitAllocationImpl <em>Implicit Allocation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.ImplicitAllocationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getImplicitAllocation()
-	 * @generated
-	 */
-	int IMPLICIT_ALLOCATION = 5;
-
-	/**
-	 * The feature id for the '<em><b>Parent</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IMPLICIT_ALLOCATION__PARENT = JAVA_ALLOCATION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Feature</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IMPLICIT_ALLOCATION__FEATURE = JAVA_ALLOCATION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>Implicit Allocation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IMPLICIT_ALLOCATION_FEATURE_COUNT = JAVA_ALLOCATION_FEATURE_COUNT + 2;
-
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.ParseTreeAllocationImpl <em>Parse Tree Allocation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.ParseTreeAllocationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getParseTreeAllocation()
-	 * @generated
-	 */
-	int PARSE_TREE_ALLOCATION = 6;
-
-	/**
-	 * The feature id for the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARSE_TREE_ALLOCATION__EXPRESSION = JAVA_ALLOCATION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>Parse Tree Allocation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARSE_TREE_ALLOCATION_FEATURE_COUNT = JAVA_ALLOCATION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTExpressionImpl <em>PT Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTExpression()
-	 * @generated
-	 */
-	int PT_EXPRESSION = 7;
-
-	/**
-	 * The number of structural features of the the '<em>PT Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_EXPRESSION_FEATURE_COUNT = 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTArrayAccessImpl <em>PT Array Access</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTArrayAccessImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTArrayAccess()
-	 * @generated
-	 */
-	int PT_ARRAY_ACCESS = 8;
-
-	/**
-	 * The feature id for the '<em><b>Array</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_ACCESS__ARRAY = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Indexes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_ACCESS__INDEXES = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Array Access</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_ACCESS_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTArrayCreationImpl <em>PT Array Creation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTArrayCreationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTArrayCreation()
-	 * @generated
-	 */
-	int PT_ARRAY_CREATION = 9;
-
-	/**
-	 * The feature id for the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_CREATION__TYPE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Dimensions</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_CREATION__DIMENSIONS = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Initializer</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_CREATION__INITIALIZER = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the the '<em>PT Array Creation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_CREATION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTArrayInitializerImpl <em>PT Array Initializer</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTArrayInitializerImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTArrayInitializer()
-	 * @generated
-	 */
-	int PT_ARRAY_INITIALIZER = 10;
-
-	/**
-	 * The feature id for the '<em><b>Expressions</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_INITIALIZER__EXPRESSIONS = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Array Initializer</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ARRAY_INITIALIZER_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTBooleanLiteralImpl <em>PT Boolean Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTBooleanLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTBooleanLiteral()
-	 * @generated
-	 */
-	int PT_BOOLEAN_LITERAL = 11;
-
-	/**
-	 * The feature id for the '<em><b>Boolean Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_BOOLEAN_LITERAL__BOOLEAN_VALUE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Boolean Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_BOOLEAN_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTCastExpressionImpl <em>PT Cast Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTCastExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTCastExpression()
-	 * @generated
-	 */
-	int PT_CAST_EXPRESSION = 12;
-
-	/**
-	 * The feature id for the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CAST_EXPRESSION__TYPE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CAST_EXPRESSION__EXPRESSION = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Cast Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CAST_EXPRESSION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTCharacterLiteralImpl <em>PT Character Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTCharacterLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTCharacterLiteral()
-	 * @generated
-	 */
-	int PT_CHARACTER_LITERAL = 13;
-
-	/**
-	 * The feature id for the '<em><b>Escaped Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CHARACTER_LITERAL__ESCAPED_VALUE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Char Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CHARACTER_LITERAL__CHAR_VALUE = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Character Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CHARACTER_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTClassInstanceCreationImpl <em>PT Class Instance Creation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTClassInstanceCreationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTClassInstanceCreation()
-	 * @generated
-	 */
-	int PT_CLASS_INSTANCE_CREATION = 14;
-
-	/**
-	 * The feature id for the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CLASS_INSTANCE_CREATION__TYPE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Arguments</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CLASS_INSTANCE_CREATION__ARGUMENTS = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Class Instance Creation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CLASS_INSTANCE_CREATION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTConditionalExpressionImpl <em>PT Conditional Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTConditionalExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTConditionalExpression()
-	 * @generated
-	 */
-	int PT_CONDITIONAL_EXPRESSION = 15;
-
-	/**
-	 * The feature id for the '<em><b>Condition</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CONDITIONAL_EXPRESSION__CONDITION = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>True</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CONDITIONAL_EXPRESSION__TRUE = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>False</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CONDITIONAL_EXPRESSION__FALSE = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the the '<em>PT Conditional Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_CONDITIONAL_EXPRESSION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTFieldAccessImpl <em>PT Field Access</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTFieldAccessImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTFieldAccess()
-	 * @generated
-	 */
-	int PT_FIELD_ACCESS = 16;
-
-	/**
-	 * The feature id for the '<em><b>Receiver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_FIELD_ACCESS__RECEIVER = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Field</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_FIELD_ACCESS__FIELD = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Field Access</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_FIELD_ACCESS_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTInfixExpressionImpl <em>PT Infix Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTInfixExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTInfixExpression()
-	 * @generated
-	 */
-	int PT_INFIX_EXPRESSION = 17;
-
-	/**
-	 * The feature id for the '<em><b>Left Operand</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INFIX_EXPRESSION__LEFT_OPERAND = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Operator</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INFIX_EXPRESSION__OPERATOR = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Right Operand</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INFIX_EXPRESSION__RIGHT_OPERAND = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Extended Operands</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INFIX_EXPRESSION__EXTENDED_OPERANDS = PT_EXPRESSION_FEATURE_COUNT + 3;
-
-	/**
-	 * The number of structural features of the the '<em>PT Infix Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INFIX_EXPRESSION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 4;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTInstanceofImpl <em>PT Instanceof</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTInstanceofImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTInstanceof()
-	 * @generated
-	 */
-	int PT_INSTANCEOF = 18;
-
-	/**
-	 * The feature id for the '<em><b>Operand</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INSTANCEOF__OPERAND = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INSTANCEOF__TYPE = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Instanceof</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INSTANCEOF_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTMethodInvocationImpl <em>PT Method Invocation</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTMethodInvocationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTMethodInvocation()
-	 * @generated
-	 */
-	int PT_METHOD_INVOCATION = 19;
-
-	/**
-	 * The feature id for the '<em><b>Receiver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_METHOD_INVOCATION__RECEIVER = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_METHOD_INVOCATION__NAME = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Arguments</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_METHOD_INVOCATION__ARGUMENTS = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The number of structural features of the the '<em>PT Method Invocation</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_METHOD_INVOCATION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTNameImpl <em>PT Name</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTNameImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTName()
-	 * @generated
-	 */
-	int PT_NAME = 20;
-
-	/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_NAME__NAME = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Name</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_NAME_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTNullLiteralImpl <em>PT Null Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTNullLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTNullLiteral()
-	 * @generated
-	 */
-	int PT_NULL_LITERAL = 21;
-
-	/**
-	 * The number of structural features of the the '<em>PT Null Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_NULL_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTNumberLiteralImpl <em>PT Number Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTNumberLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTNumberLiteral()
-	 * @generated
-	 */
-	int PT_NUMBER_LITERAL = 22;
-
-	/**
-	 * The feature id for the '<em><b>Token</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_NUMBER_LITERAL__TOKEN = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Number Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_NUMBER_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTParenthesizedExpressionImpl <em>PT Parenthesized Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTParenthesizedExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTParenthesizedExpression()
-	 * @generated
-	 */
-	int PT_PARENTHESIZED_EXPRESSION = 23;
-
-	/**
-	 * The feature id for the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_PARENTHESIZED_EXPRESSION__EXPRESSION = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Parenthesized Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_PARENTHESIZED_EXPRESSION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTPrefixExpressionImpl <em>PT Prefix Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTPrefixExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTPrefixExpression()
-	 * @generated
-	 */
-	int PT_PREFIX_EXPRESSION = 24;
-
-	/**
-	 * The feature id for the '<em><b>Operator</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_PREFIX_EXPRESSION__OPERATOR = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_PREFIX_EXPRESSION__EXPRESSION = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Prefix Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_PREFIX_EXPRESSION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTStringLiteralImpl <em>PT String Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTStringLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTStringLiteral()
-	 * @generated
-	 */
-	int PT_STRING_LITERAL = 25;
-
-	/**
-	 * The feature id for the '<em><b>Escaped Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_STRING_LITERAL__ESCAPED_VALUE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Literal Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_STRING_LITERAL__LITERAL_VALUE = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT String Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_STRING_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTThisLiteralImpl <em>PT This Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTThisLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTThisLiteral()
-	 * @generated
-	 */
-	int PT_THIS_LITERAL = 26;
-
-	/**
-	 * The number of structural features of the the '<em>PT This Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_THIS_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTTypeLiteralImpl <em>PT Type Literal</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTTypeLiteralImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTTypeLiteral()
-	 * @generated
-	 */
-	int PT_TYPE_LITERAL = 27;
-
-	/**
-	 * The feature id for the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_TYPE_LITERAL__TYPE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Type Literal</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_TYPE_LITERAL_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTInvalidExpressionImpl <em>PT Invalid Expression</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTInvalidExpressionImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTInvalidExpression()
-	 * @generated
-	 */
-	int PT_INVALID_EXPRESSION = 28;
-
-	/**
-	 * The feature id for the '<em><b>Message</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INVALID_EXPRESSION__MESSAGE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Invalid Expression</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INVALID_EXPRESSION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTInstanceReferenceImpl <em>PT Instance Reference</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTInstanceReferenceImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTInstanceReference()
-	 * @generated
-	 */
-	int PT_INSTANCE_REFERENCE = 29;
-
-	/**
-	 * The feature id for the '<em><b>Reference</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INSTANCE_REFERENCE__REFERENCE = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The number of structural features of the the '<em>PT Instance Reference</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_INSTANCE_REFERENCE_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.impl.PTAnonymousClassDeclarationImpl <em>PT Anonymous Class Declaration</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTAnonymousClassDeclarationImpl
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTAnonymousClassDeclaration()
-	 * @generated
-	 */
-	int PT_ANONYMOUS_CLASS_DECLARATION = 30;
-
-	/**
-	 * The feature id for the '<em><b>Declaration</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION = PT_EXPRESSION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Imports</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS = PT_EXPRESSION_FEATURE_COUNT + 1;
-
-	/**
-	 * The number of structural features of the the '<em>PT Anonymous Class Declaration</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PT_ANONYMOUS_CLASS_DECLARATION_FEATURE_COUNT = PT_EXPRESSION_FEATURE_COUNT + 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.PTInfixOperator <em>PT Infix Operator</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixOperator
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTInfixOperator()
-	 * @generated
-	 */
-	int PT_INFIX_OPERATOR = 31;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.jem.internal.instantiation.PTPrefixOperator <em>PT Prefix Operator</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixOperator
-	 * @see org.eclipse.jem.internal.instantiation.impl.InstantiationPackageImpl#getPTPrefixOperator()
-	 * @generated
-	 */
-	int PT_PREFIX_OPERATOR = 32;
-
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance <em>IJava Object Instance</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>IJava Object Instance</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance
-	 * @model instanceClass="org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance"
-	 * @generated
-	 */
-	EClass getIJavaObjectInstance();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.JavaAllocation <em>Java Allocation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Java Allocation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.JavaAllocation
-	 * @generated
-	 */
-	EClass getJavaAllocation();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.InitStringAllocation <em>Init String Allocation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Init String Allocation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.InitStringAllocation
-	 * @generated
-	 */
-	EClass getInitStringAllocation();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.InitStringAllocation#getInitString <em>Init String</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Init String</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.InitStringAllocation#getInitString()
-	 * @see #getInitStringAllocation()
-	 * @generated
-	 */
-	EAttribute getInitStringAllocation_InitString();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation <em>Implicit Allocation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Implicit Allocation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.ImplicitAllocation
-	 * @generated
-	 */
-	EClass getImplicitAllocation();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation#getParent <em>Parent</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Parent</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.ImplicitAllocation#getParent()
-	 * @see #getImplicitAllocation()
-	 * @generated
-	 */
-	EReference getImplicitAllocation_Parent();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.instantiation.ImplicitAllocation#getFeature <em>Feature</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Feature</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.ImplicitAllocation#getFeature()
-	 * @see #getImplicitAllocation()
-	 * @generated
-	 */
-	EReference getImplicitAllocation_Feature();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.ParseTreeAllocation <em>Parse Tree Allocation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Parse Tree Allocation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.ParseTreeAllocation
-	 * @generated
-	 */
-	EClass getParseTreeAllocation();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.ParseTreeAllocation#getExpression <em>Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.ParseTreeAllocation#getExpression()
-	 * @see #getParseTreeAllocation()
-	 * @generated
-	 */
-	EReference getParseTreeAllocation_Expression();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTExpression <em>PT Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTExpression
-	 * @generated
-	 */
-	EClass getPTExpression();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTArrayAccess <em>PT Array Access</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Array Access</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayAccess
-	 * @generated
-	 */
-	EClass getPTArrayAccess();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTArrayAccess#getArray <em>Array</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Array</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayAccess#getArray()
-	 * @see #getPTArrayAccess()
-	 * @generated
-	 */
-	EReference getPTArrayAccess_Array();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.instantiation.PTArrayAccess#getIndexes <em>Indexes</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Indexes</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayAccess#getIndexes()
-	 * @see #getPTArrayAccess()
-	 * @generated
-	 */
-	EReference getPTArrayAccess_Indexes();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTArrayCreation <em>PT Array Creation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Array Creation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayCreation
-	 * @generated
-	 */
-	EClass getPTArrayCreation();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Type</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayCreation#getType()
-	 * @see #getPTArrayCreation()
-	 * @generated
-	 */
-	EAttribute getPTArrayCreation_Type();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getDimensions <em>Dimensions</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Dimensions</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayCreation#getDimensions()
-	 * @see #getPTArrayCreation()
-	 * @generated
-	 */
-	EReference getPTArrayCreation_Dimensions();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getInitializer <em>Initializer</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Initializer</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayCreation#getInitializer()
-	 * @see #getPTArrayCreation()
-	 * @generated
-	 */
-	EReference getPTArrayCreation_Initializer();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTArrayInitializer <em>PT Array Initializer</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Array Initializer</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayInitializer
-	 * @generated
-	 */
-	EClass getPTArrayInitializer();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.instantiation.PTArrayInitializer#getExpressions <em>Expressions</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Expressions</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTArrayInitializer#getExpressions()
-	 * @see #getPTArrayInitializer()
-	 * @generated
-	 */
-	EReference getPTArrayInitializer_Expressions();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTBooleanLiteral <em>PT Boolean Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Boolean Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTBooleanLiteral
-	 * @generated
-	 */
-	EClass getPTBooleanLiteral();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTBooleanLiteral#isBooleanValue <em>Boolean Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Boolean Value</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTBooleanLiteral#isBooleanValue()
-	 * @see #getPTBooleanLiteral()
-	 * @generated
-	 */
-	EAttribute getPTBooleanLiteral_BooleanValue();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTCastExpression <em>PT Cast Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Cast Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTCastExpression
-	 * @generated
-	 */
-	EClass getPTCastExpression();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTCastExpression#getType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Type</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTCastExpression#getType()
-	 * @see #getPTCastExpression()
-	 * @generated
-	 */
-	EAttribute getPTCastExpression_Type();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTCastExpression#getExpression <em>Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTCastExpression#getExpression()
-	 * @see #getPTCastExpression()
-	 * @generated
-	 */
-	EReference getPTCastExpression_Expression();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral <em>PT Character Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Character Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTCharacterLiteral
-	 * @generated
-	 */
-	EClass getPTCharacterLiteral();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getEscapedValue <em>Escaped Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Escaped Value</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getEscapedValue()
-	 * @see #getPTCharacterLiteral()
-	 * @generated
-	 */
-	EAttribute getPTCharacterLiteral_EscapedValue();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getCharValue <em>Char Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Char Value</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getCharValue()
-	 * @see #getPTCharacterLiteral()
-	 * @generated
-	 */
-	EAttribute getPTCharacterLiteral_CharValue();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTClassInstanceCreation <em>PT Class Instance Creation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Class Instance Creation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTClassInstanceCreation
-	 * @generated
-	 */
-	EClass getPTClassInstanceCreation();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Type</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getType()
-	 * @see #getPTClassInstanceCreation()
-	 * @generated
-	 */
-	EAttribute getPTClassInstanceCreation_Type();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getArguments <em>Arguments</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Arguments</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getArguments()
-	 * @see #getPTClassInstanceCreation()
-	 * @generated
-	 */
-	EReference getPTClassInstanceCreation_Arguments();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression <em>PT Conditional Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Conditional Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTConditionalExpression
-	 * @generated
-	 */
-	EClass getPTConditionalExpression();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getCondition <em>Condition</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Condition</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTConditionalExpression#getCondition()
-	 * @see #getPTConditionalExpression()
-	 * @generated
-	 */
-	EReference getPTConditionalExpression_Condition();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getTrue <em>True</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>True</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTConditionalExpression#getTrue()
-	 * @see #getPTConditionalExpression()
-	 * @generated
-	 */
-	EReference getPTConditionalExpression_True();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getFalse <em>False</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>False</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTConditionalExpression#getFalse()
-	 * @see #getPTConditionalExpression()
-	 * @generated
-	 */
-	EReference getPTConditionalExpression_False();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTFieldAccess <em>PT Field Access</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Field Access</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTFieldAccess
-	 * @generated
-	 */
-	EClass getPTFieldAccess();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTFieldAccess#getReceiver <em>Receiver</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Receiver</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTFieldAccess#getReceiver()
-	 * @see #getPTFieldAccess()
-	 * @generated
-	 */
-	EReference getPTFieldAccess_Receiver();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTFieldAccess#getField <em>Field</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Field</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTFieldAccess#getField()
-	 * @see #getPTFieldAccess()
-	 * @generated
-	 */
-	EAttribute getPTFieldAccess_Field();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression <em>PT Infix Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Infix Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixExpression
-	 * @generated
-	 */
-	EClass getPTInfixExpression();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getLeftOperand <em>Left Operand</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Left Operand</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixExpression#getLeftOperand()
-	 * @see #getPTInfixExpression()
-	 * @generated
-	 */
-	EReference getPTInfixExpression_LeftOperand();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getOperator <em>Operator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Operator</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixExpression#getOperator()
-	 * @see #getPTInfixExpression()
-	 * @generated
-	 */
-	EAttribute getPTInfixExpression_Operator();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getRightOperand <em>Right Operand</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Right Operand</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixExpression#getRightOperand()
-	 * @see #getPTInfixExpression()
-	 * @generated
-	 */
-	EReference getPTInfixExpression_RightOperand();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getExtendedOperands <em>Extended Operands</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Extended Operands</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixExpression#getExtendedOperands()
-	 * @see #getPTInfixExpression()
-	 * @generated
-	 */
-	EReference getPTInfixExpression_ExtendedOperands();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTInstanceof <em>PT Instanceof</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Instanceof</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInstanceof
-	 * @generated
-	 */
-	EClass getPTInstanceof();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTInstanceof#getOperand <em>Operand</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Operand</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInstanceof#getOperand()
-	 * @see #getPTInstanceof()
-	 * @generated
-	 */
-	EReference getPTInstanceof_Operand();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTInstanceof#getType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Type</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInstanceof#getType()
-	 * @see #getPTInstanceof()
-	 * @generated
-	 */
-	EAttribute getPTInstanceof_Type();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation <em>PT Method Invocation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Method Invocation</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTMethodInvocation
-	 * @generated
-	 */
-	EClass getPTMethodInvocation();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getReceiver <em>Receiver</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Receiver</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTMethodInvocation#getReceiver()
-	 * @see #getPTMethodInvocation()
-	 * @generated
-	 */
-	EReference getPTMethodInvocation_Receiver();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Name</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTMethodInvocation#getName()
-	 * @see #getPTMethodInvocation()
-	 * @generated
-	 */
-	EAttribute getPTMethodInvocation_Name();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getArguments <em>Arguments</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Arguments</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTMethodInvocation#getArguments()
-	 * @see #getPTMethodInvocation()
-	 * @generated
-	 */
-	EReference getPTMethodInvocation_Arguments();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTName <em>PT Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Name</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTName
-	 * @generated
-	 */
-	EClass getPTName();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTName#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Name</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTName#getName()
-	 * @see #getPTName()
-	 * @generated
-	 */
-	EAttribute getPTName_Name();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTNullLiteral <em>PT Null Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Null Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTNullLiteral
-	 * @generated
-	 */
-	EClass getPTNullLiteral();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTNumberLiteral <em>PT Number Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Number Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTNumberLiteral
-	 * @generated
-	 */
-	EClass getPTNumberLiteral();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTNumberLiteral#getToken <em>Token</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Token</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTNumberLiteral#getToken()
-	 * @see #getPTNumberLiteral()
-	 * @generated
-	 */
-	EAttribute getPTNumberLiteral_Token();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTParenthesizedExpression <em>PT Parenthesized Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Parenthesized Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTParenthesizedExpression
-	 * @generated
-	 */
-	EClass getPTParenthesizedExpression();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTParenthesizedExpression#getExpression <em>Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTParenthesizedExpression#getExpression()
-	 * @see #getPTParenthesizedExpression()
-	 * @generated
-	 */
-	EReference getPTParenthesizedExpression_Expression();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression <em>PT Prefix Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Prefix Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixExpression
-	 * @generated
-	 */
-	EClass getPTPrefixExpression();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression#getOperator <em>Operator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Operator</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixExpression#getOperator()
-	 * @see #getPTPrefixExpression()
-	 * @generated
-	 */
-	EAttribute getPTPrefixExpression_Operator();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression#getExpression <em>Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixExpression#getExpression()
-	 * @see #getPTPrefixExpression()
-	 * @generated
-	 */
-	EReference getPTPrefixExpression_Expression();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTStringLiteral <em>PT String Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT String Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTStringLiteral
-	 * @generated
-	 */
-	EClass getPTStringLiteral();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTStringLiteral#getEscapedValue <em>Escaped Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Escaped Value</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTStringLiteral#getEscapedValue()
-	 * @see #getPTStringLiteral()
-	 * @generated
-	 */
-	EAttribute getPTStringLiteral_EscapedValue();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTStringLiteral#getLiteralValue <em>Literal Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Literal Value</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTStringLiteral#getLiteralValue()
-	 * @see #getPTStringLiteral()
-	 * @generated
-	 */
-	EAttribute getPTStringLiteral_LiteralValue();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTThisLiteral <em>PT This Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT This Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTThisLiteral
-	 * @generated
-	 */
-	EClass getPTThisLiteral();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTTypeLiteral <em>PT Type Literal</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Type Literal</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTTypeLiteral
-	 * @generated
-	 */
-	EClass getPTTypeLiteral();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTTypeLiteral#getType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Type</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTTypeLiteral#getType()
-	 * @see #getPTTypeLiteral()
-	 * @generated
-	 */
-	EAttribute getPTTypeLiteral_Type();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTInvalidExpression <em>PT Invalid Expression</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Invalid Expression</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInvalidExpression
-	 * @generated
-	 */
-	EClass getPTInvalidExpression();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTInvalidExpression#getMessage <em>Message</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Message</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInvalidExpression#getMessage()
-	 * @see #getPTInvalidExpression()
-	 * @generated
-	 */
-	EAttribute getPTInvalidExpression_Message();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTInstanceReference <em>PT Instance Reference</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Instance Reference</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInstanceReference
-	 * @generated
-	 */
-	EClass getPTInstanceReference();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.jem.internal.instantiation.PTInstanceReference#getReference <em>Reference</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Reference</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInstanceReference#getReference()
-	 * @see #getPTInstanceReference()
-	 * @generated
-	 */
-	EReference getPTInstanceReference_Reference();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration <em>PT Anonymous Class Declaration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>PT Anonymous Class Declaration</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration
-	 * @generated
-	 */
-	EClass getPTAnonymousClassDeclaration();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getDeclaration <em>Declaration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Declaration</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getDeclaration()
-	 * @see #getPTAnonymousClassDeclaration()
-	 * @generated
-	 */
-	EAttribute getPTAnonymousClassDeclaration_Declaration();
-
-	/**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getImports <em>Imports</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Imports</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getImports()
-	 * @see #getPTAnonymousClassDeclaration()
-	 * @generated
-	 */
-	EAttribute getPTAnonymousClassDeclaration_Imports();
-
-	/**
-	 * Returns the meta object for enum '{@link org.eclipse.jem.internal.instantiation.PTInfixOperator <em>PT Infix Operator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for enum '<em>PT Infix Operator</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixOperator
-	 * @generated
-	 */
-	EEnum getPTInfixOperator();
-
-	/**
-	 * Returns the meta object for enum '{@link org.eclipse.jem.internal.instantiation.PTPrefixOperator <em>PT Prefix Operator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for enum '<em>PT Prefix Operator</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixOperator
-	 * @generated
-	 */
-	EEnum getPTPrefixOperator();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance <em>IJava Data Type Instance</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>IJava Data Type Instance</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance
-	 * @model instanceClass="org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance"
-	 * @generated
-	 */
-	EClass getIJavaDataTypeInstance();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.jem.internal.instantiation.base.IJavaInstance <em>IJava Instance</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>IJava Instance</em>'.
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaInstance
-	 * @model instanceClass="org.eclipse.jem.internal.instantiation.base.IJavaInstance"
-	 * @generated
-	 */
-	EClass getIJavaInstance();
-
-	/**
-	 * Returns the factory that creates the instances of the model.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the factory that creates the instances of the model.
-	 * @generated
-	 */
-	InstantiationFactory getInstantiationFactory();
-
-} //InstantiationPackage
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/JavaAllocation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/JavaAllocation.java
deleted file mode 100644
index 75529f4..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/JavaAllocation.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: JavaAllocation.java,v $
- *  $Revision: 1.7 $  $Date: 2005/10/03 19:20:41 $ 
- */
- 
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Java Allocation</b></em>'.
- * <p>
- * This class is the abstract base class of the allocation class. It is the value of the "allocation" property on a Java Object so that the actual allocation can be controlled. For example, there could be one for just init string, or one for serialized.
- * </p>
- * @since 1.0.0
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This class is the abstract base class of the allocation class. It is the value of the "allocation" property on a Java Object so that the actual allocation can be controlled. For example, there could be one for just init string, or one for serialized.
- * <!-- end-model-doc -->
- *
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getJavaAllocation()
- * @model abstract="true"
- * @generated
- */
-public interface JavaAllocation extends EObject{
-	
-	/**
-	 * Answer whether the allocation is a parse tree allocation.
-	 * @return <code>true</code> if parse tree allocation
-	 * 
-	 * @since 1.2.0
-	 */
-	public boolean isParseTree();
-	
-	/**
-	 * Answer whether the allocation is an implicit allocation.
-	 * @return <code>true</code> if implicit allocation
-	 * 
-	 * @since 1.2.0
-	 */
-	public boolean isImplicit();
-} // JavaAllocation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTAnonymousClassDeclaration.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTAnonymousClassDeclaration.java
deleted file mode 100644
index 2eb6b8a..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTAnonymousClassDeclaration.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * <copyright>
- * </copyright>
- *
- * $Id: PTAnonymousClassDeclaration.java,v 1.1 2005/10/28 22:56:46 rkulp Exp $
- */
-package org.eclipse.jem.internal.instantiation;
-
-
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>PT Anonymous Class Declaration</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * An anonymous class declaration. Currently we only store the 
- * entire declaration as a string, including the "new AClass() {...}".
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getDeclaration <em>Declaration</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getImports <em>Imports</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTAnonymousClassDeclaration()
- * @model
- * @generated
- */
-public interface PTAnonymousClassDeclaration extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Declaration</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The declaration text.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Declaration</em>' attribute.
-	 * @see #setDeclaration(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTAnonymousClassDeclaration_Declaration()
-	 * @model
-	 * @generated
-	 */
-	String getDeclaration();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration#getDeclaration <em>Declaration</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Declaration</em>' attribute.
-	 * @see #getDeclaration()
-	 * @generated
-	 */
-	void setDeclaration(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Imports</b></em>' attribute list.
-	 * The list contents are of type {@link java.lang.String}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the imports needed in the main class by this declaration. This is a transient attribute. It is not serialized, nor is it parsed into from existing code. Its only purpose is to help code generation on a brand new declaration to know what imports should be added to the main class.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Imports</em>' attribute list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTAnonymousClassDeclaration_Imports()
-	 * @model type="java.lang.String" transient="true"
-	 * @generated
-	 */
-	EList getImports();
-
-} // PTAnonymousClassDeclaration
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayAccess.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayAccess.java
deleted file mode 100644
index ab68fa6..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayAccess.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTArrayAccess.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Array Access</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Array access. e.g. x[3]. 
- * 
- * Unlike AST, the entire expression of type x[3][4] will be done in one expression rather than having a separate ArrayAccess for each dimension. This is just a simplification. This can only be used if it is a simple array access where it is of the form {expression}[expression][expression].
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTArrayAccess#getArray <em>Array</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTArrayAccess#getIndexes <em>Indexes</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayAccess()
- * @model
- * @generated
- */
-public interface PTArrayAccess extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Array</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The expression representing the array to access.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Array</em>' containment reference.
-	 * @see #setArray(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayAccess_Array()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getArray();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTArrayAccess#getArray <em>Array</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Array</em>' containment reference.
-	 * @see #getArray()
-	 * @generated
-	 */
-	void setArray(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>Indexes</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.instantiation.PTExpression}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The expressions representing the indexes of the access.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Indexes</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayAccess_Indexes()
-	 * @model type="org.eclipse.jem.internal.instantiation.PTExpression" containment="true" required="true"
-	 * @generated
-	 */
-	EList getIndexes();
-
-} // ArrayAccess
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayCreation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayCreation.java
deleted file mode 100644
index a84740b..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayCreation.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTArrayCreation.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Array Creation</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Array Creation expression, e.g. new int[3] or new java.langString[][] {{"a"}, {"b"}}
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getDimensions <em>Dimensions</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getInitializer <em>Initializer</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayCreation()
- * @model
- * @generated
- */
-public interface PTArrayCreation extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The fully-qualified type, e.g. int[][] or java.lang.String[], including the number of dimension brackets.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Type</em>' attribute.
-	 * @see #setType(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayCreation_Type()
-	 * @model
-	 * @generated
-	 */
-	String getType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getType <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Type</em>' attribute.
-	 * @see #getType()
-	 * @generated
-	 */
-	void setType(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Dimensions</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.instantiation.PTExpression}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The list of expressions for the dimensions. You can have [3][4][] but [][33] is invalid. So for each dimension that has an expression, there will be an entry in the list, in the correct order. When you reach the empty dimensions, the list will end too. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Dimensions</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayCreation_Dimensions()
-	 * @model type="org.eclipse.jem.internal.instantiation.PTExpression" containment="true"
-	 * @generated
-	 */
-	EList getDimensions();
-
-	/**
-	 * Returns the value of the '<em><b>Initializer</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the initializer, if any, for this array. E.g. new int[] {2,3}. It is the {2,3}.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Initializer</em>' containment reference.
-	 * @see #setInitializer(PTArrayInitializer)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayCreation_Initializer()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTArrayInitializer getInitializer();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTArrayCreation#getInitializer <em>Initializer</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Initializer</em>' containment reference.
-	 * @see #getInitializer()
-	 * @generated
-	 */
-	void setInitializer(PTArrayInitializer value);
-
-} // ArrayCreation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayInitializer.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayInitializer.java
deleted file mode 100644
index bfaaa4e..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTArrayInitializer.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTArrayInitializer.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Array Initializer</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Array initialization expression. This is the entire expression, e.g. {2, 3}, or {{2,3}, 4}. In the second case, the {2,3} will be an ArrayInitializer contained within the expressions list for the top ArrayInitializer.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTArrayInitializer#getExpressions <em>Expressions</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayInitializer()
- * @model
- * @generated
- */
-public interface PTArrayInitializer extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Expressions</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.instantiation.PTExpression}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This isthe list of expressions within the initializer, e.g. {2, 3}, or {{2,3}, 4}. In the first case it will be two NumberLiterals. In the second case, the {2,3} will be an ArrayInitializer, followed by a NumberLiteral.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Expressions</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTArrayInitializer_Expressions()
-	 * @model type="org.eclipse.jem.internal.instantiation.PTExpression" containment="true"
-	 * @generated
-	 */
-	EList getExpressions();
-
-} // ArrayInitializer
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTBooleanLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTBooleanLiteral.java
deleted file mode 100644
index 4ad258d..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTBooleanLiteral.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTBooleanLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Boolean Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This represents a primitive boolean literal, i.e. true or false directly in the code.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTBooleanLiteral#isBooleanValue <em>Boolean Value</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTBooleanLiteral()
- * @model
- * @generated
- */
-public interface PTBooleanLiteral extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Boolean Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The value of the literal.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Boolean Value</em>' attribute.
-	 * @see #setBooleanValue(boolean)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTBooleanLiteral_BooleanValue()
-	 * @model
-	 * @generated
-	 */
-	boolean isBooleanValue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTBooleanLiteral#isBooleanValue <em>Boolean Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Boolean Value</em>' attribute.
-	 * @see #isBooleanValue()
-	 * @generated
-	 */
-	void setBooleanValue(boolean value);
-
-} // BooleanLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTCastExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTCastExpression.java
deleted file mode 100644
index f34a373..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTCastExpression.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTCastExpression.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Cast</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Cast expression, e.g. (short) 10
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTCastExpression#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTCastExpression#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTCastExpression()
- * @model
- * @generated
- */
-public interface PTCastExpression extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the fully-qualified type of the cast, e.g. int or java.lang.String
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Type</em>' attribute.
-	 * @see #setType(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTCastExpression_Type()
-	 * @model
-	 * @generated
-	 */
-	String getType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTCastExpression#getType <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Type</em>' attribute.
-	 * @see #getType()
-	 * @generated
-	 */
-	void setType(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The expression being casted.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Expression</em>' containment reference.
-	 * @see #setExpression(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTCastExpression_Expression()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getExpression();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTCastExpression#getExpression <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Expression</em>' containment reference.
-	 * @see #getExpression()
-	 * @generated
-	 */
-	void setExpression(PTExpression value);
-
-} // Cast
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTCharacterLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTCharacterLiteral.java
deleted file mode 100644
index bc37ec5..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTCharacterLiteral.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTCharacterLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Character Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This represents a primitive character expression, e.g. 'a' or '\r'.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getEscapedValue <em>Escaped Value</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getCharValue <em>Char Value</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTCharacterLiteral()
- * @model
- * @generated
- */
-public interface PTCharacterLiteral extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Escaped Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the escaped character. In other words the literal exactly as it is in the java file. E.g. 'a' or '\r'. Including the surrounding single quotes themselves.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Escaped Value</em>' attribute.
-	 * @see #setEscapedValue(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTCharacterLiteral_EscapedValue()
-	 * @model
-	 * @generated
-	 */
-	String getEscapedValue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getEscapedValue <em>Escaped Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Escaped Value</em>' attribute.
-	 * @see #getEscapedValue()
-	 * @generated
-	 */
-	void setEscapedValue(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Char Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The actual primitive character without the quotes. Escape are evaluated and turned into their character value. This is a transient field. If not set when created when queried it will create it. Typically it will be set when created from an AST node since the node already has evaluated it.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Char Value</em>' attribute.
-	 * @see #setCharValue(char)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTCharacterLiteral_CharValue()
-	 * @model transient="true"
-	 * @generated
-	 */
-	char getCharValue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTCharacterLiteral#getCharValue <em>Char Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Char Value</em>' attribute.
-	 * @see #getCharValue()
-	 * @generated
-	 */
-	void setCharValue(char value);
-
-} // CharacterLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTClassInstanceCreation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTClassInstanceCreation.java
deleted file mode 100644
index e3da3c7..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTClassInstanceCreation.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTClassInstanceCreation.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Class Instance Creation</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Class instance creation expression. E.g. new String("a")
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getArguments <em>Arguments</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTClassInstanceCreation()
- * @model
- * @generated
- */
-public interface PTClassInstanceCreation extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the type of the class. E.g. java.lang.String. This should be fully-qualified for allocation purposes. It should also be in reflection format, i.e. if X is an inner class of j.Y, then the type here should be "j.Y$X". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Type</em>' attribute.
-	 * @see #setType(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTClassInstanceCreation_Type()
-	 * @model
-	 * @generated
-	 */
-	String getType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTClassInstanceCreation#getType <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Type</em>' attribute.
-	 * @see #getType()
-	 * @generated
-	 */
-	void setType(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Arguments</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.instantiation.PTExpression}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The arguments to the constructor.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Arguments</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTClassInstanceCreation_Arguments()
-	 * @model type="org.eclipse.jem.internal.instantiation.PTExpression" containment="true"
-	 * @generated
-	 */
-	EList getArguments();
-
-} // ClassInstanceCreation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTConditionalExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTConditionalExpression.java
deleted file mode 100644
index eab0517..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTConditionalExpression.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTConditionalExpression.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Conditional Expression</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * The test Expresson, e.g. (x=3) ? 1 : 2
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getCondition <em>Condition</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getTrue <em>True</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getFalse <em>False</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTConditionalExpression()
- * @model
- * @generated
- */
-public interface PTConditionalExpression extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Condition</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The condition expression.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Condition</em>' containment reference.
-	 * @see #setCondition(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTConditionalExpression_Condition()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getCondition();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getCondition <em>Condition</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Condition</em>' containment reference.
-	 * @see #getCondition()
-	 * @generated
-	 */
-	void setCondition(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>True</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The true expression
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>True</em>' containment reference.
-	 * @see #setTrue(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTConditionalExpression_True()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getTrue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getTrue <em>True</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>True</em>' containment reference.
-	 * @see #getTrue()
-	 * @generated
-	 */
-	void setTrue(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>False</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The false expression.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>False</em>' containment reference.
-	 * @see #setFalse(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTConditionalExpression_False()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getFalse();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTConditionalExpression#getFalse <em>False</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>False</em>' containment reference.
-	 * @see #getFalse()
-	 * @generated
-	 */
-	void setFalse(PTExpression value);
-
-} // ConditionalExpression
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTExpression.java
deleted file mode 100644
index 9b716ef..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTExpression.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTExpression.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Expression</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTExpression()
- * @model abstract="true"
- * @generated
- */
-public interface PTExpression extends EObject{
-	/**
-	 * Accepts the given visitor on a visit of the current node.
-	 * 
-	 * @param visitor the visitor object
-	 * @exception IllegalArgumentException if the visitor is null
-	 */
-	public void accept(ParseVisitor visitor);
-} // Expression
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTFieldAccess.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTFieldAccess.java
deleted file mode 100644
index f8f76c0..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTFieldAccess.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTFieldAccess.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Field Access</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Access a field expression, e.g. java.awt.Color.red
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTFieldAccess#getReceiver <em>Receiver</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTFieldAccess#getField <em>Field</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTFieldAccess()
- * @model
- * @generated
- */
-public interface PTFieldAccess extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Receiver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The expression representing the object that the field is in, e.g. java.awt.Color.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Receiver</em>' containment reference.
-	 * @see #setReceiver(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTFieldAccess_Receiver()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getReceiver();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTFieldAccess#getReceiver <em>Receiver</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Receiver</em>' containment reference.
-	 * @see #getReceiver()
-	 * @generated
-	 */
-	void setReceiver(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>Field</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The name of the field being accessed, e.g. red.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Field</em>' attribute.
-	 * @see #setField(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTFieldAccess_Field()
-	 * @model
-	 * @generated
-	 */
-	String getField();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTFieldAccess#getField <em>Field</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Field</em>' attribute.
-	 * @see #getField()
-	 * @generated
-	 */
-	void setField(String value);
-
-} // FieldAccess
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInfixExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInfixExpression.java
deleted file mode 100644
index 6a81b66..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInfixExpression.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTInfixExpression.java,v $
- *  $Revision: 1.5 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Infix Expression</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * An expression with an operator that has two operands, e.g. 3 + 4.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getLeftOperand <em>Left Operand</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getOperator <em>Operator</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getRightOperand <em>Right Operand</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getExtendedOperands <em>Extended Operands</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInfixExpression()
- * @model
- * @generated
- */
-public interface PTInfixExpression extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Left Operand</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Left Operand</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Left Operand</em>' containment reference.
-	 * @see #setLeftOperand(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInfixExpression_LeftOperand()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getLeftOperand();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getLeftOperand <em>Left Operand</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Left Operand</em>' containment reference.
-	 * @see #getLeftOperand()
-	 * @generated
-	 */
-	void setLeftOperand(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>Operator</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.jem.internal.instantiation.PTInfixOperator}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The operator, e.g. +
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Operator</em>' attribute.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixOperator
-	 * @see #setOperator(PTInfixOperator)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInfixExpression_Operator()
-	 * @model
-	 * @generated
-	 */
-	PTInfixOperator getOperator();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getOperator <em>Operator</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Operator</em>' attribute.
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixOperator
-	 * @see #getOperator()
-	 * @generated
-	 */
-	void setOperator(PTInfixOperator value);
-
-	/**
-	 * Returns the value of the '<em><b>Right Operand</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The right expression. i.e. 4 of "3 + 4"
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Right Operand</em>' containment reference.
-	 * @see #setRightOperand(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInfixExpression_RightOperand()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getRightOperand();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInfixExpression#getRightOperand <em>Right Operand</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Right Operand</em>' containment reference.
-	 * @see #getRightOperand()
-	 * @generated
-	 */
-	void setRightOperand(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>Extended Operands</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.instantiation.PTExpression}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Used when there are a series of infix operations of the same operator, e.g. 1 + 2 + 3 + 4. 1 and 2 will go into left and right, while {3, 4} will go into the extended operands. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Extended Operands</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInfixExpression_ExtendedOperands()
-	 * @model type="org.eclipse.jem.internal.instantiation.PTExpression" containment="true"
-	 * @generated
-	 */
-	EList getExtendedOperands();
-
-	/**
-	 * Compress the expression
-	 * If there is no left operand and a right operand, or vice versa, and no extended operands
-	 * return the remaining single operand
-	 * If there is no left operand and a right and some extended ones shuffle everything along
-	 * so that the right becomes the left and the first extended moves into the right
-	 * or if no right and a left then just move the first extended into the right
-	 * 
-	 * @since 1.0.0
-	 */
-	PTExpression asCompressedExpression();
-
-} // InfixExpression
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInfixOperator.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInfixOperator.java
deleted file mode 100644
index 58af728..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInfixOperator.java
+++ /dev/null
@@ -1,619 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTInfixOperator.java,v $
- *  $Revision: 1.5 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.emf.common.util.AbstractEnumerator;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Infix Operator</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * Enumerator for the operator on an InfixExpression.
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInfixOperator()
- * @model
- * @generated
- */
-public final class PTInfixOperator extends AbstractEnumerator {
-	/**
-	 * The '<em><b>TIMES</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * * operator
-	 * <!-- end-model-doc -->
-	 * @see #TIMES_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int TIMES = 0;
-
-	/**
-	 * The '<em><b>DIVIDE</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * / operator
-	 * <!-- end-model-doc -->
-	 * @see #DIVIDE_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int DIVIDE = 1;
-
-	/**
-	 * The '<em><b>REMAINDER</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * % operator
-	 * <!-- end-model-doc -->
-	 * @see #REMAINDER_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int REMAINDER = 2;
-
-	/**
-	 * The '<em><b>PLUS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * + operator
-	 * <!-- end-model-doc -->
-	 * @see #PLUS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int PLUS = 3;
-
-	/**
-	 * The '<em><b>MINUS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * - operator
-	 * <!-- end-model-doc -->
-	 * @see #MINUS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int MINUS = 4;
-
-	/**
-	 * The '<em><b>LEFT SHIFT</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * << operator
-	 * <!-- end-model-doc -->
-	 * @see #LEFT_SHIFT_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int LEFT_SHIFT = 5;
-
-	/**
-	 * The '<em><b>RIGHT SHIFT SIGNED</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * >> operator
-	 * <!-- end-model-doc -->
-	 * @see #RIGHT_SHIFT_SIGNED_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int RIGHT_SHIFT_SIGNED = 6;
-
-	/**
-	 * The '<em><b>RIGHT SHIFT UNSIGNED</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * >>> operator
-	 * <!-- end-model-doc -->
-	 * @see #RIGHT_SHIFT_UNSIGNED_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int RIGHT_SHIFT_UNSIGNED = 7;
-
-	/**
-	 * The '<em><b>LESS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * <  operator
-	 * <!-- end-model-doc -->
-	 * @see #LESS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int LESS = 8;
-
-	/**
-	 * The '<em><b>GREATER</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * > operator
-	 * <!-- end-model-doc -->
-	 * @see #GREATER_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int GREATER = 9;
-
-	/**
-	 * The '<em><b>LESS EQUALS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * <= operator
-	 * <!-- end-model-doc -->
-	 * @see #LESS_EQUALS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int LESS_EQUALS = 10;
-
-	/**
-	 * The '<em><b>GREATER EQUALS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * >= operator
-	 * <!-- end-model-doc -->
-	 * @see #GREATER_EQUALS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int GREATER_EQUALS = 11;
-
-	/**
-	 * The '<em><b>EQUALS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * == operator
-	 * <!-- end-model-doc -->
-	 * @see #EQUALS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int EQUALS = 12;
-
-	/**
-	 * The '<em><b>NOT EQUALS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * != operator
-	 * <!-- end-model-doc -->
-	 * @see #NOT_EQUALS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int NOT_EQUALS = 13;
-
-	/**
-	 * The '<em><b>XOR</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * ^ operator
-	 * <!-- end-model-doc -->
-	 * @see #XOR_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int XOR = 14;
-
-	/**
-	 * The '<em><b>AND</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * & operator
-	 * <!-- end-model-doc -->
-	 * @see #AND_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int AND = 15;
-
-	/**
-	 * The '<em><b>OR</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * |  operator
-	 * <!-- end-model-doc -->
-	 * @see #OR_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int OR = 16;
-
-	/**
-	 * The '<em><b>CONDITIONAL AND</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * && operator
-	 * <!-- end-model-doc -->
-	 * @see #CONDITIONAL_AND_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int CONDITIONAL_AND = 17;
-
-	/**
-	 * The '<em><b>CONDITIONAL OR</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * || operator
-	 * <!-- end-model-doc -->
-	 * @see #CONDITIONAL_OR_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int CONDITIONAL_OR = 18;
-
-	/**
-	 * The '<em><b>TIMES</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #TIMES
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator TIMES_LITERAL = new PTInfixOperator(TIMES, "TIMES");
-
-	/**
-	 * The '<em><b>DIVIDE</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #DIVIDE
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator DIVIDE_LITERAL = new PTInfixOperator(DIVIDE, "DIVIDE");
-
-	/**
-	 * The '<em><b>REMAINDER</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #REMAINDER
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator REMAINDER_LITERAL = new PTInfixOperator(REMAINDER, "REMAINDER");
-
-	/**
-	 * The '<em><b>PLUS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #PLUS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator PLUS_LITERAL = new PTInfixOperator(PLUS, "PLUS");
-
-	/**
-	 * The '<em><b>MINUS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #MINUS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator MINUS_LITERAL = new PTInfixOperator(MINUS, "MINUS");
-
-	/**
-	 * The '<em><b>LEFT SHIFT</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #LEFT_SHIFT
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator LEFT_SHIFT_LITERAL = new PTInfixOperator(LEFT_SHIFT, "LEFT_SHIFT");
-
-	/**
-	 * The '<em><b>RIGHT SHIFT SIGNED</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #RIGHT_SHIFT_SIGNED
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator RIGHT_SHIFT_SIGNED_LITERAL = new PTInfixOperator(RIGHT_SHIFT_SIGNED, "RIGHT_SHIFT_SIGNED");
-
-	/**
-	 * The '<em><b>RIGHT SHIFT UNSIGNED</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #RIGHT_SHIFT_UNSIGNED
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator RIGHT_SHIFT_UNSIGNED_LITERAL = new PTInfixOperator(RIGHT_SHIFT_UNSIGNED, "RIGHT_SHIFT_UNSIGNED");
-
-	/**
-	 * The '<em><b>LESS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #LESS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator LESS_LITERAL = new PTInfixOperator(LESS, "LESS");
-
-	/**
-	 * The '<em><b>GREATER</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #GREATER
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator GREATER_LITERAL = new PTInfixOperator(GREATER, "GREATER");
-
-	/**
-	 * The '<em><b>LESS EQUALS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #LESS_EQUALS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator LESS_EQUALS_LITERAL = new PTInfixOperator(LESS_EQUALS, "LESS_EQUALS");
-
-	/**
-	 * The '<em><b>GREATER EQUALS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #GREATER_EQUALS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator GREATER_EQUALS_LITERAL = new PTInfixOperator(GREATER_EQUALS, "GREATER_EQUALS");
-
-	/**
-	 * The '<em><b>EQUALS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #EQUALS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator EQUALS_LITERAL = new PTInfixOperator(EQUALS, "EQUALS");
-
-	/**
-	 * The '<em><b>NOT EQUALS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #NOT_EQUALS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator NOT_EQUALS_LITERAL = new PTInfixOperator(NOT_EQUALS, "NOT_EQUALS");
-
-	/**
-	 * The '<em><b>XOR</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #XOR
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator XOR_LITERAL = new PTInfixOperator(XOR, "XOR");
-
-	/**
-	 * The '<em><b>AND</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #AND
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator AND_LITERAL = new PTInfixOperator(AND, "AND");
-
-	/**
-	 * The '<em><b>OR</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #OR
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator OR_LITERAL = new PTInfixOperator(OR, "OR");
-
-	/**
-	 * The '<em><b>CONDITIONAL AND</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #CONDITIONAL_AND
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator CONDITIONAL_AND_LITERAL = new PTInfixOperator(CONDITIONAL_AND, "CONDITIONAL_AND");
-
-	/**
-	 * The '<em><b>CONDITIONAL OR</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #CONDITIONAL_OR
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTInfixOperator CONDITIONAL_OR_LITERAL = new PTInfixOperator(CONDITIONAL_OR, "CONDITIONAL_OR");
-
-	/**
-	 * An array of all the '<em><b>PT Infix Operator</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static final PTInfixOperator[] VALUES_ARRAY =
-		new PTInfixOperator[] {
-			TIMES_LITERAL,
-			DIVIDE_LITERAL,
-			REMAINDER_LITERAL,
-			PLUS_LITERAL,
-			MINUS_LITERAL,
-			LEFT_SHIFT_LITERAL,
-			RIGHT_SHIFT_SIGNED_LITERAL,
-			RIGHT_SHIFT_UNSIGNED_LITERAL,
-			LESS_LITERAL,
-			GREATER_LITERAL,
-			LESS_EQUALS_LITERAL,
-			GREATER_EQUALS_LITERAL,
-			EQUALS_LITERAL,
-			NOT_EQUALS_LITERAL,
-			XOR_LITERAL,
-			AND_LITERAL,
-			OR_LITERAL,
-			CONDITIONAL_AND_LITERAL,
-			CONDITIONAL_OR_LITERAL,
-		};
-	
-	private static final String[] OPERATOR_STRING;
-	static {
-		OPERATOR_STRING = new String[VALUES_ARRAY.length];
-		OPERATOR_STRING[TIMES] = "*";
-		OPERATOR_STRING[DIVIDE] = "/";
-		OPERATOR_STRING[REMAINDER] = "%";
-		OPERATOR_STRING[PLUS] = "+";
-		OPERATOR_STRING[MINUS] = "-";
-		OPERATOR_STRING[LEFT_SHIFT] = "<";
-		OPERATOR_STRING[RIGHT_SHIFT_SIGNED] = ">>";
-		OPERATOR_STRING[RIGHT_SHIFT_UNSIGNED] = ">>>";
-		OPERATOR_STRING[LESS] = "<";
-		OPERATOR_STRING[GREATER] = ">";
-		OPERATOR_STRING[LESS_EQUALS] = "<=";
-		OPERATOR_STRING[GREATER_EQUALS] = ">=";
-		OPERATOR_STRING[EQUALS] = "==";
-		OPERATOR_STRING[NOT_EQUALS] = "!=";
-		OPERATOR_STRING[XOR] = "^";
-		OPERATOR_STRING[AND] = "&";
-		OPERATOR_STRING[OR] = "|";
-		OPERATOR_STRING[CONDITIONAL_AND] = "&&";
-		OPERATOR_STRING[CONDITIONAL_OR] = "||";
-	}
-
-	/**
-	 * A public read-only list of all the '<em><b>PT Infix Operator</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
-
-	/**
-	 * Returns the '<em><b>PT Infix Operator</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static PTInfixOperator get(String name) {
-		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
-			PTInfixOperator result = VALUES_ARRAY[i];
-			if (result.toString().equals(name)) {
-				return result;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the '<em><b>PT Infix Operator</b></em>' literal with the specified value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static PTInfixOperator get(int value) {
-		switch (value) {
-			case TIMES: return TIMES_LITERAL;
-			case DIVIDE: return DIVIDE_LITERAL;
-			case REMAINDER: return REMAINDER_LITERAL;
-			case PLUS: return PLUS_LITERAL;
-			case MINUS: return MINUS_LITERAL;
-			case LEFT_SHIFT: return LEFT_SHIFT_LITERAL;
-			case RIGHT_SHIFT_SIGNED: return RIGHT_SHIFT_SIGNED_LITERAL;
-			case RIGHT_SHIFT_UNSIGNED: return RIGHT_SHIFT_UNSIGNED_LITERAL;
-			case LESS: return LESS_LITERAL;
-			case GREATER: return GREATER_LITERAL;
-			case LESS_EQUALS: return LESS_EQUALS_LITERAL;
-			case GREATER_EQUALS: return GREATER_EQUALS_LITERAL;
-			case EQUALS: return EQUALS_LITERAL;
-			case NOT_EQUALS: return NOT_EQUALS_LITERAL;
-			case XOR: return XOR_LITERAL;
-			case AND: return AND_LITERAL;
-			case OR: return OR_LITERAL;
-			case CONDITIONAL_AND: return CONDITIONAL_AND_LITERAL;
-			case CONDITIONAL_OR: return CONDITIONAL_OR_LITERAL;
-		}
-		return null;	
-	}
-
-	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private PTInfixOperator(int value, String name) {
-		super(value, name);
-	}
-
-	/**
-	 * Return the operator string (i.e. for PLUS return "+").
-	 * @return The operator string.
-	 * 
-	 * @since 1.0.0
-	 */
-	public String getOperator() {
-		return OPERATOR_STRING[getValue()];
-	}
-
-} //InfixOperator
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInstanceReference.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInstanceReference.java
deleted file mode 100644
index 03ce93c..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInstanceReference.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTInstanceReference.java,v $
- *  $Revision: 1.6 $  $Date: 2005/10/03 19:20:41 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-import org.eclipse.jem.internal.instantiation.base.IJavaInstance;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>PT Instance Reference</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInstanceReference#getReference <em>Reference</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInstanceReference()
- * @model
- * @generated
- */
-public interface PTInstanceReference extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Reference</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Reference</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Reference</em>' reference.
-	 * @see #setReference(IJavaInstance)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInstanceReference_Reference()
-	 * @model required="true"
-	 * @generated
-	 */
-	IJavaInstance getReference();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInstanceReference#getReference <em>Reference</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Reference</em>' reference.
-	 * @see #getReference()
-	 * @generated
-	 */
-	void setReference(IJavaInstance value);
-
-} // PTInstanceReference
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInstanceof.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInstanceof.java
deleted file mode 100644
index 79ccdf7..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInstanceof.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTInstanceof.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Instanceof</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Instanceof expression, e.g. x instanceof java.lang.String
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInstanceof#getOperand <em>Operand</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInstanceof#getType <em>Type</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInstanceof()
- * @model
- * @generated
- */
-public interface PTInstanceof extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Operand</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The value to test, e.g. x in x instanceof java.lang.String
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Operand</em>' containment reference.
-	 * @see #setOperand(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInstanceof_Operand()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getOperand();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInstanceof#getOperand <em>Operand</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Operand</em>' containment reference.
-	 * @see #getOperand()
-	 * @generated
-	 */
-	void setOperand(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The type of the instance test, e.g. java.lang.String. It must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Type</em>' attribute.
-	 * @see #setType(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInstanceof_Type()
-	 * @model
-	 * @generated
-	 */
-	String getType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInstanceof#getType <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Type</em>' attribute.
-	 * @see #getType()
-	 * @generated
-	 */
-	void setType(String value);
-
-} // Instanceof
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInvalidExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInvalidExpression.java
deleted file mode 100644
index 916ea41..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTInvalidExpression.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTInvalidExpression.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Invalid Expression</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This is used when we have some expression we just can't evaluate for our purposes. It allows us to tell the evaluation what is actually wrong. It should be placed as the root expression to prevent processing much of the tree and then finally fail.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTInvalidExpression#getMessage <em>Message</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInvalidExpression()
- * @model
- * @generated
- */
-public interface PTInvalidExpression extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Message</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * A message as to why it is invalid.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Message</em>' attribute.
-	 * @see #setMessage(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTInvalidExpression_Message()
-	 * @model
-	 * @generated
-	 */
-	String getMessage();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTInvalidExpression#getMessage <em>Message</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Message</em>' attribute.
-	 * @see #getMessage()
-	 * @generated
-	 */
-	void setMessage(String value);
-
-} // InvalidExpression
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTMethodInvocation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTMethodInvocation.java
deleted file mode 100644
index b4a534f..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTMethodInvocation.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTMethodInvocation.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Method Invocation</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * MethodInvocation expression, e.g. x.getY(3)
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getReceiver <em>Receiver</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getArguments <em>Arguments</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTMethodInvocation()
- * @model
- * @generated
- */
-public interface PTMethodInvocation extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Receiver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Who the method is invoked against. This may be not set, which means "this". It may also be a Name, which would mean a class like "java.lang.String"
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Receiver</em>' containment reference.
-	 * @see #setReceiver(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTMethodInvocation_Receiver()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getReceiver();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getReceiver <em>Receiver</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Receiver</em>' containment reference.
-	 * @see #getReceiver()
-	 * @generated
-	 */
-	void setReceiver(PTExpression value);
-
-	/**
-	 * Returns the value of the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The name of the method being invoked.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Name</em>' attribute.
-	 * @see #setName(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTMethodInvocation_Name()
-	 * @model
-	 * @generated
-	 */
-	String getName();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTMethodInvocation#getName <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Name</em>' attribute.
-	 * @see #getName()
-	 * @generated
-	 */
-	void setName(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Arguments</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jem.internal.instantiation.PTExpression}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The list of arguments, if any, to the method.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Arguments</em>' containment reference list.
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTMethodInvocation_Arguments()
-	 * @model type="org.eclipse.jem.internal.instantiation.PTExpression" containment="true"
-	 * @generated
-	 */
-	EList getArguments();
-
-} // MethodInvocation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTName.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTName.java
deleted file mode 100644
index dcde00d..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTName.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTName.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Name</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This represents a name. This can happen for the receiver of a method invocation, e.g. x.getY() or java.lang.String.valueOf(10). In these cases you would have a name of "x" or "java.lang.String".
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTName#getName <em>Name</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTName()
- * @model
- * @generated
- */
-public interface PTName extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The name, which can be a type or a variable. If it is a type, then  it must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Name</em>' attribute.
-	 * @see #setName(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTName_Name()
-	 * @model
-	 * @generated
-	 */
-	String getName();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTName#getName <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Name</em>' attribute.
-	 * @see #getName()
-	 * @generated
-	 */
-	void setName(String value);
-
-} // Name
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTNullLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTNullLiteral.java
deleted file mode 100644
index 45fa4ce..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTNullLiteral.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTNullLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Null Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Represents the expression "null"
- * <!-- end-model-doc -->
- *
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTNullLiteral()
- * @model
- * @generated
- */
-public interface PTNullLiteral extends PTExpression{
-} // NullLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTNumberLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTNumberLiteral.java
deleted file mode 100644
index 8a074c6..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTNumberLiteral.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTNumberLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Number Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Represent a number primitive literal, e.g. 10. One optimization that will be performed is that if an expression is of the form +number or -number, it will be converted from a PrefixExpression with a NumberLiteral to just a NumberLiteral. This will simplify the model.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTNumberLiteral#getToken <em>Token</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTNumberLiteral()
- * @model
- * @generated
- */
-public interface PTNumberLiteral extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Token</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The token value, e.g. 10, 10d, or -10.75
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Token</em>' attribute.
-	 * @see #setToken(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTNumberLiteral_Token()
-	 * @model
-	 * @generated
-	 */
-	String getToken();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTNumberLiteral#getToken <em>Token</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Token</em>' attribute.
-	 * @see #getToken()
-	 * @generated
-	 */
-	void setToken(String value);
-
-} // NumberLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTParenthesizedExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTParenthesizedExpression.java
deleted file mode 100644
index 66dc024..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTParenthesizedExpression.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTParenthesizedExpression.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Parenthesized Expression</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * An expression within parenthesis, e.g. (x+3)
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTParenthesizedExpression#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTParenthesizedExpression()
- * @model
- * @generated
- */
-public interface PTParenthesizedExpression extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The expression wrapped by the parenthesis, e.g. (x+3) then the expression is "x+3"
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Expression</em>' containment reference.
-	 * @see #setExpression(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTParenthesizedExpression_Expression()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getExpression();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTParenthesizedExpression#getExpression <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Expression</em>' containment reference.
-	 * @see #getExpression()
-	 * @generated
-	 */
-	void setExpression(PTExpression value);
-
-} // ParenthesizedExpression
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTPrefixExpression.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTPrefixExpression.java
deleted file mode 100644
index 4e5d563..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTPrefixExpression.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTPrefixExpression.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Prefix Expression</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * A one operand operator, where the operator comes before the operand, e.g. - (x+3). In AST, even -3 is modeled as a PrefixExpression of operator "-" and expression of NumberLiteral(3). But we optimize this away and just use a NumberLiteral(-3) directly instead.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression#getOperator <em>Operator</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTPrefixExpression()
- * @model
- * @generated
- */
-public interface PTPrefixExpression extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Operator</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.jem.internal.instantiation.PTPrefixOperator}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The operator of this expression.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Operator</em>' attribute.
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixOperator
-	 * @see #setOperator(PTPrefixOperator)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTPrefixExpression_Operator()
-	 * @model
-	 * @generated
-	 */
-	PTPrefixOperator getOperator();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression#getOperator <em>Operator</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Operator</em>' attribute.
-	 * @see org.eclipse.jem.internal.instantiation.PTPrefixOperator
-	 * @see #getOperator()
-	 * @generated
-	 */
-	void setOperator(PTPrefixOperator value);
-
-	/**
-	 * Returns the value of the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The expression that the operator is applied to.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Expression</em>' containment reference.
-	 * @see #setExpression(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTPrefixExpression_Expression()
-	 * @model containment="true"
-	 * @generated
-	 */
-	PTExpression getExpression();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTPrefixExpression#getExpression <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Expression</em>' containment reference.
-	 * @see #getExpression()
-	 * @generated
-	 */
-	void setExpression(PTExpression value);
-
-} // PrefixExpression
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTPrefixOperator.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTPrefixOperator.java
deleted file mode 100644
index 49a6a25..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTPrefixOperator.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation;
-/*
- *  $RCSfile: PTPrefixOperator.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.emf.common.util.AbstractEnumerator;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Prefix Operator</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * The prefix expression operator. We are not modeling ++ and --.
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTPrefixOperator()
- * @model
- * @generated
- */
-public final class PTPrefixOperator extends AbstractEnumerator {
-	/**
-	 * The '<em><b>PLUS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * + operator
-	 * <!-- end-model-doc -->
-	 * @see #PLUS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int PLUS = 0;
-
-	/**
-	 * The '<em><b>MINUS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * - operator
-	 * <!-- end-model-doc -->
-	 * @see #MINUS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int MINUS = 1;
-
-	/**
-	 * The '<em><b>COMPLEMENT</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * ~ operator
-	 * <!-- end-model-doc -->
-	 * @see #COMPLEMENT_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int COMPLEMENT = 2;
-
-	/**
-	 * The '<em><b>NOT</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * ! operator
-	 * <!-- end-model-doc -->
-	 * @see #NOT_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int NOT = 3;
-
-	/**
-	 * The '<em><b>PLUS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #PLUS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTPrefixOperator PLUS_LITERAL = new PTPrefixOperator(PLUS, "PLUS");
-
-	/**
-	 * The '<em><b>MINUS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #MINUS
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTPrefixOperator MINUS_LITERAL = new PTPrefixOperator(MINUS, "MINUS");
-
-	/**
-	 * The '<em><b>COMPLEMENT</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #COMPLEMENT
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTPrefixOperator COMPLEMENT_LITERAL = new PTPrefixOperator(COMPLEMENT, "COMPLEMENT");
-
-	/**
-	 * The '<em><b>NOT</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #NOT
-	 * @generated
-	 * @ordered
-	 */
-	public static final PTPrefixOperator NOT_LITERAL = new PTPrefixOperator(NOT, "NOT");
-
-	/**
-	 * An array of all the '<em><b>PT Prefix Operator</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static final PTPrefixOperator[] VALUES_ARRAY =
-		new PTPrefixOperator[] {
-			PLUS_LITERAL,
-			MINUS_LITERAL,
-			COMPLEMENT_LITERAL,
-			NOT_LITERAL,
-		};
-	
-	private static final String[] OPERATOR_STRING;
-	static {
-		OPERATOR_STRING = new String[VALUES_ARRAY.length];
-		OPERATOR_STRING[PLUS] = "+";
-		OPERATOR_STRING[MINUS] = "-";
-		OPERATOR_STRING[COMPLEMENT] = "~";
-		OPERATOR_STRING[NOT] = "!";
-	}
-
-	/**
-	 * A public read-only list of all the '<em><b>PT Prefix Operator</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
-
-	/**
-	 * Returns the '<em><b>PT Prefix Operator</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static PTPrefixOperator get(String name) {
-		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
-			PTPrefixOperator result = VALUES_ARRAY[i];
-			if (result.toString().equals(name)) {
-				return result;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the '<em><b>PT Prefix Operator</b></em>' literal with the specified value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static PTPrefixOperator get(int value) {
-		switch (value) {
-			case PLUS: return PLUS_LITERAL;
-			case MINUS: return MINUS_LITERAL;
-			case COMPLEMENT: return COMPLEMENT_LITERAL;
-			case NOT: return NOT_LITERAL;
-		}
-		return null;	
-	}
-
-	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private PTPrefixOperator(int value, String name) {
-		super(value, name);
-	}
-
-	/**
-	 * Return the operator string (i.e. for PLUS return "+").
-	 * @return The operator string.
-	 * 
-	 * @since 1.0.0
-	 */
-	public String getOperator() {
-		return OPERATOR_STRING[getValue()];
-	}
-} //PrefixOperator
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTStringLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTStringLiteral.java
deleted file mode 100644
index f0d103d..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTStringLiteral.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTStringLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>String Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Representation of a string literal, e.g. "asdf".
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTStringLiteral#getEscapedValue <em>Escaped Value</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTStringLiteral#getLiteralValue <em>Literal Value</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTStringLiteral()
- * @model
- * @generated
- */
-public interface PTStringLiteral extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Escaped Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * This is the escaped string. In other words the literal exactly as it is in the java file. E.g. "ab" or "c\r". Including the surrounding quotes themselves.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Escaped Value</em>' attribute.
-	 * @see #setEscapedValue(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTStringLiteral_EscapedValue()
-	 * @model
-	 * @generated
-	 */
-	String getEscapedValue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTStringLiteral#getEscapedValue <em>Escaped Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Escaped Value</em>' attribute.
-	 * @see #getEscapedValue()
-	 * @generated
-	 */
-	void setEscapedValue(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Literal Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The actual string without the quotes. Escape are evaluated and turned into their character value. This is a transient field. If not set when created when queried it will create it. Typically it will be set when created from an AST node since the node already has evaluated it.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Literal Value</em>' attribute.
-	 * @see #setLiteralValue(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTStringLiteral_LiteralValue()
-	 * @model transient="true"
-	 * @generated
-	 */
-	String getLiteralValue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTStringLiteral#getLiteralValue <em>Literal Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Literal Value</em>' attribute.
-	 * @see #getLiteralValue()
-	 * @generated
-	 */
-	void setLiteralValue(String value);
-
-} // StringLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTThisLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTThisLiteral.java
deleted file mode 100644
index 8d1c2d9..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTThisLiteral.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTThisLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>This Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Represents "this", e.g. this.getX() will be a MethodInvocation with the receiver being a ThisLiteral. We can't handle the format XYZ.this because that is for inner classes and we don't support that right now.
- * <!-- end-model-doc -->
- *
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTThisLiteral()
- * @model
- * @generated
- */
-public interface PTThisLiteral extends PTExpression{
-} // ThisLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTTypeLiteral.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTTypeLiteral.java
deleted file mode 100644
index 790c4c8..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/PTTypeLiteral.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: PTTypeLiteral.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Type Literal</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * This represents a literal of the form j.XYZ.class. For instance in a method invocation x.getX(jXYZ.class) the argument will be a TypeLiteral.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.PTTypeLiteral#getType <em>Type</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTTypeLiteral()
- * @model
- * @generated
- */
-public interface PTTypeLiteral extends PTExpression{
-	/**
-	 * Returns the value of the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * The type of the literal.  It must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Type</em>' attribute.
-	 * @see #setType(String)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getPTTypeLiteral_Type()
-	 * @model
-	 * @generated
-	 */
-	String getType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.PTTypeLiteral#getType <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Type</em>' attribute.
-	 * @see #getType()
-	 * @generated
-	 */
-	void setType(String value);
-
-} // TypeLiteral
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ParseTreeAllocation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ParseTreeAllocation.java
deleted file mode 100644
index 5fafe79..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ParseTreeAllocation.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ParseTreeAllocation.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/15 21:02:19 $ 
- */
-package org.eclipse.jem.internal.instantiation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Parse Tree Allocation</b></em>'.
- * <!-- end-user-doc -->
- *
- * <!-- begin-model-doc -->
- * Allocations via Parse Trees.
- * <!-- end-model-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.ParseTreeAllocation#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getParseTreeAllocation()
- * @model
- * @generated
- */
-public interface ParseTreeAllocation extends JavaAllocation{
-	/**
-	 * Returns the value of the '<em><b>Expression</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Expression</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Expression</em>' containment reference.
-	 * @see #setExpression(PTExpression)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#getParseTreeAllocation_Expression()
-	 * @model containment="true" required="true"
-	 * @generated
-	 */
-	PTExpression getExpression();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.internal.instantiation.ParseTreeAllocation#getExpression <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Expression</em>' containment reference.
-	 * @see #getExpression()
-	 * @generated
-	 */
-	void setExpression(PTExpression value);
-
-} // ParseTreeAllocation
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ParseVisitor.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ParseVisitor.java
deleted file mode 100644
index 0cc6f85..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/ParseVisitor.java
+++ /dev/null
@@ -1,294 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ParseVisitor.java,v $
- *  $Revision: 1.7 $  $Date: 2005/10/28 22:56:46 $ 
- */
-package org.eclipse.jem.internal.instantiation;
- 
-/**
- * A visitor for abstract parse expression trees.
- * <p>
- * For each different concrete Expression node type <it>T</it> there are
- * a pair of methods:
- * <ul>
- * <li><code>public boolean visit(<it>T</it> node)</code> - Visits
- * the given node to perform some arbitrary operation. If <code>true</code>
- * is returned, the given node's child nodes will be visited next; however,
- * if <code>false</code> is returned, the given node's child nodes will 
- * not be visited. The default implementation provided by this class does
- * nothing and returns <code>true</code>. Subclasses may reimplement
- * this method as needed.</li>
- * <li><code>public void endVisit(<it>T</it> node)</code> - Visits
- * the given node to perform some arbitrary operation. When used in the
- * conventional way, this method is called after all of the given node's
- * children have been visited (or immediately, if <code>visit</code> returned
- * <code>false</code>). The default implementation provided by this class does
- * nothing. Subclasses may reimplement this method as needed.</li>
- * </ul>
- * </p>
- * In addition, there are a pair of methods for visiting AST nodes in the 
- * abstract, regardless of node type:
- * <ul>
- * <li><code>public void preVisit(ASTNode node)</code> - Visits
- * the given node to perform some arbitrary operation. 
- * This method is invoked prior to the appropriate type-specific
- * <code>visit</code> method.
- * The default implementation of this method does nothing.
- * Subclasses may reimplement this method as needed.</li>
- * <li><code>public void postVisit(ASTNode node)</code> - Visits
- * the given node to perform some arbitrary operation. 
- * This method is invoked after the appropriate type-specific
- * <code>endVisit</code> method.
- * The default implementation of this method does nothing.
- * Subclasses may reimplement this method as needed.</li>
- * </ul>
- * <p>
- * For nodes with list-valued properties, the child nodes within the list
- * are visited in order. For nodes with multiple properties, the child nodes
- * are visited in the order that most closely corresponds to the lexical
- * reading order of the source program. For instance, for a type declaration
- * node, the child ordering is: name, superclass, superinterfaces, and 
- * body declarations.
- * </p>
- * <p>
- * While it is possible to modify the tree in the visitor, care is required to
- * ensure that the consequences are as expected and desirable.
- * During the course of an ordinary visit starting at a given node, every node
- * in the subtree is visited exactly twice, first with <code>visit</code> and
- * then with <code>endVisit</code>. During a traversal of a stationary tree, 
- * each node is either behind (after <code>endVisit</code>), ahead (before 
- * <code>visit</code>), or in progress (between <code>visit</code> and
- * the matching <code>endVisit</code>). Changes to the "behind" region of the
- * tree are of no consequence to the visit in progress. Changes to the "ahead"
- * region will be taken in stride. Changes to the "in progress" portion are
- * the more interesting cases. With a node, the various properties are arranged
- * in a linear list, with a cursor that separates the properties that have
- * been visited from the ones that are still to be visited (the cursor
- * is between the elements, rather than on an element). The cursor moves from
- * the head to the tail of this list, advancing to the next position just
- * <it>before</it> <code>visit</code> if called for that child. After the child
- * subtree has been completely visited, the visit moves on the child 
- * immediately after the cursor. Removing a child while it is being visited
- * does not alter the course of the visit. But any children added at positions
- * after the cursor are considered in the "ahead" portion and will be visited.
- * </p>
- * <p>
- * Cases to watch out for:
- * <ul>
- * <li>Moving a child node further down the list. This could result in the
- * child subtree being visited multiple times; these visits are sequential.</li>
- * <li>Moving a child node up into an ancestor. If the new home for
- * the node is in the "ahead" portion, the subtree will be visited 
- * a second time; again, these visits are sequential.</li>
- * <li>Moving a node down into a child. If the new home for
- * the node is in the "ahead" portion, the subtree will be visited 
- * a second time; in this case, the visits will be nested. In some cases,
- * this can lead to a stack overflow or out of memory condition.</li>
- * </ul>
- * </p>
- *
- * Note: This is based upon the visit concept in org.eclipse.jdt.core.dom.ASTVisitor. 
- *
- * @see Expression#accept
- *  
- * @since 1.0.0
- */
-public class ParseVisitor {
-	
-	/**
-	 * Exception to throw to just stop visiting a parse visit. It doesn't mean error, it
-	 * just means stop visiting. ParseVisitors should throw this when they want to stop
-	 * visiting further without an explicit error.
-	 * <p>
-	 * If they want to indicate an error, parse visitors can throw any other RuntimeException. 
-	 * Those will also stop visiting, but the exception will be passed on out of the 
-	 * {@link PTExpression#accept(ParseVisitor)}. StopVisiting will not be passed on
-	 * but will be caught inside accept.
-	 * 
-	 * @since 1.1.0.1
-	 */
-	public static class StopVisiting extends RuntimeException {
-
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0.1
-		 */
-		private static final long serialVersionUID = -5246860806568355520L;
-		
-	}
-	/**
-	 * Visits the given parse node prior to the type-specific visit. (before <code>visit</code>).
-	 * <p>
-	 * The default implementation does nothing. Subclasses may reimplement.
-	 * </p>
-	 * 
-	 * @param node
-	 *            the node to visit
-	 */
-	public void preVisit(PTExpression node) {
-		// default implementation: do nothing
-	}
-
-	/**
-	 * Visits the given parse node following the type-specific visit (after <code>endVisit</code>).
-	 * <p>
-	 * The default implementation does nothing. Subclasses may reimplement.
-	 * </p>
-	 * 
-	 * @param node
-	 *            the node to visit
-	 */
-	public void postVisit(PTExpression node) {
-		// default implementation: do nothing
-	}
-
-	public boolean visit(PTAnonymousClassDeclaration node) {
-		return true;
-	}
-	public boolean visit(PTArrayAccess node) {
-		return true;
-	}
-	public boolean visit(PTArrayCreation node) {
-		return true;
-	}
-	public boolean visit(PTArrayInitializer node) {
-		return true;
-	}
-	public boolean visit(PTBooleanLiteral node) {
-		return true;
-	}
-	public boolean visit(PTCastExpression node) {
-		return true;
-	}
-	public boolean visit(PTCharacterLiteral node) {
-		return true;
-	}
-	public boolean visit(PTClassInstanceCreation node) {
-		return true;
-	}
-	public boolean visit(PTConditionalExpression node) {
-		return true;
-	}
-	public boolean visit(PTFieldAccess node) {
-		return true;
-	}
-	public boolean visit(PTInfixExpression node) {
-		return true;
-	}
-	public boolean visit(PTInstanceof node) {
-		return true;
-	}
-	public boolean visit(PTInvalidExpression node) {
-		return true;
-	}
-	public boolean visit(PTMethodInvocation node) {
-		return true;
-	}
-	public boolean visit(PTName node) {
-		return true;
-	}
-	public boolean visit(PTNullLiteral node) {
-		return true;
-	}
-	public boolean visit(PTNumberLiteral node) {
-		return true;
-	}
-	public boolean visit(PTParenthesizedExpression node) {
-		return true;
-	}
-	public boolean visit(PTPrefixExpression node) {
-		return true;
-	}
-	public boolean visit(PTStringLiteral node) {
-		return true;
-	}
-	public boolean visit(PTThisLiteral node) {
-		return true;
-	}
-	public boolean visit(PTTypeLiteral node) {
-		return true;
-	}
-	public boolean visit(PTInstanceReference node) {
-		return true;
-	}
-	public void endVisit(PTAnonymousClassDeclaration node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTArrayAccess node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTArrayCreation node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTArrayInitializer node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTBooleanLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTCastExpression node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTCharacterLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTClassInstanceCreation node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTConditionalExpression node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTFieldAccess node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTInfixExpression node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTInstanceof node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTInvalidExpression node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTMethodInvocation node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTName node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTNullLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTNumberLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTParenthesizedExpression node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTPrefixExpression node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTStringLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTThisLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTTypeLiteral node) {
-		// default implementation: do nothing
-	}
-	public void endVisit(PTInstanceReference node) {
-		// default implementation: do nothing
-	}
-	
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/FeatureValueProvider.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/FeatureValueProvider.java
deleted file mode 100644
index 611c8bb..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/FeatureValueProvider.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: FeatureValueProvider.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-import java.util.Iterator;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Implementers of this interface (an EMF EObject subclass) provide a visiter
- * capability to the set features on the EObject. This way only the set features
- * are presented to the visitor. This can save a lot of time.
- * 
- * @since 1.1.0
- */
-public interface FeatureValueProvider {
-	
-	/**
-	 * A helper class for FeatureValueProvider.
-	 * 
-	 * @see FeatureValueProviderHelper#visitSetFeatures(EObject, Visitor)
-	 * 
-	 * @since 1.1.0
-	 */
-	public static class FeatureValueProviderHelper {
-		
-		/**
-		 * A helper to handle where the object may or may not be
-		 * implement FeatureValueProvider. This way it can be a
-		 * common access to do it.
-		 * 
-		 * @param eobject
-		 * @param visitor
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public static Object visitSetFeatures(EObject eobject, Visitor visitor) {
-			if (eobject instanceof FeatureValueProvider)
-				return ((FeatureValueProvider)eobject).visitSetFeatures(visitor);
-			else {
-				// Not a FeatureValueProvider, so do normal.
-				Iterator features = eobject.eClass().getEAllStructuralFeatures().iterator();
-				while(features.hasNext()){
-					EStructuralFeature sf = (EStructuralFeature)features.next();
-					if(eobject.eIsSet(sf)){
-						Object result = visitor.isSet(sf, eobject.eGet(sf));
-						if (result != null)
-							return result;
-					}
-				}
-				return null;
-			}
-		}
-		
-		/**
-		 * Answers whether any feature is set or not.
-		 * <p>
-		 * <b>Note:</b> This SHOULD NOT be used as a test before deciding whether to do visitSetFeatures or not. It is more efficient to just call
-		 * visitSetFeatures. It should be used only to see if any features are set.
-		 * 
-		 * @param eobject
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		public static boolean isAnyFeatureSet(EObject eobject) {
-			if (eobject instanceof FeatureValueProvider)
-				return ((FeatureValueProvider)eobject).isAnyFeatureSet();
-			else {
-				// Not a FeatureValueProvider, so do normal.
-				Iterator features = eobject.eClass().getEAllStructuralFeatures().iterator();
-				while(features.hasNext()){
-					EStructuralFeature sf = (EStructuralFeature)features.next();
-					if(eobject.eIsSet(sf)){
-						return true;
-					}
-				}
-				return false;
-			}			
-		}
-		
-		private FeatureValueProviderHelper() {
-		}
-	}
-	
-	/**
-	 * The interface for the visiter callback.
-	 * 
-	 * @since 1.1.0
-	 */
-	public interface Visitor{
-		/**
-		 * Called for each set feature on the FeatureValueProvider.
-		 * 
-		 * @param feature
-		 * @param value
-		 * @return <code>null</code> to continue to next setting, or a value to stop visiting and return that value be the real exception.
-		 * @since 1.1.0
-		 */
-		Object isSet(EStructuralFeature feature, Object value);
-	}	
-
-	/**
-	 * Visit the set features.
-	 * @param aVisitor
-	 * @param <code>null</code> if all settings visited, or the value returned from the visit (isSet) that returned a non-nullSe.
-	 * @since 1.1.0
-	 */
-	public Object visitSetFeatures(Visitor aVisitor);
-	
-	/**
-	 * Answers whether any feature is set or not.
-	 * <p>
-	 * <b>Note:</b> This SHOULD NOT be used as a test before deciding whether to do visitSetFeatures or not. It is
-	 * more efficient to just call visitSetFeatures. It should be used only to see if any features are set.
-	 * 
-	 * @return <code>true</code> if any features are set.
-	 * 
-	 * @since 1.1.0
-	 */
-	public boolean isAnyFeatureSet();
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaDataTypeInstance.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaDataTypeInstance.java
deleted file mode 100644
index b295463..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaDataTypeInstance.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: IJavaDataTypeInstance.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-/**
- * Interface for instances of java data types.
- */
-
-public interface IJavaDataTypeInstance extends IJavaInstance {
-
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaInstance.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaInstance.java
deleted file mode 100644
index 14ed414..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaInstance.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: IJavaInstance.java,v $
- *  $Revision: 1.7 $  $Date: 2005/10/03 19:20:42 $ 
- */
-
-import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.jem.internal.instantiation.JavaAllocation;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationInstance;
-/**
- * A common interface for Java instances. It will be
- * shared by Java Objects and Java DataType instances.
- */
-public interface IJavaInstance extends EObject, FeatureValueProvider, IInstantiationInstance {
-	
-	/**
-	 * Get the allocation object.
-	 * @return The allocation object.
-	 */
-	public JavaAllocation getAllocation();
-	
-	/**
-	 * Set the allocation for this object instance.
-	 * @param allocation
-	 */
-	public void setAllocation(JavaAllocation allocation);	
-	
-	/**
-	 * Return whether the allocation has been set or not.
-	 * @return <code>true</code> if set. 
-	 */
-	public boolean isSetAllocation();
-	
-	/**
-	 * Answer true if we are an instance of one of Java's primitive data types.
-	 * e.g. boolean, char - true otherwise, e.g. java.lang.Boolean
-	 */
-	public boolean isPrimitive();
-	
-	/**
-	 * Answer whether this has an implicit allocation.
-	 * @return <code>true</code> if implicit allocation. <code>false</code> if not set or not implicit.
-	 * 
-	 * @since 1.2.0
-	 */
-	public boolean isImplicitAllocation();
-	
-	/**
-	 * Answer whether this has an parsetree allocation.
-	 * @return <code>true</code> if parsetree allocation. <code>false</code> if not set or not parsetree.
-	 * 
-	 * @since 1.2.0
-	 */
-	public boolean isParseTreeAllocation();
-
-	
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaObjectInstance.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaObjectInstance.java
deleted file mode 100644
index b279b3c..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/IJavaObjectInstance.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: IJavaObjectInstance.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-
-/**
- * Interface for java object instances.
- */
-public interface IJavaObjectInstance extends IJavaInstance {
-	
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/InstantiationBaseMessages.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/InstantiationBaseMessages.java
deleted file mode 100644
index f452450..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/InstantiationBaseMessages.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class InstantiationBaseMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.instantiation.base.messages";//$NON-NLS-1$
-
-	private InstantiationBaseMessages() {
-		// Do not instantiate
-	}
-
-	public static String ParseTreeAllocationInstantiationVisitor_CurrentlyThisNotSupported_EXC_;
-	public static String ParseTreeAllocationInstantiationVisitor_CannotProcessAnonymousDeclarations_EXC_;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, InstantiationBaseMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaDataTypeInstance.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaDataTypeInstance.java
deleted file mode 100644
index e62ce34..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaDataTypeInstance.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaDataTypeInstance.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:20:24 $ 
- */
-package org.eclipse.jem.internal.instantiation.base;
-
-
-/**
- * This is the default instance of a Java Model Datatype (i.e. primitive).
- * It can be created from a string, which becomes the initialization string
- * for the instance. It's toString will be the initialization string.
- *
- * It should not be referenced directly, the IJavaDataTypeInstance interface should be
- * used instead. It is public so that it can be subclassed. 
- */
-public class JavaDataTypeInstance extends JavaInstance implements IJavaDataTypeInstance {
-
-	protected JavaDataTypeInstance() {
-	}
-		
-	public boolean isPrimitive(){
-		return true;
-	}
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaFactoryHandler.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaFactoryHandler.java
deleted file mode 100644
index 05e4255..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaFactoryHandler.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: JavaFactoryHandler.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:25 $ 
- */
-
-import org.eclipse.emf.ecore.*;
-
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaDataType;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationHandler;
-
-/**
- * Adapter on JavaFactoryImpl to do instantiation.
- */
-public class JavaFactoryHandler implements IInstantiationHandler {
-
-	public final static JavaFactoryHandler INSTANCE = new JavaFactoryHandler();
-
-	/**
-	 * Constructor for JavaFactoryAdapter.
-	 */
-	protected JavaFactoryHandler() {
-		super();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.instantiation.IInstantiationHandler#handlesClass(org.eclipse.emf.ecore.EClass)
-	 */
-	public boolean handlesClass(EClass type) {
-		return type instanceof JavaClass || type instanceof JavaDataType;
-		// During XMI loading, it can't tell the JavaDataType is different than JavaClass.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.instantiation.IInstantiationHandler#handlesDataType(org.eclipse.jem.java.JavaDataType)
-	 */
-	public boolean handlesDataType(JavaDataType type) {
-		return true;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.instantiation.IInstantiationHandler#create(org.eclipse.emf.ecore.EClass)
-	 */
-	public EObject create(EClass javaClass) {
-		EObject result = javaClass instanceof JavaClass ? (EObject) new JavaObjectInstance() : new JavaDataTypeInstance();
-		((InternalEObject) result).eSetClass(javaClass);
-		return result;
-	}
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstance.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstance.java
deleted file mode 100644
index f987eee..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstance.java
+++ /dev/null
@@ -1,308 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile$
- *  $Revision$  $Date$ 
- */
-
-import java.util.List;
-
-import org.eclipse.emf.common.util.BasicEList;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.impl.EStructuralFeatureImpl;
-
-import org.eclipse.jem.internal.instantiation.JavaAllocation;
-import org.eclipse.jem.java.JavaHelpers;
-
-/**
- * This is the default instance for java model objects.
- * It should not be referenced directly, the IJavaObjectInstance interface should be
- * used instead. It is public so that it can be subclassed.
- */
-public abstract class JavaInstance extends EObjectImpl implements IJavaInstance {
-	
-	public JavaHelpers getJavaType(){
-		return (JavaHelpers) eClass();
-	}
-	
-	public JavaAllocation getAllocation() {
-		return isSetAllocation() ? (JavaAllocation) eGet(JavaInstantiation.getAllocationFeature(this)) : null;
-	}
-	
-	public boolean isImplicitAllocation() {
-		return isSetAllocation() && getAllocation().isImplicit();
-	}
-	
-	public boolean isParseTreeAllocation() {
-		return isSetAllocation() && getAllocation().isParseTree();
-	}
-	
-	/** 
-	 * Visit the argument with all of the set features in an optimized fashion 
-	 */
-	private final static Object NIL = EStructuralFeatureImpl.InternalSettingDelegateSingle.NIL;
-	public Object visitSetFeatures(Visitor aVisitor) {
-		Object result = null;
-		if (eHasSettings()) {
-			JavaInstancePropertiesHolder settings = (JavaInstancePropertiesHolder) eProperties();
-
-			Object[] setPropertyValues = settings.eSettings();
-			if (setPropertyValues != null) {
-				List allFeatures = settings.getAllStructuralFeatures();
-				for (int i = 0; i < setPropertyValues.length; i++) {
-					Object propertyValue = setPropertyValues[i];
-					if (propertyValue != null) {
-						// <null> is handled by the placeholder NIL. A setting of true null means not set. A setting of NIL means set to null.
-						if (propertyValue == NIL)
-							propertyValue = null;
-						if ((result = aVisitor.isSet((EStructuralFeature) allFeatures.get(i), propertyValue)) != null)
-							break;
-					}
-				}
-			} 
-		}
-		return result;
-	}
-	
-	public boolean isAnyFeatureSet() {
-		if (eHasSettings()) {
-			JavaInstancePropertiesHolder settings = (JavaInstancePropertiesHolder) eProperties();
-
-			Object[] setPropertyValues = settings.eSettings();
-			if (setPropertyValues != null) {
-				for (int i = 0; i < setPropertyValues.length; i++) {
-					Object propertyValue = setPropertyValues[i];
-					if (propertyValue != null) {
-						return true;
-					}
-				}
-			} 
-		}
-		return false;
-	}
-		
-	public boolean isSetAllocation() {
-		EReference allocationFeature = JavaInstantiation.getAllocationFeature(this);
-		return allocationFeature != null && eIsSet(allocationFeature);
-	}
-	
-	public void setAllocation(JavaAllocation allocation) {
-		EReference allocationFeature = JavaInstantiation.getAllocationFeature(this);
-		if (allocationFeature != null)
-			eSet(allocationFeature, allocation);
-	}
-	
-	
-	public String toString() {
-		// EObject's toString is too big for us, so we do a customized one.
-		StringBuffer result = new StringBuffer(getClass().getName());
-		result.append('@');
-		result.append(Integer.toHexString(hashCode()));
-		
-		if (eIsProxy())
-		{
-		  result.append(" (eProxyURI: "); //$NON-NLS-1$
-		  result.append(eProxyURI());
-		  result.append(')');
-		}
-		if(getJavaType() != null){
-			result.append('{');
-			result.append(getJavaType().getQualifiedName());
-			result.append('}');
-		}
-		
-		try {
-			JavaAllocation allocation = getAllocation();
-			if (allocation != null) {
-				result.append(':'); //$NON-NLS-1$
-				result.append(allocation.toString());
-			}
-		} catch (IllegalArgumentException e) {
-		} catch (NullPointerException e) {
-			// This can occur because sometimes this eClass can't be constructed right and won't have an initstring feature.
-			// In that case an NPE is thrown.
-		}
-		return result.toString();
-	}
-	
-	protected static class JavaInstancePropertiesHolder extends EPropertiesHolderImpl {
-		private EList allStructuralFeatures;
-		
-		public JavaInstancePropertiesHolder() {
-		}
-		
-		public Object[] eSettings() {
-			return eSettings;
-		}
-
-		public EList getAllStructuralFeatures() {
-			return allStructuralFeatures;
-		}
-		
-		/*
-		 * Clear the cache. This is due to 
-		 * structural features have changed.
-		 */
-		public void clearCache() {
-			eSettings = null;
-			setEContents(null);
-			setECrossReferences(null);
-			allStructuralFeatures = null;			
-		}
-
-		/* (non-Javadoc)
-		 * @see org.eclipse.emf.ecore.impl.EObjectImpl.EPropertiesHolderImpl#allocateSettings(int)
-		 */
-		public void allocateSettings(int maximumDynamicFeatureID) {
-			if (allStructuralFeatures == null)
-				allStructuralFeatures = getEClass().getEAllStructuralFeatures();			
-			super.allocateSettings(maximumDynamicFeatureID);
-		}
-		
-		
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.emf.ecore.impl.EObjectImpl.EPropertiesHolderImpl#setEContents(org.eclipse.emf.common.util.EList)
-		 */
-		public void setEContents(EList eContents) {
-			if (allStructuralFeatures == null)
-				allStructuralFeatures = getEClass().getEAllStructuralFeatures();
-			super.setEContents(eContents);
-		}
-
-		/* (non-Javadoc)
-		 * @see org.eclipse.emf.ecore.impl.EObjectImpl.EPropertiesHolderImpl#setECrossReferences(org.eclipse.emf.common.util.EList)
-		 */
-		public void setECrossReferences(EList eCrossReferences) {
-			if (allStructuralFeatures == null)
-				allStructuralFeatures = getEClass().getEAllStructuralFeatures();
-			super.setECrossReferences(eCrossReferences);
-		}
-
-	}
-	
-	protected EPropertiesHolder eProperties()
-	{
-	  if (eProperties == null)
-	  {
-		eProperties = new JavaInstancePropertiesHolder();
-	  }
-	  return eProperties;
-	}
-		
-	/**
-	 * @see org.eclipse.emf.ecore.InternalEObject#eSetClass(EClass)
-	 */
-	public void eSetClass(EClass eClass) {
-		super.eSetClass(eClass);
-		migrate();
-	}
-
-	/**
-	 * @param newEClass New eClass set to. (null) when migrating while not setting a new EClass.
-	 */
-	protected void migrate() {
-		// Note: This is extremelly implementation dependent. It may change for any implementation of EMF.	
-		if (eProperties != null && (eProperties.hasSettings() || eProperties.getEContents() != null || eProperties.getECrossReferences() != null)) {
-			// Maybe need to reconstruct settings or clear cache.
-			JavaInstancePropertiesHolder properties = (JavaInstancePropertiesHolder) eProperties;
-			EList oldAllFeatures = properties.getAllStructuralFeatures();
-			
-			// See if migration needed.
-			if (properties.getEClass().getEAllStructuralFeatures() == oldAllFeatures)
-				return;	// No migration needed.
-			
-			Object[] oldSettings = properties.eSettings();			
-			properties.clearCache();	// Clear the cache so we can rebuild it.
-			if (oldSettings == null) {
-				return;	// It was just either contents or crossrefs, and they have been appropriately cleared.			
-			}
-			
-			// It is assumed that any SF that (by identity) is in
-			// both the old and the new eClass, then it doesn't have any internal changes. It simply changed position
-			// in the settings list. Otherwise, need to see if compatible by same name, and if so, move it.			
-			eSettings();	// Create new settings
-			Object[] newSettings = properties.eSettings();
-			int staticFeatureCnt = eStaticFeatureCount();			
-			for (int oldIndex = 0; oldIndex < oldSettings.length; oldIndex++) {
-				if (oldSettings[oldIndex] != null) {
-					EStructuralFeature sf = (EStructuralFeature) oldAllFeatures.get(oldIndex+staticFeatureCnt);
-					int newIndex = super.eDynamicFeatureID(sf);	// To avoid recurse on migrate.
-					if (newIndex > -1) {
-						moveESetting(oldSettings, newSettings, oldIndex, sf, newIndex);
-					} else {
-						// See if it exists by name and is compatible.
-						EStructuralFeature newSF = properties.getEClass().getEStructuralFeature(sf.getName());
-						if (newSF != null && newSF.getClass().equals(sf.getClass()) &&
-							newSF.isMany() == sf.isMany() && newSF.isChangeable() == sf.isChangeable()) {
-							boolean compatible = newSF.isUnique() == sf.isUnique() || !newSF.isUnique();	// If new is not unique, then doesn't matter if old and new are the same
-							if (newSF instanceof EReference) {
-								EReference newRef = (EReference) newSF;
-								EReference ref = (EReference) sf;
-								compatible = newRef.isContainment() == ref.isContainment() && newRef.getEReferenceType().isSuperTypeOf(ref.getEReferenceType());
-							} else
-								compatible = newSF.getEType().equals(sf.getEType());
-								
-							if (compatible) {
-								newIndex = eDynamicFeatureID(newSF);
-								moveESetting(oldSettings, newSettings, oldIndex, newSF, newIndex);
-							}
-						}
-					}
-				}
-			}
-		} 
-	}
-
-	private void moveESetting(Object[] oldSettings, Object[] newSettings, int oldIndex, EStructuralFeature sf, int newIndex) {
-		// See if single vs many.
-		if (!sf.isMany())
-			newSettings[newIndex] = oldSettings[oldIndex];	// Great, we can just move it over.
-		else {
-			// Many is more difficult. Need to create a new dynamic list of right type, and
-			// then just copy over the data from the old one. We create new one by doing a simple eGet.
-			// This will construct an empty one with no notifications going out.
-			// Note: This is extremelly implementation dependent. We will be throwing away the old
-			// oldMany, so it is ok to reuse the actual array of data for the newMany.
-			BasicEList newMany = (BasicEList) eGet(sf);
-			BasicEList oldMany = (BasicEList) oldSettings[oldIndex];
-			newMany.setData(oldMany.size(), oldMany.data()); 
-		}
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.impl.EObjectImpl#eDynamicFeatureID(org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	protected int eDynamicFeatureID(EStructuralFeature eStructuralFeature) {
-		migrate();	// See if migration needed, and do if it does.
-		return super.eDynamicFeatureID(eStructuralFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eContents()
-	 */
-	public EList eContents() {
-		migrate();			
-		return super.eContents();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.ecore.EObject#eCrossReferences()
-	 */
-	public EList eCrossReferences() {
-		migrate();			
-		return super.eCrossReferences();
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstantiation.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstantiation.java
deleted file mode 100644
index ab46b24..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstantiation.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: JavaInstantiation.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationHandlerFactoryAdapter;
-
-/**
- * This class is used to initialize java model instantiation code and to access dynamic features.
- */
-public class JavaInstantiation {
-	
-	
-	public static final String ALLOCATION = "allocation";  //$NON-NLS-1$
-
-	/**
-	 * Get a structural feature from an instance of an IJavaObjectInstance, where the feature
-	 * is specified by its name.
-	 */
-	public static EStructuralFeature getSFeature(IJavaObjectInstance jobject, String featureName) {
-		return jobject.eClass().getEStructuralFeature(featureName);
-	}
-	
-	/**
-	 * Get a reference from an instance of an IJavaObjectInstance, where the feature
-	 * is specified by its name.
-	 */
-	public static EReference getReference(IJavaObjectInstance jobject, String featureName) {
-		return (EReference) getSFeature(jobject, featureName);
-	}	
-	
-	/**
-	 * Get a structural feature from an instance of an IJavaObjectInstance, where the feature
-	 * is specified by its URI (e.g. "java:/java.lang#Object/class").
-	 */
-	public static EStructuralFeature getSFeature(IJavaObjectInstance jobject, URI sfURI) {
-		return getSFeature((JavaClass) jobject.getJavaType(), sfURI);
-	}
-
-	/**
-	 * Get a structural feature from a JavaClass, where the feature
-	 * is specified by its URI (e.g. "java:/java.lang#Object/class").
-	 */
-	public static EStructuralFeature getSFeature(JavaClass jclass, URI sfURI) {
-		return getSFeature(jclass.eResource().getResourceSet(), sfURI);
-	}
-	
-	/**
-	 * Get a structural feature from a ResourceSet, where the feature
-	 * is specified by its URI (e.g. "java:/java.lang#Object/class").
-	 */
-	public static EStructuralFeature getSFeature(ResourceSet rset, URI sfURI) {
-		return (EStructuralFeature) rset.getEObject(sfURI, true);
-	}	
-	
-	/**
-	 * Get a reference from an instance of an IJavaObjectInstance, where the feature
-	 * is specified by its URI (e.g. "java:/java.lang#Object/class").
-	 */
-	public static EReference getReference(IJavaObjectInstance jobject, URI sfURI) {
-		return (EReference) getSFeature((JavaClass) jobject.getJavaType(), sfURI);
-	}
-
-	/**
-	 * Get a reference from a JavaClass, where the feature
-	 * is specified by its URI (e.g. "java:/java.lang#Object/class").
-	 */
-	public static EReference getReference(JavaClass jclass, URI sfURI) {
-		return (EReference) getSFeature(jclass.eResource().getResourceSet(), sfURI);
-	}
-	
-	/**
-	 * Get a reference from a ResourceSet, where the feature
-	 * is specified by its URI (e.g. "java:/java.lang#Object/class").
-	 */
-	public static EReference getReference(ResourceSet rset, URI sfURI) {
-		return (EReference) rset.getEObject(sfURI, true);
-	}	
-	
-	/**
-	 * Get the allocation Feature for this object. Since it depends
-	 * on what resource that the metaclass is defined in, we must look for it.
-	 */
-	public static EReference getAllocationFeature(IJavaInstance jinstance) {
-		return (EReference) jinstance.eClass().getEStructuralFeature(ALLOCATION);
-	}
-			
-	public static void initialize(ResourceSet rset) {
-			if (EcoreUtil.getExistingAdapter(rset, IInstantiationHandlerFactoryAdapter.ADAPTER_KEY) == null)
-				rset.eAdapters().add(new JavaInstantiationHandlerFactoryAdapter());
-	}
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstantiationHandlerFactoryAdapter.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstantiationHandlerFactoryAdapter.java
deleted file mode 100644
index 8d5df86..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaInstantiationHandlerFactoryAdapter.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.base;
-/*
- *  $RCSfile: JavaInstantiationHandlerFactoryAdapter.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/14 23:30:35 $ 
- */
-
-import org.eclipse.emf.common.notify.impl.AdapterImpl;
-
-import org.eclipse.jem.java.internal.impl.JavaFactoryImpl;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationHandler;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationHandlerFactoryAdapter;
-
-/**
- * This adapter is attached to the resource set for a java model. The
- * JavaXMIFactory will ask for this adapter and ask it for the IInstantiationHandler.
- */
-public class JavaInstantiationHandlerFactoryAdapter extends AdapterImpl implements IInstantiationHandlerFactoryAdapter {
-
-	/**
-	 * Constructor for JavaInstantiationHandlerFactoryAdapter.
-	 */
-	public JavaInstantiationHandlerFactoryAdapter() {
-		super();
-	}
-
-	/**
-	 * @see org.eclipse.jem.internal.instantiation.IInstantiationHandlerFactoryAdapter#getInstantiationHandler(JavaFactoryImpl)
-	 */
-	public IInstantiationHandler getInstantiationHandler(JavaFactoryImpl factory) {
-		return JavaFactoryHandler.INSTANCE;
-	}
-
-	/**
-	 * @see org.eclipse.emf.common.notify.Adapter#isAdapterForType(Object)
-	 */
-	public boolean isAdapterForType(Object type) {
-		return IInstantiationHandlerFactoryAdapter.ADAPTER_KEY == type;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaObjectInstance.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaObjectInstance.java
deleted file mode 100644
index 8d7327f..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/JavaObjectInstance.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaObjectInstance.java,v $
- *  $Revision: 1.18 $  $Date: 2005/08/23 21:13:01 $ 
- */
-package org.eclipse.jem.internal.instantiation.base;
- 
-
-/**
- * Java Object Instance implementation.
- * @since 1.1.0.1
- */
-public class JavaObjectInstance extends JavaInstance implements IJavaObjectInstance {
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.base.IJavaInstance#isPrimitive()
-	 */
-	public boolean isPrimitive() {
-		return false;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/ParseTreeAllocationInstantiationVisitor.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/ParseTreeAllocationInstantiationVisitor.java
deleted file mode 100644
index 3927467..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/ParseTreeAllocationInstantiationVisitor.java
+++ /dev/null
@@ -1,505 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: ParseTreeAllocationInstantiationVisitor.java,v $
- *  $Revision: 1.9 $  $Date: 2005/10/28 22:56:46 $ 
- */
-package org.eclipse.jem.internal.instantiation.base;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.proxy.core.*;
-import org.eclipse.jem.internal.proxy.initParser.tree.*;
- 
-/**
- * This is the standard parse visitor for instantiating a bean proxy from a java parse tree allocation.
- * It can be reused, but is not thread-safe.
- * 
- * @since 1.0.0
- */
-public class ParseTreeAllocationInstantiationVisitor extends ParseVisitor {
-		
-	/**
-	 * The expression that is being created and evaluated.
-	 */
-	private IExpression expression;
-	
-	/*
-	 * The next expression type that should be used. It is used when one expression is sending the
-	 * visitation to the next expression. It will set this to what that expression should be using. This
-	 * is necessary because the next expression doesn't know what it should be.
-	 */
-	private ForExpression nextExpression = ForExpression.ROOTEXPRESSION;
-	
-	/**
-	 * An exception occurred during processing. It is a RuntimeException because
-	 * it can be thrown at any time. It wrappers another exception. That exception
-	 * can be retrieved from the cause of the ProcessingException.
-	 * 
-	 * @see Throwable#getCause()
-	 * @since 1.0.0
-	 */
-	public static class ProcessingException extends RuntimeException {
-		
-		/**
-		 * Comment for <code>serialVersionUID</code>
-		 * 
-		 * @since 1.1.0
-		 */
-		private static final long serialVersionUID = 1268624222490406643L;
-
-		/**
-		 * @param cause
-		 * 
-		 * @since 1.0.0
-		 */
-		public ProcessingException(Throwable cause) {
-			super(cause);
-		}
-	}
-	
-	static final InfixOperator[] INFIXTOPROXY;
-	static {
-		INFIXTOPROXY = new InfixOperator[PTInfixOperator.VALUES.size()];
-		INFIXTOPROXY[PTInfixOperator.AND] = InfixOperator.IN_AND;
-		INFIXTOPROXY[PTInfixOperator.CONDITIONAL_AND] = InfixOperator.IN_CONDITIONAL_AND;
-		INFIXTOPROXY[PTInfixOperator.CONDITIONAL_OR] = InfixOperator.IN_CONDITIONAL_OR;
-		INFIXTOPROXY[PTInfixOperator.DIVIDE] = InfixOperator.IN_DIVIDE;
-		INFIXTOPROXY[PTInfixOperator.EQUALS] = InfixOperator.IN_EQUALS;
-		INFIXTOPROXY[PTInfixOperator.GREATER] = InfixOperator.IN_GREATER;
-		INFIXTOPROXY[PTInfixOperator.GREATER_EQUALS] = InfixOperator.IN_GREATER_EQUALS;
-		INFIXTOPROXY[PTInfixOperator.LEFT_SHIFT] = InfixOperator.IN_LEFT_SHIFT;
-		INFIXTOPROXY[PTInfixOperator.LESS] = InfixOperator.IN_LESS;
-		INFIXTOPROXY[PTInfixOperator.LESS_EQUALS] = InfixOperator.IN_LESS_EQUALS;
-		INFIXTOPROXY[PTInfixOperator.MINUS] = InfixOperator.IN_MINUS;
-		INFIXTOPROXY[PTInfixOperator.NOT_EQUALS] = InfixOperator.IN_NOT_EQUALS;
-		INFIXTOPROXY[PTInfixOperator.OR] = InfixOperator.IN_OR;
-		INFIXTOPROXY[PTInfixOperator.PLUS] = InfixOperator.IN_PLUS;
-		INFIXTOPROXY[PTInfixOperator.REMAINDER] = InfixOperator.IN_REMAINDER;
-		INFIXTOPROXY[PTInfixOperator.RIGHT_SHIFT_SIGNED] = InfixOperator.IN_RIGHT_SHIFT_SIGNED;
-		INFIXTOPROXY[PTInfixOperator.RIGHT_SHIFT_UNSIGNED] = InfixOperator.IN_RIGHT_SHIFT_UNSIGNED;
-		INFIXTOPROXY[PTInfixOperator.TIMES] = InfixOperator.IN_TIMES;
-		INFIXTOPROXY[PTInfixOperator.XOR] = InfixOperator.IN_XOR;
-	}
-	
-	/**
-	 * A helper method to convert the parse tree's infix operator to the Proxy infix operator.
-	 * 
-	 * @param operator
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public static InfixOperator convertPTInfixOperatorToProxyInfixOperator(PTInfixOperator operator) {
-		return INFIXTOPROXY[operator.getValue()];
-	}
-
-	static final PrefixOperator[] PREFIXTOPROXY;
-	static {
-		PREFIXTOPROXY = new PrefixOperator[PTPrefixOperator.VALUES.size()];
-		PREFIXTOPROXY[PTPrefixOperator.COMPLEMENT] = PrefixOperator.PRE_COMPLEMENT;
-		PREFIXTOPROXY[PTPrefixOperator.MINUS] = PrefixOperator.PRE_MINUS;
-		PREFIXTOPROXY[PTPrefixOperator.NOT] = PrefixOperator.PRE_NOT;
-		PREFIXTOPROXY[PTPrefixOperator.PLUS] = PrefixOperator.PRE_PLUS;
-	}
-	
-	/**
-	 * A helper method to convert the parse tree's prefix operator to the Proxy prefix operator.
-	 * 
-	 * @param operator
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public static PrefixOperator convertPTPrefixOperatorToProxyPrefixOperator(PTPrefixOperator operator) {
-		return PREFIXTOPROXY[operator.getValue()];
-	}
-	
-	/**
-	 * Create the visitor with the given registry.
-	 * 
-	 * @param registry
-	 * 
-	 * @since 1.0.0
-	 */
-	public ParseTreeAllocationInstantiationVisitor() {
-	}
-	
-	/**
-	 * Get the current registry.
-	 * 
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final ProxyFactoryRegistry getRegistry() {
-		return expression.getRegistry();
-	}
-	
-	/**
-	 * Get the current expression.
-	 * 
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	protected final IExpression getExpression() {
-		return expression;
-	}	
-
-	/**
-	 * Get the beanproxy for the given expression and registry. It will evaluate immediately.
-	 * 
-	 * @param expression
-	 * @param registry
-	 * @return
-	 * @throws IllegalStateException
-	 * @throws ThrowableProxy
-	 * @throws NoExpressionValueException
-	 * @throws ProcessingException
-	 * 
-	 * @since 1.0.0
-	 */
-	public IBeanProxy getBeanProxy(PTExpression expression, ProxyFactoryRegistry registry) throws IllegalStateException, IllegalArgumentException, ThrowableProxy, NoExpressionValueException, ProcessingException {
-		this.expression = registry.getBeanProxyFactory().createExpression();
-		setNextExpression(ForExpression.ROOTEXPRESSION);
-		try {
-			expression.accept(this);
-		} catch (ProcessingException e) {
-			// Handle the most common that make sense to be know distinctly and throw them instead of ProcessingException.
-			Throwable t = e.getCause();
-			if (t instanceof NoExpressionValueException)
-				throw (NoExpressionValueException) t;
-			else if (t instanceof IllegalStateException)
-				throw (IllegalStateException) t;
-			else
-				throw e;
-		}
-		
-		return getExpression().getExpressionValue();
-	}
-	
-	/**
-	 * Using the given expression processor allocate the proxy. It will not evaluate immediately, but just push onto the expression.
-	 * @param expression
-	 * @param expressionProcessor
-	 * @return the ExpressionProxy for the allocation.
-	 * @throws IllegalStateException
-	 * @throws IllegalArgumentException
-	 * @throws ProcessingException
-	 * 
-	 * @since 1.1.0
-	 */
-	public ExpressionProxy getProxy(PTExpression expression, IExpression expressionProcessor) throws IllegalStateException, IllegalArgumentException, ProcessingException {
-		this.expression = expressionProcessor;
-		try {
-			ExpressionProxy proxy = expressionProcessor.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION);
-			setNextExpression(ForExpression.ASSIGNMENT_RIGHT);
-			expression.accept(this);
-			return proxy;
-		} catch (ProcessingException e) {
-			// Handle the most common that make sense to be know distinctly and throw them instead of ProcessingException.
-			Throwable t = e.getCause();
-			if (t instanceof IllegalStateException)
-				throw (IllegalStateException) t;
-			else
-				throw e;
-		}
-	}
-
-	
-	/**
-	 * Set the next expression type. (i.e. the <code>forExpression</code> field of most of the create expression methods.
-	 * 
-	 * @param nextExpression
-	 * 
-	 * @see IExpression#createInfixExpression(int, int, int)
-	 * @since 1.0.0
-	 */
-	protected final void setNextExpression(ForExpression nextExpression) {
-		this.nextExpression = nextExpression;
-	}
-
-	/**
-	 * Get the next expression type. (i.e. the <code>forExpression</code> field of most of the create expression methods.
-	 * 
-	 * @return
-	 * 
-	 * @see IExpression#createInfixExpression(int, int, int)
-	 * @since 1.0.0
-	 */
-	protected final ForExpression getNextExpression() {
-		return nextExpression;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration)
-	 */
-	public boolean visit(PTAnonymousClassDeclaration node) {
-		throw new IllegalArgumentException(MessageFormat.format(InstantiationBaseMessages.ParseTreeAllocationInstantiationVisitor_CannotProcessAnonymousDeclarations_EXC_, new Object[] {node.getDeclaration()}));
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTArrayAccess)
-	 */
-	public boolean visit(PTArrayAccess node) {
-		getExpression().createArrayAccess(getNextExpression(), node.getIndexes().size());
-		setNextExpression(ForExpression.ARRAYACCESS_ARRAY);
-		node.getArray().accept(this);
-		List idx = node.getIndexes();
-		int s = idx.size();
-		for (int i = 0; i < s; i++) {
-			setNextExpression(ForExpression.ARRAYACCESS_INDEX);
-			((PTExpression) idx.get(i)).accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTArrayCreation)
-	 */
-	public boolean visit(PTArrayCreation node) {
-		getExpression().createArrayCreation(getNextExpression(), node.getType(), node.getDimensions().size());
-		if (node.getDimensions().isEmpty()) {
-			node.getInitializer().accept(this);	// Array initializer doesn't require a next expression.
-		} else {
-			List dims = node.getDimensions();
-			int s = dims.size();
-			for (int i = 0; i < s; i++) {
-				setNextExpression(ForExpression.ARRAYCREATION_DIMENSION);
-				((PTExpression) dims.get(i)).accept(this);
-			}
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTArrayInitializer)
-	 */
-	public boolean visit(PTArrayInitializer node) {
-		getExpression().createArrayInitializer(node.getExpressions().size());
-		List exps = node.getExpressions();
-		int s = exps.size();
-		for (int i = 0; i < s; i++) {
-			setNextExpression(ForExpression.ARRAYINITIALIZER_EXPRESSION);
-			((PTExpression) exps.get(i)).accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTBooleanLiteral)
-	 */
-	public boolean visit(PTBooleanLiteral node) {
-		getExpression().createPrimitiveLiteral(getNextExpression(), node.isBooleanValue());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTCastExpression)
-	 */
-	public boolean visit(PTCastExpression node) {
-		getExpression().createCastExpression(getNextExpression(), node.getType());
-		setNextExpression(ForExpression.CAST_EXPRESSION);
-		node.getExpression().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTCharacterLiteral)
-	 */
-	public boolean visit(PTCharacterLiteral node) {
-		getExpression().createPrimitiveLiteral(getNextExpression(), node.getCharValue());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTClassInstanceCreation)
-	 */
-	public boolean visit(PTClassInstanceCreation node) {
-		getExpression().createClassInstanceCreation(getNextExpression(), node.getType(), node.getArguments().size());
-		List args = node.getArguments();
-		int s = args.size();
-		for (int i = 0; i < s; i++) {
-			setNextExpression(ForExpression.CLASSINSTANCECREATION_ARGUMENT);
-			((PTExpression) args.get(i)).accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTConditionalExpression)
-	 */
-	public boolean visit(PTConditionalExpression node) {
-		getExpression().createConditionalExpression(getNextExpression());
-		setNextExpression(ForExpression.CONDITIONAL_CONDITION);
-		node.getCondition().accept(this);
-		setNextExpression(ForExpression.CONDITIONAL_TRUE);
-		node.getTrue().accept(this);
-		setNextExpression(ForExpression.CONDITIONAL_FALSE);
-		node.getFalse().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTFieldAccess)
-	 */
-	public boolean visit(PTFieldAccess node) {
-		getExpression().createFieldAccess(getNextExpression(), node.getField(), node.getReceiver() != null);
-		if (node.getReceiver() != null) {
-			setNextExpression(ForExpression.FIELD_RECEIVER);
-			node.getReceiver().accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTInfixExpression)
-	 */
-	public boolean visit(PTInfixExpression node) {
-		getExpression().createInfixExpression(getNextExpression(), convertPTInfixOperatorToProxyInfixOperator(node.getOperator()), node.getExtendedOperands().size());
-		setNextExpression(ForExpression.INFIX_LEFT);
-		node.getLeftOperand().accept(this);
-		setNextExpression(ForExpression.INFIX_RIGHT);
-		node.getRightOperand().accept(this);
-		List extended = node.getExtendedOperands();
-		int s = extended.size();
-		for (int i = 0; i < s; i++) {
-			setNextExpression(ForExpression.INFIX_EXTENDED);
-			((PTExpression) extended.get(i)).accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTInstanceof)
-	 */
-	public boolean visit(PTInstanceof node) {
-		getExpression().createInstanceofExpression(getNextExpression(), node.getType());
-		setNextExpression(ForExpression.INSTANCEOF_VALUE);
-		node.getOperand().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTInvalidExpression)
-	 */
-	public boolean visit(PTInvalidExpression node) {
-		throw new IllegalArgumentException(node.getMessage());
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTMethodInvocation)
-	 */
-	public boolean visit(PTMethodInvocation node) {
-		getExpression().createMethodInvocation(getNextExpression(), node.getName(), node.getReceiver() != null, node.getArguments().size());
-		if (node.getReceiver() != null) {
-			setNextExpression(ForExpression.METHOD_RECEIVER);
-			node.getReceiver().accept(this);
-		}
-		List args = node.getArguments();
-		int s = args.size();
-		for (int i = 0; i < s; i++) {
-			setNextExpression(ForExpression.METHOD_ARGUMENT);
-			((PTExpression) args.get(i)).accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTName)
-	 */
-	public boolean visit(PTName node) {
-		// This is special in the PTName can only be used as a type receiver at this time.
-		getExpression().createTypeReceiver(node.getName());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTNullLiteral)
-	 */
-	public boolean visit(PTNullLiteral node) {
-		// This is special in the PTName can only be used as a type receiver at this time.
-		getExpression().createNull(getNextExpression());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTNumberLiteral)
-	 */
-	public boolean visit(PTNumberLiteral node) {
-		// It is assumed the tokens are trimmed.
-		String lit = node.getToken();
-		char lastChar = lit.charAt(lit.length()-1);
-		if (lastChar == 'l' || lastChar == 'L' ) {
-			// It is definitely a long.
-			// Using decode so that things like 0x3 will be parsed. parseLong won't recognize those.
-			getExpression().createPrimitiveLiteral(getNextExpression(), Long.decode(lit.substring(0, lit.length()-1)).longValue());
-		} else if (lastChar == 'F' || lastChar == 'f') {
-			// It is definitely a float.
-			getExpression().createPrimitiveLiteral(getNextExpression(), Float.parseFloat(lit.substring(0, lit.length()-1)));
-		} else if (lastChar == 'D' || lastChar == 'd')  {
-			// It is definitely a double.
-			getExpression().createPrimitiveLiteral(getNextExpression(), Double.parseDouble(lit.substring(0, lit.length()-1)));
-		} else if (lit.indexOf('.') != -1 || lit.indexOf('e') != -1 || lit.indexOf('E') != -1) {
-				// It is definitely a double. (has a period or an exponent, but does not have an 'f' on the end is always a double).
-				getExpression().createPrimitiveLiteral(getNextExpression(), Double.parseDouble(lit.substring(0, lit.length())));
-		} else {
-			// Using decode so that things like 0x3 will be parsed. parseInt won't recognize those.
-			getExpression().createPrimitiveLiteral(getNextExpression(), Integer.decode(lit).intValue());
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTParenthesizedExpression)
-	 */
-	public boolean visit(PTParenthesizedExpression node) {
-		node.getExpression().accept(this);	// For instantiation purposes, the parenthesis can be ignored.
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTPrefixExpression)
-	 */
-	public boolean visit(PTPrefixExpression node) {
-		getExpression().createPrefixExpression(getNextExpression(), convertPTPrefixOperatorToProxyPrefixOperator(node.getOperator()));
-		setNextExpression(ForExpression.PREFIX_OPERAND);
-		node.getExpression().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTStringLiteral)
-	 */
-	public boolean visit(PTStringLiteral node) {
-		getExpression().createProxyExpression(getNextExpression(), getRegistry().getBeanProxyFactory().createBeanProxyWith(node.getLiteralValue()));
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTThisLiteral)
-	 */
-	public boolean visit(PTThisLiteral node) {
-		throw new IllegalArgumentException(InstantiationBaseMessages.ParseTreeAllocationInstantiationVisitor_CurrentlyThisNotSupported_EXC_); 
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTTypeLiteral)
-	 */
-	public boolean visit(PTTypeLiteral node) {
-		getExpression().createTypeLiteral(getNextExpression(), node.getType());
-		return false;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/messages.properties b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/messages.properties
deleted file mode 100644
index d7e1f16..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/base/messages.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-ParseTreeAllocationInstantiationVisitor_CurrentlyThisNotSupported_EXC_ = IWAV0001E Currently "this" is not supported
-ParseTreeAllocationInstantiationVisitor_CannotProcessAnonymousDeclarations_EXC_ = Cannot process anonymous declarations: "{0}"
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/ImplicitAllocationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/ImplicitAllocationImpl.java
deleted file mode 100644
index 8ea295f..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/ImplicitAllocationImpl.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: ImplicitAllocationImpl.java,v $
- *  $Revision: 1.9 $  $Date: 2005/10/03 19:20:41 $ 
- */
- 
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.ImplicitAllocation;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Implicit Allocation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.ImplicitAllocationImpl#getParent <em>Parent</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.ImplicitAllocationImpl#getFeature <em>Feature</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ImplicitAllocationImpl extends JavaAllocationImpl implements ImplicitAllocation {
-	/**
-	 * The cached value of the '{@link #getParent() <em>Parent</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getParent()
-	 * @generated
-	 * @ordered
-	 */
-	protected EObject parent = null;
-
-	/**
-	 * The cached value of the '{@link #getFeature() <em>Feature</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFeature()
-	 * @generated
-	 * @ordered
-	 */
-	protected EStructuralFeature feature = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ImplicitAllocationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getImplicitAllocation();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject getParent() {
-		if (parent != null && parent.eIsProxy()) {
-			EObject oldParent = parent;
-			parent = eResolveProxy((InternalEObject)parent);
-			if (parent != oldParent) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, InstantiationPackage.IMPLICIT_ALLOCATION__PARENT, oldParent, parent));
-			}
-		}
-		return parent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject basicGetParent() {
-		return parent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setParent(EObject newParent) {
-		EObject oldParent = parent;
-		parent = newParent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.IMPLICIT_ALLOCATION__PARENT, oldParent, parent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EStructuralFeature getFeature() {
-		if (feature != null && feature.eIsProxy()) {
-			EStructuralFeature oldFeature = feature;
-			feature = (EStructuralFeature)eResolveProxy((InternalEObject)feature);
-			if (feature != oldFeature) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, InstantiationPackage.IMPLICIT_ALLOCATION__FEATURE, oldFeature, feature));
-			}
-		}
-		return feature;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EStructuralFeature basicGetFeature() {
-		return feature;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFeature(EStructuralFeature newFeature) {
-		EStructuralFeature oldFeature = feature;
-		feature = newFeature;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.IMPLICIT_ALLOCATION__FEATURE, oldFeature, feature));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.IMPLICIT_ALLOCATION__PARENT:
-				if (resolve) return getParent();
-				return basicGetParent();
-			case InstantiationPackage.IMPLICIT_ALLOCATION__FEATURE:
-				if (resolve) return getFeature();
-				return basicGetFeature();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.IMPLICIT_ALLOCATION__PARENT:
-				setParent((EObject)newValue);
-				return;
-			case InstantiationPackage.IMPLICIT_ALLOCATION__FEATURE:
-				setFeature((EStructuralFeature)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.IMPLICIT_ALLOCATION__PARENT:
-				setParent((EObject)null);
-				return;
-			case InstantiationPackage.IMPLICIT_ALLOCATION__FEATURE:
-				setFeature((EStructuralFeature)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.IMPLICIT_ALLOCATION__PARENT:
-				return parent != null;
-			case InstantiationPackage.IMPLICIT_ALLOCATION__FEATURE:
-				return feature != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return "ImplicitAllocation(" + getParent() + "-" + getFeature();
-	}
-
-	public boolean isImplicit() {
-		return true;
-	}
-	
-} //ImplicitAllocationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InitStringAllocationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InitStringAllocationImpl.java
deleted file mode 100644
index 78dfa34..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InitStringAllocationImpl.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: InitStringAllocationImpl.java,v $
- *  $Revision: 1.8 $  $Date: 2005/09/15 21:02:19 $ 
- */
- 
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.InitStringAllocation;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Init String Allocation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.InitStringAllocationImpl#getInitString <em>Init String</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class InitStringAllocationImpl extends JavaAllocationImpl implements InitStringAllocation {
-	/**
-	 * The default value of the '{@link #getInitString() <em>Init String</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInitString()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String INIT_STRING_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getInitString() <em>Init String</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInitString()
-	 * @generated
-	 * @ordered
-	 */
-	protected String initString = INIT_STRING_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected InitStringAllocationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getInitStringAllocation();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getInitString() {
-		return initString;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInitString(String newInitString) {
-		String oldInitString = initString;
-		initString = newInitString;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.INIT_STRING_ALLOCATION__INIT_STRING, oldInitString, initString));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.INIT_STRING_ALLOCATION__INIT_STRING:
-				return getInitString();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.INIT_STRING_ALLOCATION__INIT_STRING:
-				setInitString((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.INIT_STRING_ALLOCATION__INIT_STRING:
-				setInitString(INIT_STRING_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.INIT_STRING_ALLOCATION__INIT_STRING:
-				return INIT_STRING_EDEFAULT == null ? initString != null : !INIT_STRING_EDEFAULT.equals(initString);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer();
-		result.append("InitString: ");
-		result.append(initString);
-		return result.toString();
-	}
-
-} //InitStringAllocationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationFactoryImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationFactoryImpl.java
deleted file mode 100644
index 0028982..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationFactoryImpl.java
+++ /dev/null
@@ -1,633 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: InstantiationFactoryImpl.java,v $
- *  $Revision: 1.12 $  $Date: 2005/10/28 22:56:46 $ 
- */
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EObject;
-
-import java.util.List;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.base.IJavaInstance;
-
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-public class InstantiationFactoryImpl extends EFactoryImpl implements InstantiationFactory {
-	/**
-	 * Creates an instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public InstantiationFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject create(EClass eClass) {
-		switch (eClass.getClassifierID()) {
-			case InstantiationPackage.INIT_STRING_ALLOCATION: return createInitStringAllocation();
-			case InstantiationPackage.IMPLICIT_ALLOCATION: return createImplicitAllocation();
-			case InstantiationPackage.PARSE_TREE_ALLOCATION: return createParseTreeAllocation();
-			case InstantiationPackage.PT_ARRAY_ACCESS: return createPTArrayAccess();
-			case InstantiationPackage.PT_ARRAY_CREATION: return createPTArrayCreation();
-			case InstantiationPackage.PT_ARRAY_INITIALIZER: return createPTArrayInitializer();
-			case InstantiationPackage.PT_BOOLEAN_LITERAL: return createPTBooleanLiteral();
-			case InstantiationPackage.PT_CAST_EXPRESSION: return createPTCastExpression();
-			case InstantiationPackage.PT_CHARACTER_LITERAL: return createPTCharacterLiteral();
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION: return createPTClassInstanceCreation();
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION: return createPTConditionalExpression();
-			case InstantiationPackage.PT_FIELD_ACCESS: return createPTFieldAccess();
-			case InstantiationPackage.PT_INFIX_EXPRESSION: return createPTInfixExpression();
-			case InstantiationPackage.PT_INSTANCEOF: return createPTInstanceof();
-			case InstantiationPackage.PT_METHOD_INVOCATION: return createPTMethodInvocation();
-			case InstantiationPackage.PT_NAME: return createPTName();
-			case InstantiationPackage.PT_NULL_LITERAL: return createPTNullLiteral();
-			case InstantiationPackage.PT_NUMBER_LITERAL: return createPTNumberLiteral();
-			case InstantiationPackage.PT_PARENTHESIZED_EXPRESSION: return createPTParenthesizedExpression();
-			case InstantiationPackage.PT_PREFIX_EXPRESSION: return createPTPrefixExpression();
-			case InstantiationPackage.PT_STRING_LITERAL: return createPTStringLiteral();
-			case InstantiationPackage.PT_THIS_LITERAL: return createPTThisLiteral();
-			case InstantiationPackage.PT_TYPE_LITERAL: return createPTTypeLiteral();
-			case InstantiationPackage.PT_INVALID_EXPRESSION: return createPTInvalidExpression();
-			case InstantiationPackage.PT_INSTANCE_REFERENCE: return createPTInstanceReference();
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION: return createPTAnonymousClassDeclaration();
-			default:
-				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object createFromString(EDataType eDataType, String initialValue) {
-		switch (eDataType.getClassifierID()) {
-			case InstantiationPackage.PT_INFIX_OPERATOR: {
-				PTInfixOperator result = PTInfixOperator.get(initialValue);
-				if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
-				return result;
-			}
-			case InstantiationPackage.PT_PREFIX_OPERATOR: {
-				PTPrefixOperator result = PTPrefixOperator.get(initialValue);
-				if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
-				return result;
-			}
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String convertToString(EDataType eDataType, Object instanceValue) {
-		switch (eDataType.getClassifierID()) {
-			case InstantiationPackage.PT_INFIX_OPERATOR:
-				return instanceValue == null ? null : instanceValue.toString();
-			case InstantiationPackage.PT_PREFIX_OPERATOR:
-				return instanceValue == null ? null : instanceValue.toString();
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public InitStringAllocation createInitStringAllocation() {
-		InitStringAllocationImpl initStringAllocation = new InitStringAllocationImpl();
-		return initStringAllocation;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ImplicitAllocation createImplicitAllocation() {
-		ImplicitAllocationImpl implicitAllocation = new ImplicitAllocationImpl();
-		return implicitAllocation;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ParseTreeAllocation createParseTreeAllocation() {
-		ParseTreeAllocationImpl parseTreeAllocation = new ParseTreeAllocationImpl();
-		return parseTreeAllocation;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTArrayAccess createPTArrayAccess() {
-		PTArrayAccessImpl ptArrayAccess = new PTArrayAccessImpl();
-		return ptArrayAccess;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTArrayCreation createPTArrayCreation() {
-		PTArrayCreationImpl ptArrayCreation = new PTArrayCreationImpl();
-		return ptArrayCreation;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTArrayInitializer createPTArrayInitializer() {
-		PTArrayInitializerImpl ptArrayInitializer = new PTArrayInitializerImpl();
-		return ptArrayInitializer;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTBooleanLiteral createPTBooleanLiteral() {
-		PTBooleanLiteralImpl ptBooleanLiteral = new PTBooleanLiteralImpl();
-		return ptBooleanLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTCastExpression createPTCastExpression() {
-		PTCastExpressionImpl ptCastExpression = new PTCastExpressionImpl();
-		return ptCastExpression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTCharacterLiteral createPTCharacterLiteral() {
-		PTCharacterLiteralImpl ptCharacterLiteral = new PTCharacterLiteralImpl();
-		return ptCharacterLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTClassInstanceCreation createPTClassInstanceCreation() {
-		PTClassInstanceCreationImpl ptClassInstanceCreation = new PTClassInstanceCreationImpl();
-		return ptClassInstanceCreation;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTConditionalExpression createPTConditionalExpression() {
-		PTConditionalExpressionImpl ptConditionalExpression = new PTConditionalExpressionImpl();
-		return ptConditionalExpression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTFieldAccess createPTFieldAccess() {
-		PTFieldAccessImpl ptFieldAccess = new PTFieldAccessImpl();
-		return ptFieldAccess;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTInfixExpression createPTInfixExpression() {
-		PTInfixExpressionImpl ptInfixExpression = new PTInfixExpressionImpl();
-		return ptInfixExpression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTInstanceof createPTInstanceof() {
-		PTInstanceofImpl ptInstanceof = new PTInstanceofImpl();
-		return ptInstanceof;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTMethodInvocation createPTMethodInvocation() {
-		PTMethodInvocationImpl ptMethodInvocation = new PTMethodInvocationImpl();
-		return ptMethodInvocation;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTName createPTName() {
-		PTNameImpl ptName = new PTNameImpl();
-		return ptName;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTNullLiteral createPTNullLiteral() {
-		PTNullLiteralImpl ptNullLiteral = new PTNullLiteralImpl();
-		return ptNullLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTNumberLiteral createPTNumberLiteral() {
-		PTNumberLiteralImpl ptNumberLiteral = new PTNumberLiteralImpl();
-		return ptNumberLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTParenthesizedExpression createPTParenthesizedExpression() {
-		PTParenthesizedExpressionImpl ptParenthesizedExpression = new PTParenthesizedExpressionImpl();
-		return ptParenthesizedExpression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTPrefixExpression createPTPrefixExpression() {
-		PTPrefixExpressionImpl ptPrefixExpression = new PTPrefixExpressionImpl();
-		return ptPrefixExpression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTStringLiteral createPTStringLiteral() {
-		PTStringLiteralImpl ptStringLiteral = new PTStringLiteralImpl();
-		return ptStringLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTThisLiteral createPTThisLiteral() {
-		PTThisLiteralImpl ptThisLiteral = new PTThisLiteralImpl();
-		return ptThisLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTTypeLiteral createPTTypeLiteral() {
-		PTTypeLiteralImpl ptTypeLiteral = new PTTypeLiteralImpl();
-		return ptTypeLiteral;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTInvalidExpression createPTInvalidExpression() {
-		PTInvalidExpressionImpl ptInvalidExpression = new PTInvalidExpressionImpl();
-		return ptInvalidExpression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTInstanceReference createPTInstanceReference() {
-		PTInstanceReferenceImpl ptInstanceReference = new PTInstanceReferenceImpl();
-		return ptInstanceReference;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTAnonymousClassDeclaration createPTAnonymousClassDeclaration() {
-		PTAnonymousClassDeclarationImpl ptAnonymousClassDeclaration = new PTAnonymousClassDeclarationImpl();
-		return ptAnonymousClassDeclaration;
-	}
-
-	public PTInstanceReference createPTInstanceReference(IJavaInstance instance) {
-		PTInstanceReference ptInstanceReference = createPTInstanceReference();
-		ptInstanceReference.setReference(instance);
-		return ptInstanceReference;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public InstantiationPackage getInstantiationPackage() {
-		return (InstantiationPackage)getEPackage();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @deprecated
-	 * @generated
-	 */
-	public static InstantiationPackage getPackage() {
-		return InstantiationPackage.eINSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createImplicitAllocation(org.eclipse.emf.ecore.EObject, org.eclipse.emf.ecore.EStructuralFeature)
-	 */
-	public ImplicitAllocation createImplicitAllocation(EObject parent, EStructuralFeature sf) {
-		ImplicitAllocation alloc = createImplicitAllocation();
-		alloc.setParent(parent);
-		alloc.setFeature(sf);
-		return alloc;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createInitStringAllocation(java.lang.String)
-	 */
-	public InitStringAllocation createInitStringAllocation(String initString) {
-		InitStringAllocation alloc = createInitStringAllocation();
-		alloc.setInitString(initString);
-		return alloc;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createParseTreeAllocation(org.eclipse.jem.internal.instantiation.PTExpression)
-	 */
-	public ParseTreeAllocation createParseTreeAllocation(PTExpression expression) {
-		ParseTreeAllocation a = createParseTreeAllocation();
-		a.setExpression(expression);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTArrayAccess(org.eclipse.jem.internal.instantiation.PTExpression, java.util.List)
-	 */
-	public PTArrayAccess createPTArrayAccess(PTExpression array, List indexes) {
-		PTArrayAccess a = createPTArrayAccess();
-		a.setArray(array);
-		a.getIndexes().addAll(indexes);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTArrayCreation(java.lang.String, java.util.List, org.eclipse.jem.internal.instantiation.PTArrayInitializer)
-	 */
-	public PTArrayCreation createPTArrayCreation(String type, List dimensions, PTArrayInitializer initializer) {
-		PTArrayCreation a = createPTArrayCreation();
-		a.setType(type);
-		if (dimensions != null)
-			a.getDimensions().addAll(dimensions);
-		a.setInitializer(initializer);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTArrayInitializer(java.util.List)
-	 */
-	public PTArrayInitializer createPTArrayInitializer(List expressions) {
-		PTArrayInitializer a = createPTArrayInitializer();
-		if (expressions != null)
-			a.getExpressions().addAll(expressions);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTBooleanLiteral(boolean)
-	 */
-	public PTBooleanLiteral createPTBooleanLiteral(boolean booleanValue) {
-		PTBooleanLiteral a = createPTBooleanLiteral();
-		a.setBooleanValue(booleanValue);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTCastExpression(java.lang.String, org.eclipse.jem.internal.instantiation.PTExpression)
-	 */
-	public PTCastExpression createPTCastExpression(String type, PTExpression expression) {
-		PTCastExpression a = createPTCastExpression();
-		a.setType(type);
-		a.setExpression(expression);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTCharacterLiteral(java.lang.String)
-	 */
-	public PTCharacterLiteral createPTCharacterLiteral(String escapedValue) {
-		PTCharacterLiteral a = createPTCharacterLiteral();
-		a.setEscapedValue(escapedValue);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTClassInstanceCreation(java.lang.String, java.util.List)
-	 */
-	public PTClassInstanceCreation createPTClassInstanceCreation(String type, List arguments) {
-		PTClassInstanceCreation a = createPTClassInstanceCreation();
-		a.setType(type);
-		if (arguments != null)
-			a.getArguments().addAll(arguments);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTConditionalExpression(org.eclipse.jem.internal.instantiation.PTExpression, org.eclipse.jem.internal.instantiation.PTExpression, org.eclipse.jem.internal.instantiation.PTExpression)
-	 */
-	public PTConditionalExpression createPTConditionalExpression(
-		PTExpression condition,
-		PTExpression trueExpressoin,
-		PTExpression falseExpression) {
-		PTConditionalExpression a = createPTConditionalExpression();
-		a.setCondition(condition);
-		a.setTrue(trueExpressoin);
-		a.setFalse(falseExpression);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTFieldAccess(org.eclipse.jem.internal.instantiation.PTExpression, java.lang.String)
-	 */
-	public PTFieldAccess createPTFieldAccess(PTExpression receiver, String field) {
-		PTFieldAccess a = createPTFieldAccess();
-		a.setReceiver(receiver);
-		a.setField(field);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTInfixExpression(org.eclipse.jem.internal.instantiation.PTExpression, org.eclipse.jem.internal.instantiation.PTInfixOperator, org.eclipse.jem.internal.instantiation.PTExpression, java.util.List)
-	 */
-	public PTInfixExpression createPTInfixExpression(
-		PTExpression leftOperand,
-		PTInfixOperator operator,
-		PTExpression rightOperand,
-		List extendedOperands) {
-		PTInfixExpression a = createPTInfixExpression();
-		a.setLeftOperand(leftOperand);
-		a.setOperator(operator);
-		a.setRightOperand(rightOperand);
-		if (extendedOperands != null)
-			a.getExtendedOperands().addAll(extendedOperands);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTInstanceof(org.eclipse.jem.internal.instantiation.PTExpression, java.lang.String)
-	 */
-	public PTInstanceof createPTInstanceof(PTExpression operand, String type) {
-		PTInstanceof a = createPTInstanceof();
-		a.setOperand(operand);
-		a.setType(type);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTInvalidExpression(java.lang.String)
-	 */
-	public PTInvalidExpression createPTInvalidExpression(String message) {
-		PTInvalidExpression a = createPTInvalidExpression();
-		a.setMessage(message);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTMethodInvocation(org.eclipse.jem.internal.instantiation.PTExpression, java.lang.String, java.util.List)
-	 */
-	public PTMethodInvocation createPTMethodInvocation(PTExpression receiver, String name, List arguments) {
-		PTMethodInvocation a = createPTMethodInvocation();
-		a.setReceiver(receiver);
-		a.setName(name);
-		if (arguments != null)
-			a.getArguments().addAll(arguments);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTName(java.lang.String)
-	 */
-	public PTName createPTName(String name) {
-		PTName a = createPTName();
-		a.setName(name);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTNumberLiteral(java.lang.String)
-	 */
-	public PTNumberLiteral createPTNumberLiteral(String token) {
-		PTNumberLiteral a = createPTNumberLiteral();
-		a.setToken(token);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTParenthesizedExpression(org.eclipse.jem.internal.instantiation.PTExpression)
-	 */
-	public PTParenthesizedExpression createPTParenthesizedExpression(PTExpression expression) {
-		PTParenthesizedExpression a = createPTParenthesizedExpression();
-		a.setExpression(expression);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTPrefixExpression(org.eclipse.jem.internal.instantiation.PTPrefixOperator, org.eclipse.jem.internal.instantiation.PTExpression)
-	 */
-	public PTPrefixExpression createPTPrefixExpression(PTPrefixOperator operator, PTExpression expression) {
-		PTPrefixExpression a = createPTPrefixExpression();
-		a.setOperator(operator);
-		a.setExpression(expression);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTStringLiteral(java.lang.String)
-	 */
-	public PTStringLiteral createPTStringLiteral(String escapeLiteral) {
-		PTStringLiteral a = createPTStringLiteral();
-		a.setEscapedValue(escapeLiteral);
-		return a;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationFactory#createPTTypeLiteral(java.lang.String)
-	 */
-	public PTTypeLiteral createPTTypeLiteral(String type) {
-		PTTypeLiteral a = createPTTypeLiteral();
-		a.setType(type);
-		return a;
-	}
-
-} //InstantiationFactoryImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationImplMessages.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationImplMessages.java
deleted file mode 100644
index 8debe1f..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationImplMessages.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-
-import org.eclipse.osgi.util.NLS;
-
-public final class InstantiationImplMessages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jem.internal.instantiation.impl.messages";//$NON-NLS-1$
-
-	private InstantiationImplMessages() {
-		// Do not instantiate
-	}
-
-	public static String NaiveExpressionFlattener_InvalidExpression;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, InstantiationImplMessages.class);
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationPackageImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationPackageImpl.java
deleted file mode 100644
index 3a385ba..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/InstantiationPackageImpl.java
+++ /dev/null
@@ -1,1392 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: InstantiationPackageImpl.java,v $
- *  $Revision: 1.13 $  $Date: 2005/10/28 22:56:46 $ 
- */
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EcorePackage;
-
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-
-import org.eclipse.emf.ecore.impl.EcorePackageImpl;
-
-import org.eclipse.jem.internal.instantiation.PTArrayAccess;
-import org.eclipse.jem.internal.instantiation.PTArrayCreation;
-import org.eclipse.jem.internal.instantiation.PTArrayInitializer;
-import org.eclipse.jem.internal.instantiation.PTBooleanLiteral;
-import org.eclipse.jem.internal.instantiation.PTCastExpression;
-import org.eclipse.jem.internal.instantiation.PTCharacterLiteral;
-import org.eclipse.jem.internal.instantiation.PTClassInstanceCreation;
-import org.eclipse.jem.internal.instantiation.PTConditionalExpression;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.PTFieldAccess;
-import org.eclipse.jem.internal.instantiation.ImplicitAllocation;
-import org.eclipse.jem.internal.instantiation.PTInfixExpression;
-import org.eclipse.jem.internal.instantiation.PTInfixOperator;
-import org.eclipse.jem.internal.instantiation.PTInstanceReference;
-import org.eclipse.jem.internal.instantiation.InitStringAllocation;
-import org.eclipse.jem.internal.instantiation.PTInstanceof;
-import org.eclipse.jem.internal.instantiation.InstantiationFactory;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTInvalidExpression;
-import org.eclipse.jem.internal.instantiation.JavaAllocation;
-
-import org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration;
-import org.eclipse.jem.internal.instantiation.PTMethodInvocation;
-import org.eclipse.jem.internal.instantiation.PTName;
-import org.eclipse.jem.internal.instantiation.PTNullLiteral;
-import org.eclipse.jem.internal.instantiation.PTNumberLiteral;
-import org.eclipse.jem.internal.instantiation.PTParenthesizedExpression;
-import org.eclipse.jem.internal.instantiation.ParseTreeAllocation;
-
-import org.eclipse.jem.internal.instantiation.PTPrefixExpression;
-import org.eclipse.jem.internal.instantiation.PTPrefixOperator;
-import org.eclipse.jem.internal.instantiation.PTStringLiteral;
-import org.eclipse.jem.internal.instantiation.PTThisLiteral;
-import org.eclipse.jem.internal.instantiation.PTTypeLiteral;
-
-import org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance;
-import org.eclipse.jem.internal.instantiation.base.IJavaInstance;
-import org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-public class InstantiationPackageImpl extends EPackageImpl implements InstantiationPackage {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass iJavaDataTypeInstanceEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass iJavaObjectInstanceEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass javaAllocationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass initStringAllocationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass implicitAllocationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass parseTreeAllocationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptArrayAccessEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptArrayCreationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptArrayInitializerEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptBooleanLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptCastExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptCharacterLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptClassInstanceCreationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptConditionalExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptFieldAccessEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptInfixExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptInstanceofEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptMethodInvocationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptNameEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptNullLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptNumberLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptParenthesizedExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptPrefixExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptStringLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptThisLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptTypeLiteralEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptInvalidExpressionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptInstanceReferenceEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ptAnonymousClassDeclarationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EEnum ptInfixOperatorEEnum = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EEnum ptPrefixOperatorEEnum = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass iJavaInstanceEClass = null;
-
-	/**
-	 * Creates an instance of the model <b>Package</b>, registered with
-	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-	 * package URI value.
-	 * <p>Note: the correct way to create the package is via the static
-	 * factory method {@link #init init()}, which also performs
-	 * initialization of the package, or returns the registered package,
-	 * if one already exists.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.emf.ecore.EPackage.Registry
-	 * @see org.eclipse.jem.internal.instantiation.InstantiationPackage#eNS_URI
-	 * @see #init()
-	 * @generated
-	 */
-	private InstantiationPackageImpl() {
-		super(eNS_URI, InstantiationFactory.eINSTANCE);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static boolean isInited = false;
-
-	/**
-	 * Creates, registers, and initializes the <b>Package</b> for this
-	 * model, and for any others upon which it depends.  Simple
-	 * dependencies are satisfied by calling this method on all
-	 * dependent packages before doing anything else.  This method drives
-	 * initialization for interdependent packages directly, in parallel
-	 * with this package, itself.
-	 * <p>Of this package and its interdependencies, all packages which
-	 * have not yet been registered by their URI values are first created
-	 * and registered.  The packages are then initialized in two steps:
-	 * meta-model objects for all of the packages are created before any
-	 * are initialized, since one package's meta-model objects may refer to
-	 * those of another.
-	 * <p>Invocation of this method will not affect any packages that have
-	 * already been initialized.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #eNS_URI
-	 * @see #createPackageContents()
-	 * @see #initializePackageContents()
-	 * @generated
-	 */
-	public static InstantiationPackage init() {
-		if (isInited) return (InstantiationPackage)EPackage.Registry.INSTANCE.getEPackage(InstantiationPackage.eNS_URI);
-
-		// Obtain or create and register package
-		InstantiationPackageImpl theInstantiationPackage = (InstantiationPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof InstantiationPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new InstantiationPackageImpl());
-
-		isInited = true;
-
-		// Initialize simple dependencies
-		EcorePackageImpl.init();
-
-		// Create package meta-data objects
-		theInstantiationPackage.createPackageContents();
-
-		// Initialize created meta-data
-		theInstantiationPackage.initializePackageContents();
-
-		// Mark meta-data to indicate it can't be changed
-		theInstantiationPackage.freeze();
-
-		return theInstantiationPackage;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIJavaObjectInstance() {
-		return iJavaObjectInstanceEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getJavaAllocation() {
-		return javaAllocationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getInitStringAllocation() {
-		return initStringAllocationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getInitStringAllocation_InitString() {
-		return (EAttribute)initStringAllocationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getImplicitAllocation() {
-		return implicitAllocationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getImplicitAllocation_Parent() {
-		return (EReference)implicitAllocationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getImplicitAllocation_Feature() {
-		return (EReference)implicitAllocationEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getParseTreeAllocation() {
-		return parseTreeAllocationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getParseTreeAllocation_Expression() {
-		return (EReference)parseTreeAllocationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTExpression() {
-		return ptExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTArrayAccess() {
-		return ptArrayAccessEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTArrayAccess_Array() {
-		return (EReference)ptArrayAccessEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTArrayAccess_Indexes() {
-		return (EReference)ptArrayAccessEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTArrayCreation() {
-		return ptArrayCreationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTArrayCreation_Type() {
-		return (EAttribute)ptArrayCreationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTArrayCreation_Dimensions() {
-		return (EReference)ptArrayCreationEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTArrayCreation_Initializer() {
-		return (EReference)ptArrayCreationEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTArrayInitializer() {
-		return ptArrayInitializerEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTArrayInitializer_Expressions() {
-		return (EReference)ptArrayInitializerEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTBooleanLiteral() {
-		return ptBooleanLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTBooleanLiteral_BooleanValue() {
-		return (EAttribute)ptBooleanLiteralEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTCastExpression() {
-		return ptCastExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTCastExpression_Type() {
-		return (EAttribute)ptCastExpressionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTCastExpression_Expression() {
-		return (EReference)ptCastExpressionEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTCharacterLiteral() {
-		return ptCharacterLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTCharacterLiteral_EscapedValue() {
-		return (EAttribute)ptCharacterLiteralEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTCharacterLiteral_CharValue() {
-		return (EAttribute)ptCharacterLiteralEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTClassInstanceCreation() {
-		return ptClassInstanceCreationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTClassInstanceCreation_Type() {
-		return (EAttribute)ptClassInstanceCreationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTClassInstanceCreation_Arguments() {
-		return (EReference)ptClassInstanceCreationEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTConditionalExpression() {
-		return ptConditionalExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTConditionalExpression_Condition() {
-		return (EReference)ptConditionalExpressionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTConditionalExpression_True() {
-		return (EReference)ptConditionalExpressionEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTConditionalExpression_False() {
-		return (EReference)ptConditionalExpressionEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTFieldAccess() {
-		return ptFieldAccessEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTFieldAccess_Receiver() {
-		return (EReference)ptFieldAccessEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTFieldAccess_Field() {
-		return (EAttribute)ptFieldAccessEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTInfixExpression() {
-		return ptInfixExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTInfixExpression_LeftOperand() {
-		return (EReference)ptInfixExpressionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTInfixExpression_Operator() {
-		return (EAttribute)ptInfixExpressionEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTInfixExpression_RightOperand() {
-		return (EReference)ptInfixExpressionEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTInfixExpression_ExtendedOperands() {
-		return (EReference)ptInfixExpressionEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTInstanceof() {
-		return ptInstanceofEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTInstanceof_Operand() {
-		return (EReference)ptInstanceofEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTInstanceof_Type() {
-		return (EAttribute)ptInstanceofEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTMethodInvocation() {
-		return ptMethodInvocationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTMethodInvocation_Receiver() {
-		return (EReference)ptMethodInvocationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTMethodInvocation_Name() {
-		return (EAttribute)ptMethodInvocationEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTMethodInvocation_Arguments() {
-		return (EReference)ptMethodInvocationEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTName() {
-		return ptNameEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTName_Name() {
-		return (EAttribute)ptNameEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTNullLiteral() {
-		return ptNullLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTNumberLiteral() {
-		return ptNumberLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTNumberLiteral_Token() {
-		return (EAttribute)ptNumberLiteralEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTParenthesizedExpression() {
-		return ptParenthesizedExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTParenthesizedExpression_Expression() {
-		return (EReference)ptParenthesizedExpressionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTPrefixExpression() {
-		return ptPrefixExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTPrefixExpression_Operator() {
-		return (EAttribute)ptPrefixExpressionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTPrefixExpression_Expression() {
-		return (EReference)ptPrefixExpressionEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTStringLiteral() {
-		return ptStringLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTStringLiteral_EscapedValue() {
-		return (EAttribute)ptStringLiteralEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTStringLiteral_LiteralValue() {
-		return (EAttribute)ptStringLiteralEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTThisLiteral() {
-		return ptThisLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTTypeLiteral() {
-		return ptTypeLiteralEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTTypeLiteral_Type() {
-		return (EAttribute)ptTypeLiteralEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTInvalidExpression() {
-		return ptInvalidExpressionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTInvalidExpression_Message() {
-		return (EAttribute)ptInvalidExpressionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTInstanceReference() {
-		return ptInstanceReferenceEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPTInstanceReference_Reference() {
-		return (EReference)ptInstanceReferenceEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPTAnonymousClassDeclaration() {
-		return ptAnonymousClassDeclarationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTAnonymousClassDeclaration_Declaration() {
-		return (EAttribute)ptAnonymousClassDeclarationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPTAnonymousClassDeclaration_Imports() {
-		return (EAttribute)ptAnonymousClassDeclarationEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EEnum getPTInfixOperator() {
-		return ptInfixOperatorEEnum;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EEnum getPTPrefixOperator() {
-		return ptPrefixOperatorEEnum;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIJavaDataTypeInstance() {
-		return iJavaDataTypeInstanceEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIJavaInstance() {
-		return iJavaInstanceEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public InstantiationFactory getInstantiationFactory() {
-		return (InstantiationFactory)getEFactoryInstance();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isCreated = false;
-
-	/**
-	 * Creates the meta-model objects for the package.  This method is
-	 * guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void createPackageContents() {
-		if (isCreated) return;
-		isCreated = true;
-
-		// Create classes and their features
-		iJavaDataTypeInstanceEClass = createEClass(IJAVA_DATA_TYPE_INSTANCE);
-
-		iJavaInstanceEClass = createEClass(IJAVA_INSTANCE);
-
-		iJavaObjectInstanceEClass = createEClass(IJAVA_OBJECT_INSTANCE);
-
-		javaAllocationEClass = createEClass(JAVA_ALLOCATION);
-
-		initStringAllocationEClass = createEClass(INIT_STRING_ALLOCATION);
-		createEAttribute(initStringAllocationEClass, INIT_STRING_ALLOCATION__INIT_STRING);
-
-		implicitAllocationEClass = createEClass(IMPLICIT_ALLOCATION);
-		createEReference(implicitAllocationEClass, IMPLICIT_ALLOCATION__PARENT);
-		createEReference(implicitAllocationEClass, IMPLICIT_ALLOCATION__FEATURE);
-
-		parseTreeAllocationEClass = createEClass(PARSE_TREE_ALLOCATION);
-		createEReference(parseTreeAllocationEClass, PARSE_TREE_ALLOCATION__EXPRESSION);
-
-		ptExpressionEClass = createEClass(PT_EXPRESSION);
-
-		ptArrayAccessEClass = createEClass(PT_ARRAY_ACCESS);
-		createEReference(ptArrayAccessEClass, PT_ARRAY_ACCESS__ARRAY);
-		createEReference(ptArrayAccessEClass, PT_ARRAY_ACCESS__INDEXES);
-
-		ptArrayCreationEClass = createEClass(PT_ARRAY_CREATION);
-		createEAttribute(ptArrayCreationEClass, PT_ARRAY_CREATION__TYPE);
-		createEReference(ptArrayCreationEClass, PT_ARRAY_CREATION__DIMENSIONS);
-		createEReference(ptArrayCreationEClass, PT_ARRAY_CREATION__INITIALIZER);
-
-		ptArrayInitializerEClass = createEClass(PT_ARRAY_INITIALIZER);
-		createEReference(ptArrayInitializerEClass, PT_ARRAY_INITIALIZER__EXPRESSIONS);
-
-		ptBooleanLiteralEClass = createEClass(PT_BOOLEAN_LITERAL);
-		createEAttribute(ptBooleanLiteralEClass, PT_BOOLEAN_LITERAL__BOOLEAN_VALUE);
-
-		ptCastExpressionEClass = createEClass(PT_CAST_EXPRESSION);
-		createEAttribute(ptCastExpressionEClass, PT_CAST_EXPRESSION__TYPE);
-		createEReference(ptCastExpressionEClass, PT_CAST_EXPRESSION__EXPRESSION);
-
-		ptCharacterLiteralEClass = createEClass(PT_CHARACTER_LITERAL);
-		createEAttribute(ptCharacterLiteralEClass, PT_CHARACTER_LITERAL__ESCAPED_VALUE);
-		createEAttribute(ptCharacterLiteralEClass, PT_CHARACTER_LITERAL__CHAR_VALUE);
-
-		ptClassInstanceCreationEClass = createEClass(PT_CLASS_INSTANCE_CREATION);
-		createEAttribute(ptClassInstanceCreationEClass, PT_CLASS_INSTANCE_CREATION__TYPE);
-		createEReference(ptClassInstanceCreationEClass, PT_CLASS_INSTANCE_CREATION__ARGUMENTS);
-
-		ptConditionalExpressionEClass = createEClass(PT_CONDITIONAL_EXPRESSION);
-		createEReference(ptConditionalExpressionEClass, PT_CONDITIONAL_EXPRESSION__CONDITION);
-		createEReference(ptConditionalExpressionEClass, PT_CONDITIONAL_EXPRESSION__TRUE);
-		createEReference(ptConditionalExpressionEClass, PT_CONDITIONAL_EXPRESSION__FALSE);
-
-		ptFieldAccessEClass = createEClass(PT_FIELD_ACCESS);
-		createEReference(ptFieldAccessEClass, PT_FIELD_ACCESS__RECEIVER);
-		createEAttribute(ptFieldAccessEClass, PT_FIELD_ACCESS__FIELD);
-
-		ptInfixExpressionEClass = createEClass(PT_INFIX_EXPRESSION);
-		createEReference(ptInfixExpressionEClass, PT_INFIX_EXPRESSION__LEFT_OPERAND);
-		createEAttribute(ptInfixExpressionEClass, PT_INFIX_EXPRESSION__OPERATOR);
-		createEReference(ptInfixExpressionEClass, PT_INFIX_EXPRESSION__RIGHT_OPERAND);
-		createEReference(ptInfixExpressionEClass, PT_INFIX_EXPRESSION__EXTENDED_OPERANDS);
-
-		ptInstanceofEClass = createEClass(PT_INSTANCEOF);
-		createEReference(ptInstanceofEClass, PT_INSTANCEOF__OPERAND);
-		createEAttribute(ptInstanceofEClass, PT_INSTANCEOF__TYPE);
-
-		ptMethodInvocationEClass = createEClass(PT_METHOD_INVOCATION);
-		createEReference(ptMethodInvocationEClass, PT_METHOD_INVOCATION__RECEIVER);
-		createEAttribute(ptMethodInvocationEClass, PT_METHOD_INVOCATION__NAME);
-		createEReference(ptMethodInvocationEClass, PT_METHOD_INVOCATION__ARGUMENTS);
-
-		ptNameEClass = createEClass(PT_NAME);
-		createEAttribute(ptNameEClass, PT_NAME__NAME);
-
-		ptNullLiteralEClass = createEClass(PT_NULL_LITERAL);
-
-		ptNumberLiteralEClass = createEClass(PT_NUMBER_LITERAL);
-		createEAttribute(ptNumberLiteralEClass, PT_NUMBER_LITERAL__TOKEN);
-
-		ptParenthesizedExpressionEClass = createEClass(PT_PARENTHESIZED_EXPRESSION);
-		createEReference(ptParenthesizedExpressionEClass, PT_PARENTHESIZED_EXPRESSION__EXPRESSION);
-
-		ptPrefixExpressionEClass = createEClass(PT_PREFIX_EXPRESSION);
-		createEAttribute(ptPrefixExpressionEClass, PT_PREFIX_EXPRESSION__OPERATOR);
-		createEReference(ptPrefixExpressionEClass, PT_PREFIX_EXPRESSION__EXPRESSION);
-
-		ptStringLiteralEClass = createEClass(PT_STRING_LITERAL);
-		createEAttribute(ptStringLiteralEClass, PT_STRING_LITERAL__ESCAPED_VALUE);
-		createEAttribute(ptStringLiteralEClass, PT_STRING_LITERAL__LITERAL_VALUE);
-
-		ptThisLiteralEClass = createEClass(PT_THIS_LITERAL);
-
-		ptTypeLiteralEClass = createEClass(PT_TYPE_LITERAL);
-		createEAttribute(ptTypeLiteralEClass, PT_TYPE_LITERAL__TYPE);
-
-		ptInvalidExpressionEClass = createEClass(PT_INVALID_EXPRESSION);
-		createEAttribute(ptInvalidExpressionEClass, PT_INVALID_EXPRESSION__MESSAGE);
-
-		ptInstanceReferenceEClass = createEClass(PT_INSTANCE_REFERENCE);
-		createEReference(ptInstanceReferenceEClass, PT_INSTANCE_REFERENCE__REFERENCE);
-
-		ptAnonymousClassDeclarationEClass = createEClass(PT_ANONYMOUS_CLASS_DECLARATION);
-		createEAttribute(ptAnonymousClassDeclarationEClass, PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION);
-		createEAttribute(ptAnonymousClassDeclarationEClass, PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS);
-
-		// Create enums
-		ptInfixOperatorEEnum = createEEnum(PT_INFIX_OPERATOR);
-		ptPrefixOperatorEEnum = createEEnum(PT_PREFIX_OPERATOR);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isInitialized = false;
-
-	/**
-	 * Complete the initialization of the package and its meta-model.  This
-	 * method is guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void initializePackageContents() {
-		if (isInitialized) return;
-		isInitialized = true;
-
-		// Initialize package
-		setName(eNAME);
-		setNsPrefix(eNS_PREFIX);
-		setNsURI(eNS_URI);
-
-		// Obtain other dependent packages
-		EcorePackageImpl theEcorePackage = (EcorePackageImpl)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
-
-		// Add supertypes to classes
-		iJavaDataTypeInstanceEClass.getESuperTypes().add(this.getIJavaInstance());
-		iJavaObjectInstanceEClass.getESuperTypes().add(this.getIJavaInstance());
-		initStringAllocationEClass.getESuperTypes().add(this.getJavaAllocation());
-		implicitAllocationEClass.getESuperTypes().add(this.getJavaAllocation());
-		parseTreeAllocationEClass.getESuperTypes().add(this.getJavaAllocation());
-		ptArrayAccessEClass.getESuperTypes().add(this.getPTExpression());
-		ptArrayCreationEClass.getESuperTypes().add(this.getPTExpression());
-		ptArrayInitializerEClass.getESuperTypes().add(this.getPTExpression());
-		ptBooleanLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptCastExpressionEClass.getESuperTypes().add(this.getPTExpression());
-		ptCharacterLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptClassInstanceCreationEClass.getESuperTypes().add(this.getPTExpression());
-		ptConditionalExpressionEClass.getESuperTypes().add(this.getPTExpression());
-		ptFieldAccessEClass.getESuperTypes().add(this.getPTExpression());
-		ptInfixExpressionEClass.getESuperTypes().add(this.getPTExpression());
-		ptInstanceofEClass.getESuperTypes().add(this.getPTExpression());
-		ptMethodInvocationEClass.getESuperTypes().add(this.getPTExpression());
-		ptNameEClass.getESuperTypes().add(this.getPTExpression());
-		ptNullLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptNumberLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptParenthesizedExpressionEClass.getESuperTypes().add(this.getPTExpression());
-		ptPrefixExpressionEClass.getESuperTypes().add(this.getPTExpression());
-		ptStringLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptThisLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptTypeLiteralEClass.getESuperTypes().add(this.getPTExpression());
-		ptInvalidExpressionEClass.getESuperTypes().add(this.getPTExpression());
-		ptInstanceReferenceEClass.getESuperTypes().add(this.getPTExpression());
-		ptAnonymousClassDeclarationEClass.getESuperTypes().add(this.getPTExpression());
-
-		// Initialize classes and features; add operations and parameters
-		initEClass(iJavaDataTypeInstanceEClass, IJavaDataTypeInstance.class, "IJavaDataTypeInstance", IS_ABSTRACT, IS_INTERFACE, !IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(iJavaInstanceEClass, IJavaInstance.class, "IJavaInstance", IS_ABSTRACT, IS_INTERFACE, !IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(iJavaObjectInstanceEClass, IJavaObjectInstance.class, "IJavaObjectInstance", IS_ABSTRACT, IS_INTERFACE, !IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(javaAllocationEClass, JavaAllocation.class, "JavaAllocation", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(initStringAllocationEClass, InitStringAllocation.class, "InitStringAllocation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getInitStringAllocation_InitString(), ecorePackage.getEString(), "initString", null, 0, 1, InitStringAllocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(implicitAllocationEClass, ImplicitAllocation.class, "ImplicitAllocation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getImplicitAllocation_Parent(), theEcorePackage.getEObject(), null, "parent", null, 1, 1, ImplicitAllocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getImplicitAllocation_Feature(), theEcorePackage.getEStructuralFeature(), null, "feature", null, 1, 1, ImplicitAllocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(parseTreeAllocationEClass, ParseTreeAllocation.class, "ParseTreeAllocation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getParseTreeAllocation_Expression(), this.getPTExpression(), null, "expression", null, 1, 1, ParseTreeAllocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptExpressionEClass, PTExpression.class, "PTExpression", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(ptArrayAccessEClass, PTArrayAccess.class, "PTArrayAccess", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTArrayAccess_Array(), this.getPTExpression(), null, "array", null, 0, 1, PTArrayAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTArrayAccess_Indexes(), this.getPTExpression(), null, "indexes", null, 1, -1, PTArrayAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptArrayCreationEClass, PTArrayCreation.class, "PTArrayCreation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTArrayCreation_Type(), ecorePackage.getEString(), "type", null, 0, 1, PTArrayCreation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTArrayCreation_Dimensions(), this.getPTExpression(), null, "dimensions", null, 0, -1, PTArrayCreation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTArrayCreation_Initializer(), this.getPTArrayInitializer(), null, "initializer", null, 0, 1, PTArrayCreation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptArrayInitializerEClass, PTArrayInitializer.class, "PTArrayInitializer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTArrayInitializer_Expressions(), this.getPTExpression(), null, "expressions", null, 0, -1, PTArrayInitializer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptBooleanLiteralEClass, PTBooleanLiteral.class, "PTBooleanLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTBooleanLiteral_BooleanValue(), ecorePackage.getEBoolean(), "booleanValue", null, 0, 1, PTBooleanLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptCastExpressionEClass, PTCastExpression.class, "PTCastExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTCastExpression_Type(), ecorePackage.getEString(), "type", null, 0, 1, PTCastExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTCastExpression_Expression(), this.getPTExpression(), null, "expression", null, 0, 1, PTCastExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptCharacterLiteralEClass, PTCharacterLiteral.class, "PTCharacterLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTCharacterLiteral_EscapedValue(), ecorePackage.getEString(), "escapedValue", null, 0, 1, PTCharacterLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTCharacterLiteral_CharValue(), ecorePackage.getEChar(), "charValue", null, 0, 1, PTCharacterLiteral.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptClassInstanceCreationEClass, PTClassInstanceCreation.class, "PTClassInstanceCreation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTClassInstanceCreation_Type(), ecorePackage.getEString(), "type", null, 0, 1, PTClassInstanceCreation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTClassInstanceCreation_Arguments(), this.getPTExpression(), null, "arguments", null, 0, -1, PTClassInstanceCreation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptConditionalExpressionEClass, PTConditionalExpression.class, "PTConditionalExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTConditionalExpression_Condition(), this.getPTExpression(), null, "condition", null, 0, 1, PTConditionalExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTConditionalExpression_True(), this.getPTExpression(), null, "true", null, 0, 1, PTConditionalExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTConditionalExpression_False(), this.getPTExpression(), null, "false", null, 0, 1, PTConditionalExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptFieldAccessEClass, PTFieldAccess.class, "PTFieldAccess", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTFieldAccess_Receiver(), this.getPTExpression(), null, "receiver", null, 0, 1, PTFieldAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTFieldAccess_Field(), ecorePackage.getEString(), "field", null, 0, 1, PTFieldAccess.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptInfixExpressionEClass, PTInfixExpression.class, "PTInfixExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTInfixExpression_LeftOperand(), this.getPTExpression(), null, "leftOperand", null, 0, 1, PTInfixExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTInfixExpression_Operator(), this.getPTInfixOperator(), "operator", null, 0, 1, PTInfixExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTInfixExpression_RightOperand(), this.getPTExpression(), null, "rightOperand", null, 0, 1, PTInfixExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTInfixExpression_ExtendedOperands(), this.getPTExpression(), null, "extendedOperands", null, 0, -1, PTInfixExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptInstanceofEClass, PTInstanceof.class, "PTInstanceof", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTInstanceof_Operand(), this.getPTExpression(), null, "operand", null, 0, 1, PTInstanceof.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTInstanceof_Type(), ecorePackage.getEString(), "type", null, 0, 1, PTInstanceof.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptMethodInvocationEClass, PTMethodInvocation.class, "PTMethodInvocation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTMethodInvocation_Receiver(), this.getPTExpression(), null, "receiver", null, 0, 1, PTMethodInvocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTMethodInvocation_Name(), ecorePackage.getEString(), "name", null, 0, 1, PTMethodInvocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTMethodInvocation_Arguments(), this.getPTExpression(), null, "arguments", null, 0, -1, PTMethodInvocation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptNameEClass, PTName.class, "PTName", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTName_Name(), ecorePackage.getEString(), "name", null, 0, 1, PTName.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptNullLiteralEClass, PTNullLiteral.class, "PTNullLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(ptNumberLiteralEClass, PTNumberLiteral.class, "PTNumberLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTNumberLiteral_Token(), ecorePackage.getEString(), "token", null, 0, 1, PTNumberLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptParenthesizedExpressionEClass, PTParenthesizedExpression.class, "PTParenthesizedExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTParenthesizedExpression_Expression(), this.getPTExpression(), null, "expression", null, 0, 1, PTParenthesizedExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptPrefixExpressionEClass, PTPrefixExpression.class, "PTPrefixExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTPrefixExpression_Operator(), this.getPTPrefixOperator(), "operator", null, 0, 1, PTPrefixExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPTPrefixExpression_Expression(), this.getPTExpression(), null, "expression", null, 0, 1, PTPrefixExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptStringLiteralEClass, PTStringLiteral.class, "PTStringLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTStringLiteral_EscapedValue(), ecorePackage.getEString(), "escapedValue", null, 0, 1, PTStringLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTStringLiteral_LiteralValue(), ecorePackage.getEString(), "literalValue", null, 0, 1, PTStringLiteral.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptThisLiteralEClass, PTThisLiteral.class, "PTThisLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(ptTypeLiteralEClass, PTTypeLiteral.class, "PTTypeLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTTypeLiteral_Type(), ecorePackage.getEString(), "type", null, 0, 1, PTTypeLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptInvalidExpressionEClass, PTInvalidExpression.class, "PTInvalidExpression", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTInvalidExpression_Message(), ecorePackage.getEString(), "message", null, 0, 1, PTInvalidExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptInstanceReferenceEClass, PTInstanceReference.class, "PTInstanceReference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPTInstanceReference_Reference(), this.getIJavaInstance(), null, "reference", null, 1, 1, PTInstanceReference.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ptAnonymousClassDeclarationEClass, PTAnonymousClassDeclaration.class, "PTAnonymousClassDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPTAnonymousClassDeclaration_Declaration(), ecorePackage.getEString(), "declaration", null, 0, 1, PTAnonymousClassDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPTAnonymousClassDeclaration_Imports(), ecorePackage.getEString(), "imports", null, 0, -1, PTAnonymousClassDeclaration.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		// Initialize enums and add enum literals
-		initEEnum(ptInfixOperatorEEnum, PTInfixOperator.class, "PTInfixOperator");
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.TIMES_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.DIVIDE_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.REMAINDER_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.PLUS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.MINUS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.LEFT_SHIFT_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.RIGHT_SHIFT_SIGNED_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.RIGHT_SHIFT_UNSIGNED_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.LESS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.GREATER_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.LESS_EQUALS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.GREATER_EQUALS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.EQUALS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.NOT_EQUALS_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.XOR_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.AND_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.OR_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.CONDITIONAL_AND_LITERAL);
-		addEEnumLiteral(ptInfixOperatorEEnum, PTInfixOperator.CONDITIONAL_OR_LITERAL);
-
-		initEEnum(ptPrefixOperatorEEnum, PTPrefixOperator.class, "PTPrefixOperator");
-		addEEnumLiteral(ptPrefixOperatorEEnum, PTPrefixOperator.PLUS_LITERAL);
-		addEEnumLiteral(ptPrefixOperatorEEnum, PTPrefixOperator.MINUS_LITERAL);
-		addEEnumLiteral(ptPrefixOperatorEEnum, PTPrefixOperator.COMPLEMENT_LITERAL);
-		addEEnumLiteral(ptPrefixOperatorEEnum, PTPrefixOperator.NOT_LITERAL);
-
-		// Create resource
-		createResource(eNS_URI);
-	}
-
-} //InstantiationPackageImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/JavaAllocationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/JavaAllocationImpl.java
deleted file mode 100644
index 828d460..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/JavaAllocationImpl.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: JavaAllocationImpl.java,v $
- *  $Revision: 1.7 $  $Date: 2005/10/03 19:20:41 $ 
- */
- 
-
-import org.eclipse.emf.ecore.EClass;
-
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.JavaAllocation;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Java Allocation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public abstract class JavaAllocationImpl extends EObjectImpl implements JavaAllocation {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected JavaAllocationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getJavaAllocation();
-	}
-	
-	public boolean isParseTree() {
-		return false;
-	}
-
-	public boolean isImplicit() {
-		return false;
-	}
-
-} //JavaAllocationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/NaiveExpressionFlattener.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/NaiveExpressionFlattener.java
deleted file mode 100644
index 3b6ecb5..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/NaiveExpressionFlattener.java
+++ /dev/null
@@ -1,331 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: NaiveExpressionFlattener.java,v $
- *  $Revision: 1.10 $  $Date: 2005/10/28 22:56:46 $ 
- */
-package org.eclipse.jem.internal.instantiation.impl;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-import org.eclipse.jem.internal.instantiation.*;
- 
-/**
- * This naively flattens the ParseTree. It just works with what's there.
- * 
- * @since 1.0.0
- */
-public class NaiveExpressionFlattener extends ParseVisitor {
-	
-	private StringBuffer buffer = new StringBuffer(100);
-	
-	protected final StringBuffer getStringBuffer() {
-		return buffer;
-	}
-	
-	/**
-	 * Return the string result of the flattening.
-	 * @return The flattened string.
-	 * 
-	 * @since 1.0.0
-	 */
-	public String getResult() {
-		return buffer.toString();
-	}
-	
-	/**
-	 * Reset the result so that flattener can be used again.
-	 * 
-	 * @since 1.0.0
-	 */
-	public void reset() {
-		buffer.setLength(0);
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration)
-	 */
-	public boolean visit(PTAnonymousClassDeclaration node) {
-		buffer.append(node.getDeclaration());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTArrayAccess)
-	 */
-	public boolean visit(PTArrayAccess node) {
-		node.getArray().accept(this);
-		if (!node.getIndexes().isEmpty()) {
-			List indexes = node.getIndexes();
-			for (int i = 0; i < indexes.size(); i++) {
-				buffer.append('[');
-				((PTExpression) indexes.get(i)).accept(this);
-				buffer.append(']');
-			}
-		}
-		return false;
-		
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTArrayCreation)
-	 */
-	public boolean visit(PTArrayCreation node) {
-		String type = handleQualifiedName(node.getType());
-		buffer.append("new "); //$NON-NLS-1$
-		int ob = type.indexOf('[');
-		buffer.append(type.substring(0, ob));
-		int realdims = 0;
-		while (ob != -1) {
-			realdims++;
-			ob = type.indexOf('[',ob+1);
-		}
-		List dims = node.getDimensions();
-		for (int i = 0; i < dims.size(); i++) {
-			buffer.append('[');
-			((PTExpression) dims.get(i)).accept(this);
-			buffer.append(']');
-		}
-		for (int i=dims.size(); i < realdims; i++) {
-			buffer.append("[]"); //$NON-NLS-1$
-		}
-		
-		if (node.getInitializer() != null) {
-			buffer.append(' ');
-			((PTExpression) node.getInitializer()).accept(this);
-		}
-		
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTArrayInitializer)
-	 */
-	public boolean visit(PTArrayInitializer node) {
-		buffer.append('{');
-		List exp = node.getExpressions();
-		for (int i = 0; i < exp.size(); i++) {
-			if (i != 0)
-				buffer.append(", "); //$NON-NLS-1$
-			((PTExpression) exp.get(i)).accept(this);
-		}
-		buffer.append('}');
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTBooleanLiteral)
-	 */
-	public boolean visit(PTBooleanLiteral node) {
-		buffer.append(node.isBooleanValue() ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTCastExpression)
-	 */
-	public boolean visit(PTCastExpression node) {
-		buffer.append('(');
-		buffer.append(handleQualifiedName(node.getType()));
-		buffer.append(") "); //$NON-NLS-1$
-		node.getExpression().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTCharacterLiteral)
-	 */
-	public boolean visit(PTCharacterLiteral node) {
-		buffer.append(node.getEscapedValue());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTClassInstanceCreation)
-	 */
-	public boolean visit(PTClassInstanceCreation node) {
-		buffer.append("new "); //$NON-NLS-1$
-		buffer.append(handleQualifiedName(node.getType()));
-		buffer.append('(');
-		List args = node.getArguments();
-		for (int i = 0; i < args.size(); i++) {
-			if (i != 0)
-				buffer.append(", "); //$NON-NLS-1$
-			((PTExpression) args.get(i)).accept(this);
-		}
-		buffer.append(')');
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTConditionalExpression)
-	 */
-	public boolean visit(PTConditionalExpression node) {
-		node.getCondition().accept(this);
-		buffer.append(" ? "); //$NON-NLS-1$
-		node.getTrue().accept(this);
-		buffer.append(" : "); //$NON-NLS-1$
-		node.getFalse().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTFieldAccess)
-	 */
-	public boolean visit(PTFieldAccess node) {
-		node.getReceiver().accept(this);
-		buffer.append('.');
-		buffer.append(node.getField());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTInfixExpression)
-	 */
-	public boolean visit(PTInfixExpression node) {
-		node.getLeftOperand().accept(this);
-		buffer.append(' ');
-		String oper = node.getOperator().getOperator();
-		buffer.append(oper);
-		buffer.append(' ');
-		node.getRightOperand().accept(this);
-		List ext = node.getExtendedOperands();
-		for (int i = 0; i < ext.size(); i++) {
-			buffer.append(' ');
-			buffer.append(oper);
-			buffer.append(' ');
-			((PTExpression) ext.get(i)).accept(this);
-		}
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTInstanceof)
-	 */
-	public boolean visit(PTInstanceof node) {
-		node.getOperand().accept(this);
-		buffer.append(" instanceof "); //$NON-NLS-1$
-		buffer.append(handleQualifiedName(node.getType()));
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTInvalidExpression)
-	 */
-	public boolean visit(PTInvalidExpression node) {
-		buffer.append(MessageFormat.format(InstantiationImplMessages.NaiveExpressionFlattener_InvalidExpression, new Object[]{node.getMessage()})); 
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTMethodInvocation)
-	 */
-	public boolean visit(PTMethodInvocation node) {
-		if (node.getReceiver() != null) {
-			node.getReceiver().accept(this);
-			buffer.append('.');
-		}
-		
-		buffer.append(node.getName());
-		buffer.append('(');
-		List args = node.getArguments();
-		for (int i = 0; i < args.size(); i++) {
-			if (i != 0)
-				buffer.append(", "); //$NON-NLS-1$
-			((PTExpression) args.get(i)).accept(this);
-		}
-		buffer.append(')');
-		return false;	
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTName)
-	 */
-	public boolean visit(PTName node) {
-		buffer.append(handleQualifiedName(node.getName()));
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTNullLiteral)
-	 */
-	public boolean visit(PTNullLiteral node) {
-		buffer.append("null"); //$NON-NLS-1$
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTNumberLiteral)
-	 */
-	public boolean visit(PTNumberLiteral node) {
-		buffer.append(node.getToken());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTParenthesizedExpression)
-	 */
-	public boolean visit(PTParenthesizedExpression node) {
-		buffer.append('(');
-		node.getExpression().accept(this);
-		buffer.append(')');
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTPrefixExpression)
-	 */
-	public boolean visit(PTPrefixExpression node) {
-		buffer.append(node.getOperator().getOperator());
-		node.getExpression().accept(this);
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTStringLiteral)
-	 */
-	public boolean visit(PTStringLiteral node) {
-		buffer.append(node.getEscapedValue());
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTThisLiteral)
-	 */
-	public boolean visit(PTThisLiteral node) {
-		buffer.append("this"); //$NON-NLS-1$
-		return false;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.ParseVisitor#visit(org.eclipse.jem.internal.instantiation.PTTypeLiteral)
-	 */
-	public boolean visit(PTTypeLiteral node) {
-		buffer.append(handleQualifiedName(node.getType()));
-		buffer.append(".class"); //$NON-NLS-1$
-		return false;
-	}
-	
-	/**
-	 * This method enables one to overide the handling of qualified names.
-	 * The default operation is to do nothing.
-	 * 
-	 * Overriders may choose to use short names, relying on import statement handling.
-	 * 
-	 * @param qName  
-	 * @return Name to use for the flattened result
-	 */
-	protected String handleQualifiedName(String qName) {
-		return qName;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTAnonymousClassDeclarationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTAnonymousClassDeclarationImpl.java
deleted file mode 100644
index 911d3fc..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTAnonymousClassDeclarationImpl.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTAnonymousClassDeclarationImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/10/28 22:56:46 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTAnonymousClassDeclaration;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>PT Anonymous Class Declaration</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTAnonymousClassDeclarationImpl#getDeclaration <em>Declaration</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTAnonymousClassDeclarationImpl#getImports <em>Imports</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTAnonymousClassDeclarationImpl extends PTExpressionImpl implements PTAnonymousClassDeclaration {
-	/**
-	 * The default value of the '{@link #getDeclaration() <em>Declaration</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDeclaration()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String DECLARATION_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getDeclaration() <em>Declaration</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDeclaration()
-	 * @generated
-	 * @ordered
-	 */
-	protected String declaration = DECLARATION_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getImports() <em>Imports</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getImports()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList imports = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTAnonymousClassDeclarationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTAnonymousClassDeclaration();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getDeclaration() {
-		return declaration;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDeclaration(String newDeclaration) {
-		String oldDeclaration = declaration;
-		declaration = newDeclaration;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION, oldDeclaration, declaration));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getImports() {
-		if (imports == null) {
-			imports = new EDataTypeUniqueEList(String.class, this, InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS);
-		}
-		return imports;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION:
-				return getDeclaration();
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS:
-				return getImports();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION:
-				setDeclaration((String)newValue);
-				return;
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS:
-				getImports().clear();
-				getImports().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION:
-				setDeclaration(DECLARATION_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS:
-				getImports().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__DECLARATION:
-				return DECLARATION_EDEFAULT == null ? declaration != null : !DECLARATION_EDEFAULT.equals(declaration);
-			case InstantiationPackage.PT_ANONYMOUS_CLASS_DECLARATION__IMPORTS:
-				return imports != null && !imports.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (declaration: ");
-		result.append(declaration);
-		result.append(", imports: ");
-		result.append(imports);
-		result.append(')');
-		return result.toString();
-	}
-
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-
-} //PTAnonymousClassDeclarationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayAccessImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayAccessImpl.java
deleted file mode 100644
index 21be599..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayAccessImpl.java
+++ /dev/null
@@ -1,244 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTArrayAccessImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTArrayAccess;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Array Access</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTArrayAccessImpl#getArray <em>Array</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTArrayAccessImpl#getIndexes <em>Indexes</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTArrayAccessImpl extends PTExpressionImpl implements PTArrayAccess {
-	/**
-	 * The cached value of the '{@link #getArray() <em>Array</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getArray()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression array = null;
-
-	/**
-	 * The cached value of the '{@link #getIndexes() <em>Indexes</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIndexes()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList indexes = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTArrayAccessImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTArrayAccess();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getArray() {
-		return array;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetArray(PTExpression newArray, NotificationChain msgs) {
-		PTExpression oldArray = array;
-		array = newArray;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_ARRAY_ACCESS__ARRAY, oldArray, newArray);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setArray(PTExpression newArray) {
-		if (newArray != array) {
-			NotificationChain msgs = null;
-			if (array != null)
-				msgs = ((InternalEObject)array).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_ARRAY_ACCESS__ARRAY, null, msgs);
-			if (newArray != null)
-				msgs = ((InternalEObject)newArray).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_ARRAY_ACCESS__ARRAY, null, msgs);
-			msgs = basicSetArray(newArray, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_ARRAY_ACCESS__ARRAY, newArray, newArray));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIndexes() {
-		if (indexes == null) {
-			indexes = new EObjectContainmentEList(PTExpression.class, this, InstantiationPackage.PT_ARRAY_ACCESS__INDEXES);
-		}
-		return indexes;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_ARRAY_ACCESS__ARRAY:
-					return basicSetArray(null, msgs);
-				case InstantiationPackage.PT_ARRAY_ACCESS__INDEXES:
-					return ((InternalEList)getIndexes()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_ACCESS__ARRAY:
-				return getArray();
-			case InstantiationPackage.PT_ARRAY_ACCESS__INDEXES:
-				return getIndexes();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_ACCESS__ARRAY:
-				setArray((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_ARRAY_ACCESS__INDEXES:
-				getIndexes().clear();
-				getIndexes().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_ACCESS__ARRAY:
-				setArray((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_ARRAY_ACCESS__INDEXES:
-				getIndexes().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_ACCESS__ARRAY:
-				return array != null;
-			case InstantiationPackage.PT_ARRAY_ACCESS__INDEXES:
-				return indexes != null && !indexes.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getArray());
-			if (indexes != null)
-				acceptChildren(visitor, indexes);
-		}
-		visitor.endVisit(this);
-	}	
-
-} //ArrayAccessImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayCreationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayCreationImpl.java
deleted file mode 100644
index 34011e6..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayCreationImpl.java
+++ /dev/null
@@ -1,299 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTArrayCreationImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTArrayCreation;
-import org.eclipse.jem.internal.instantiation.PTArrayInitializer;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Array Creation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTArrayCreationImpl#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTArrayCreationImpl#getDimensions <em>Dimensions</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTArrayCreationImpl#getInitializer <em>Initializer</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTArrayCreationImpl extends PTExpressionImpl implements PTArrayCreation {
-	/**
-	 * The default value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TYPE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected String type = TYPE_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getDimensions() <em>Dimensions</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDimensions()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList dimensions = null;
-
-	/**
-	 * The cached value of the '{@link #getInitializer() <em>Initializer</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInitializer()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTArrayInitializer initializer = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTArrayCreationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTArrayCreation();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getType() {
-		return type;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setType(String newType) {
-		String oldType = type;
-		type = newType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_ARRAY_CREATION__TYPE, oldType, type));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDimensions() {
-		if (dimensions == null) {
-			dimensions = new EObjectContainmentEList(PTExpression.class, this, InstantiationPackage.PT_ARRAY_CREATION__DIMENSIONS);
-		}
-		return dimensions;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTArrayInitializer getInitializer() {
-		return initializer;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetInitializer(PTArrayInitializer newInitializer, NotificationChain msgs) {
-		PTArrayInitializer oldInitializer = initializer;
-		initializer = newInitializer;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER, oldInitializer, newInitializer);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInitializer(PTArrayInitializer newInitializer) {
-		if (newInitializer != initializer) {
-			NotificationChain msgs = null;
-			if (initializer != null)
-				msgs = ((InternalEObject)initializer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER, null, msgs);
-			if (newInitializer != null)
-				msgs = ((InternalEObject)newInitializer).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER, null, msgs);
-			msgs = basicSetInitializer(newInitializer, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER, newInitializer, newInitializer));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_ARRAY_CREATION__DIMENSIONS:
-					return ((InternalEList)getDimensions()).basicRemove(otherEnd, msgs);
-				case InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER:
-					return basicSetInitializer(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_CREATION__TYPE:
-				return getType();
-			case InstantiationPackage.PT_ARRAY_CREATION__DIMENSIONS:
-				return getDimensions();
-			case InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER:
-				return getInitializer();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_CREATION__TYPE:
-				setType((String)newValue);
-				return;
-			case InstantiationPackage.PT_ARRAY_CREATION__DIMENSIONS:
-				getDimensions().clear();
-				getDimensions().addAll((Collection)newValue);
-				return;
-			case InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER:
-				setInitializer((PTArrayInitializer)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_CREATION__TYPE:
-				setType(TYPE_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_ARRAY_CREATION__DIMENSIONS:
-				getDimensions().clear();
-				return;
-			case InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER:
-				setInitializer((PTArrayInitializer)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_CREATION__TYPE:
-				return TYPE_EDEFAULT == null ? type != null : !TYPE_EDEFAULT.equals(type);
-			case InstantiationPackage.PT_ARRAY_CREATION__DIMENSIONS:
-				return dimensions != null && !dimensions.isEmpty();
-			case InstantiationPackage.PT_ARRAY_CREATION__INITIALIZER:
-				return initializer != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChildren(visitor, dimensions);
-			acceptChild(visitor, getInitializer());
-		}
-		visitor.endVisit(this);
-	}	
-} //ArrayCreationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayInitializerImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayInitializerImpl.java
deleted file mode 100644
index 4f37a37..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTArrayInitializerImpl.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTArrayInitializerImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTArrayInitializer;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Array Initializer</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTArrayInitializerImpl#getExpressions <em>Expressions</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTArrayInitializerImpl extends PTExpressionImpl implements PTArrayInitializer {
-	/**
-	 * The cached value of the '{@link #getExpressions() <em>Expressions</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExpressions()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList expressions = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTArrayInitializerImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTArrayInitializer();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getExpressions() {
-		if (expressions == null) {
-			expressions = new EObjectContainmentEList(PTExpression.class, this, InstantiationPackage.PT_ARRAY_INITIALIZER__EXPRESSIONS);
-		}
-		return expressions;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_ARRAY_INITIALIZER__EXPRESSIONS:
-					return ((InternalEList)getExpressions()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_INITIALIZER__EXPRESSIONS:
-				return getExpressions();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_INITIALIZER__EXPRESSIONS:
-				getExpressions().clear();
-				getExpressions().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_INITIALIZER__EXPRESSIONS:
-				getExpressions().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_ARRAY_INITIALIZER__EXPRESSIONS:
-				return expressions != null && !expressions.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			acceptChildren(visitor, expressions);
-		}
-		visitor.endVisit(this);
-	}
-} //ArrayInitializerImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTBooleanLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTBooleanLiteralImpl.java
deleted file mode 100644
index 9ece1f6..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTBooleanLiteralImpl.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTBooleanLiteralImpl.java,v $
- *  $Revision: 1.4 $  $Date: 2005/09/15 21:02:19 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTBooleanLiteral;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Boolean Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTBooleanLiteralImpl#isBooleanValue <em>Boolean Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTBooleanLiteralImpl extends PTExpressionImpl implements PTBooleanLiteral {
-	/**
-	 * The default value of the '{@link #isBooleanValue() <em>Boolean Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isBooleanValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean BOOLEAN_VALUE_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isBooleanValue() <em>Boolean Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isBooleanValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int BOOLEAN_VALUE_EFLAG = 1 << 8;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTBooleanLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTBooleanLiteral();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isBooleanValue() {
-		return (eFlags & BOOLEAN_VALUE_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBooleanValue(boolean newBooleanValue) {
-		boolean oldBooleanValue = (eFlags & BOOLEAN_VALUE_EFLAG) != 0;
-		if (newBooleanValue) eFlags |= BOOLEAN_VALUE_EFLAG; else eFlags &= ~BOOLEAN_VALUE_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_BOOLEAN_LITERAL__BOOLEAN_VALUE, oldBooleanValue, newBooleanValue));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_BOOLEAN_LITERAL__BOOLEAN_VALUE:
-				return isBooleanValue() ? Boolean.TRUE : Boolean.FALSE;
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_BOOLEAN_LITERAL__BOOLEAN_VALUE:
-				setBooleanValue(((Boolean)newValue).booleanValue());
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_BOOLEAN_LITERAL__BOOLEAN_VALUE:
-				setBooleanValue(BOOLEAN_VALUE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_BOOLEAN_LITERAL__BOOLEAN_VALUE:
-				return ((eFlags & BOOLEAN_VALUE_EFLAG) != 0) != BOOLEAN_VALUE_EDEFAULT;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-
-} //BooleanLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTCastExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTCastExpressionImpl.java
deleted file mode 100644
index c6da964..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTCastExpressionImpl.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTCastExpressionImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTCastExpression;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Cast</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTCastExpressionImpl#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTCastExpressionImpl#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTCastExpressionImpl extends PTExpressionImpl implements PTCastExpression {
-	/**
-	 * The default value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TYPE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected String type = TYPE_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getExpression() <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExpression()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression expression = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTCastExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTCastExpression();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getType() {
-		return type;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setType(String newType) {
-		String oldType = type;
-		type = newType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CAST_EXPRESSION__TYPE, oldType, type));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getExpression() {
-		return expression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetExpression(PTExpression newExpression, NotificationChain msgs) {
-		PTExpression oldExpression = expression;
-		expression = newExpression;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION, oldExpression, newExpression);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExpression(PTExpression newExpression) {
-		if (newExpression != expression) {
-			NotificationChain msgs = null;
-			if (expression != null)
-				msgs = ((InternalEObject)expression).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION, null, msgs);
-			if (newExpression != null)
-				msgs = ((InternalEObject)newExpression).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION, null, msgs);
-			msgs = basicSetExpression(newExpression, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION, newExpression, newExpression));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION:
-					return basicSetExpression(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CAST_EXPRESSION__TYPE:
-				return getType();
-			case InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION:
-				return getExpression();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CAST_EXPRESSION__TYPE:
-				setType((String)newValue);
-				return;
-			case InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION:
-				setExpression((PTExpression)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CAST_EXPRESSION__TYPE:
-				setType(TYPE_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION:
-				setExpression((PTExpression)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CAST_EXPRESSION__TYPE:
-				return TYPE_EDEFAULT == null ? type != null : !TYPE_EDEFAULT.equals(type);
-			case InstantiationPackage.PT_CAST_EXPRESSION__EXPRESSION:
-				return expression != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getExpression());
-		}
-		visitor.endVisit(this);
-	}
-} //CastImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTCharacterLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTCharacterLiteralImpl.java
deleted file mode 100644
index e5504e7..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTCharacterLiteralImpl.java
+++ /dev/null
@@ -1,387 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTCharacterLiteralImpl.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTCharacterLiteral;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Character Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTCharacterLiteralImpl#getEscapedValue <em>Escaped Value</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTCharacterLiteralImpl#getCharValue <em>Char Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTCharacterLiteralImpl extends PTExpressionImpl implements PTCharacterLiteral {
-	/**
-	 * The default value of the '{@link #getEscapedValue() <em>Escaped Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getEscapedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ESCAPED_VALUE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getEscapedValue() <em>Escaped Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getEscapedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected String escapedValue = ESCAPED_VALUE_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getCharValue() <em>Char Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getCharValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final char CHAR_VALUE_EDEFAULT = '\u0000';
-
-	/**
-	 * The cached value of the '{@link #getCharValue() <em>Char Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getCharValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected char charValue = CHAR_VALUE_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTCharacterLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTCharacterLiteral();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getEscapedValue() {
-		return escapedValue;
-	}
-
-	public void setEscapedValue(String newEscapedValue) {
-		charValueSet = false;
-		setCharValueGen(CHAR_VALUE_EDEFAULT);
-		setEscapedValueGen(newEscapedValue);
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setEscapedValueGen(String newEscapedValue) {
-		String oldEscapedValue = escapedValue;
-		escapedValue = newEscapedValue;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CHARACTER_LITERAL__ESCAPED_VALUE, oldEscapedValue, escapedValue));
-	}
-
-	private boolean charValueSet;
-	
-	public char getCharValue() {
-		if (!charValueSet && escapedValue != ESCAPED_VALUE_EDEFAULT) {
-			String s = getEscapedValue();
-			int len = s.length();
-			if (len < 2 || s.charAt(0) != '\'' || s.charAt(len-1) != '\'' ) {
-				throw new IllegalArgumentException();
-			}
-			char c = s.charAt(1);
-			if (c == '\'') {
-				throw new IllegalArgumentException();
-			}
-			if (c == '\\') {
-				if (len == 4) {
-					setCharValueGen(getCharEscaped(s.charAt(2)));
-				} else if (len == 8) {
-					//handle the case of unicode.
-					int currentPosition = 2;
-					int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
-					if (s.charAt(currentPosition++) == 'u') {
-						if ((c1 = Character.getNumericValue(s.charAt(currentPosition++))) > 15
-								|| c1 < 0
-								|| (c2 = Character.getNumericValue(s.charAt(currentPosition++))) > 15
-								|| c2 < 0
-								|| (c3 = Character.getNumericValue(s.charAt(currentPosition++))) > 15
-								|| c3 < 0
-								|| (c4 = Character.getNumericValue(s.charAt(currentPosition++))) > 15
-								|| c4 < 0){
-							throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
-						} else {
-							setCharValueGen((char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4));
-						}
-					} else {
-						throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
-					}
-				} else {
-					throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
-				}
-			} else
-				setCharValueGen(c);
-			
-			charValueSet = true;
-		}
-		return getCharValueGen();
-	}
-	
-	public static char getCharEscaped(char nextChar) {
-		switch(nextChar) {
-			case 'b' :
-				return '\b';
-			case 't' :
-				return '\t';
-			case 'n' :
-				return '\n';
-			case 'f' :
-				return '\f';
-			case 'r' :
-				return '\r';
-			case '\"':
-				return '\"';
-			case '\'':
-				return '\'';
-			case '\\':
-				return '\\';
-			case '0' :
-				return '\0';
-			case '1' :
-				return '\1';
-			case '2' :
-				return '\2';
-			case '3' :
-				return '\3';
-			case '4' :
-				return '\4';
-			case '5' :
-				return '\5';
-			case '6' :
-				return '\6';
-			case '7' :
-				return '\7';
-			default:
-				throw new IllegalArgumentException("illegal character");//$NON-NLS-1$
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public char getCharValueGen() {
-		return charValue;
-	}
-
-	public void setCharValue(char newCharValue) {		
-		charValueSet = true;
-		setCharValueGen(newCharValue);
-		
-		StringBuffer b = new StringBuffer(8);
-		b.append('\''); // opening delimiter
-		appendCharacter(newCharValue, b);
-		b.append('\''); // closing delimiter
-		setEscapedValueGen(b.toString());
-	}
-	
-	public static void appendCharacter(char character, StringBuffer b) {
-		switch(character) {
-			case '\b' :
-				b.append("\\b"); //$NON-NLS-1$
-				break;
-			case '\t' :
-				b.append("\\t"); //$NON-NLS-1$
-				break;
-			case '\n' :
-				b.append("\\n"); //$NON-NLS-1$
-				break;
-			case '\f' :
-				b.append("\\f"); //$NON-NLS-1$
-				break;
-			case '\r' :
-				b.append("\\r"); //$NON-NLS-1$
-				break;
-			case '\"':
-				b.append("\\\""); //$NON-NLS-1$
-				break;
-			case '\'':
-				b.append("\\\'"); //$NON-NLS-1$
-				break;
-			case '\\':
-				b.append("\\\\"); //$NON-NLS-1$
-				break;
-			case '\0' :
-				b.append("\\0"); //$NON-NLS-1$
-				break;
-			case '\1' :
-				b.append("\\1"); //$NON-NLS-1$
-				break;
-			case '\2' :
-				b.append("\\2"); //$NON-NLS-1$
-				break;
-			case '\3' :
-				b.append("\\3"); //$NON-NLS-1$
-				break;
-			case '\4' :
-				b.append("\\4"); //$NON-NLS-1$
-				break;
-			case '\5' :
-				b.append("\\5"); //$NON-NLS-1$
-				break;
-			case '\6' :
-				b.append("\\6"); //$NON-NLS-1$
-				break;
-			case '\7' :
-				b.append("\\7"); //$NON-NLS-1$
-				break;			
-			default:
-				// use a simple algorithm, if char is < 255 then just use it, else use it as unicode.
-				if (character < 255)
-					b.append(character);
-				else {
-					b.append("\\u");
-					String s = Integer.toString(character, 16);
-					int zeros = 4-s.length();
-					while (zeros-- > 0) {
-						b.append('0');
-					}
-					b.append(s);
-				}	
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setCharValueGen(char newCharValue) {
-		char oldCharValue = charValue;
-		charValue = newCharValue;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CHARACTER_LITERAL__CHAR_VALUE, oldCharValue, charValue));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CHARACTER_LITERAL__ESCAPED_VALUE:
-				return getEscapedValue();
-			case InstantiationPackage.PT_CHARACTER_LITERAL__CHAR_VALUE:
-				return new Character(getCharValue());
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CHARACTER_LITERAL__ESCAPED_VALUE:
-				setEscapedValue((String)newValue);
-				return;
-			case InstantiationPackage.PT_CHARACTER_LITERAL__CHAR_VALUE:
-				setCharValue(((Character)newValue).charValue());
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CHARACTER_LITERAL__ESCAPED_VALUE:
-				setEscapedValue(ESCAPED_VALUE_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_CHARACTER_LITERAL__CHAR_VALUE:
-				setCharValue(CHAR_VALUE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CHARACTER_LITERAL__ESCAPED_VALUE:
-				return ESCAPED_VALUE_EDEFAULT == null ? escapedValue != null : !ESCAPED_VALUE_EDEFAULT.equals(escapedValue);
-			case InstantiationPackage.PT_CHARACTER_LITERAL__CHAR_VALUE:
-				return charValue != CHAR_VALUE_EDEFAULT;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-} //CharacterLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTClassInstanceCreationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTClassInstanceCreationImpl.java
deleted file mode 100644
index 91ea191..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTClassInstanceCreationImpl.java
+++ /dev/null
@@ -1,231 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTClassInstanceCreationImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTClassInstanceCreation;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Class Instance Creation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTClassInstanceCreationImpl#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTClassInstanceCreationImpl#getArguments <em>Arguments</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTClassInstanceCreationImpl extends PTExpressionImpl implements PTClassInstanceCreation {
-	/**
-	 * The default value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TYPE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected String type = TYPE_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getArguments() <em>Arguments</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getArguments()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList arguments = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTClassInstanceCreationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTClassInstanceCreation();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getType() {
-		return type;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setType(String newType) {
-		String oldType = type;
-		type = newType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CLASS_INSTANCE_CREATION__TYPE, oldType, type));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getArguments() {
-		if (arguments == null) {
-			arguments = new EObjectContainmentEList(PTExpression.class, this, InstantiationPackage.PT_CLASS_INSTANCE_CREATION__ARGUMENTS);
-		}
-		return arguments;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__ARGUMENTS:
-					return ((InternalEList)getArguments()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__TYPE:
-				return getType();
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__ARGUMENTS:
-				return getArguments();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__TYPE:
-				setType((String)newValue);
-				return;
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__ARGUMENTS:
-				getArguments().clear();
-				getArguments().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__TYPE:
-				setType(TYPE_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__ARGUMENTS:
-				getArguments().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__TYPE:
-				return TYPE_EDEFAULT == null ? type != null : !TYPE_EDEFAULT.equals(type);
-			case InstantiationPackage.PT_CLASS_INSTANCE_CREATION__ARGUMENTS:
-				return arguments != null && !arguments.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChildren(visitor, arguments);
-		}
-		visitor.endVisit(this);
-	}
-} //ClassInstanceCreationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTConditionalExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTConditionalExpressionImpl.java
deleted file mode 100644
index 96cae47..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTConditionalExpressionImpl.java
+++ /dev/null
@@ -1,333 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTConditionalExpressionImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTConditionalExpression;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Conditional Expression</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTConditionalExpressionImpl#getCondition <em>Condition</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTConditionalExpressionImpl#getTrue <em>True</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTConditionalExpressionImpl#getFalse <em>False</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTConditionalExpressionImpl extends PTExpressionImpl implements PTConditionalExpression {
-	/**
-	 * The cached value of the '{@link #getCondition() <em>Condition</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getCondition()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression condition = null;
-
-	/**
-	 * The cached value of the '{@link #getTrue() <em>True</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTrue()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression true_ = null;
-
-	/**
-	 * The cached value of the '{@link #getFalse() <em>False</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFalse()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression false_ = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTConditionalExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTConditionalExpression();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getCondition() {
-		return condition;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetCondition(PTExpression newCondition, NotificationChain msgs) {
-		PTExpression oldCondition = condition;
-		condition = newCondition;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION, oldCondition, newCondition);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setCondition(PTExpression newCondition) {
-		if (newCondition != condition) {
-			NotificationChain msgs = null;
-			if (condition != null)
-				msgs = ((InternalEObject)condition).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION, null, msgs);
-			if (newCondition != null)
-				msgs = ((InternalEObject)newCondition).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION, null, msgs);
-			msgs = basicSetCondition(newCondition, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION, newCondition, newCondition));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getTrue() {
-		return true_;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetTrue(PTExpression newTrue, NotificationChain msgs) {
-		PTExpression oldTrue = true_;
-		true_ = newTrue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE, oldTrue, newTrue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTrue(PTExpression newTrue) {
-		if (newTrue != true_) {
-			NotificationChain msgs = null;
-			if (true_ != null)
-				msgs = ((InternalEObject)true_).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE, null, msgs);
-			if (newTrue != null)
-				msgs = ((InternalEObject)newTrue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE, null, msgs);
-			msgs = basicSetTrue(newTrue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE, newTrue, newTrue));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getFalse() {
-		return false_;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFalse(PTExpression newFalse, NotificationChain msgs) {
-		PTExpression oldFalse = false_;
-		false_ = newFalse;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE, oldFalse, newFalse);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFalse(PTExpression newFalse) {
-		if (newFalse != false_) {
-			NotificationChain msgs = null;
-			if (false_ != null)
-				msgs = ((InternalEObject)false_).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE, null, msgs);
-			if (newFalse != null)
-				msgs = ((InternalEObject)newFalse).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE, null, msgs);
-			msgs = basicSetFalse(newFalse, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE, newFalse, newFalse));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION:
-					return basicSetCondition(null, msgs);
-				case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE:
-					return basicSetTrue(null, msgs);
-				case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE:
-					return basicSetFalse(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION:
-				return getCondition();
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE:
-				return getTrue();
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE:
-				return getFalse();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION:
-				setCondition((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE:
-				setTrue((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE:
-				setFalse((PTExpression)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION:
-				setCondition((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE:
-				setTrue((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE:
-				setFalse((PTExpression)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__CONDITION:
-				return condition != null;
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__TRUE:
-				return true_ != null;
-			case InstantiationPackage.PT_CONDITIONAL_EXPRESSION__FALSE:
-				return false_ != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getCondition());
-			acceptChild(visitor, getTrue());
-			acceptChild(visitor, getFalse());
-		}
-		visitor.endVisit(this);
-	}	
-
-} //ConditionalExpressionImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTExpressionImpl.java
deleted file mode 100644
index 2264d70..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTExpressionImpl.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTExpressionImpl.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.List;
-
-import org.eclipse.emf.ecore.EClass;
-
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Expression</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public abstract class PTExpressionImpl extends EObjectImpl implements PTExpression {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTExpression();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.Expression#accept(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	public final void accept(ParseVisitor visitor) {
-		try {
-			childAccept0(visitor);
-		} catch (ParseVisitor.StopVisiting e) {
-			// Do nothing, this is a normal way to just stop visiting.
-		}
-	}
-
-	/**
-	 * Accepts the given visitor on a type-specific visit of the current node.
-	 * This method must be implemented in all concrete Expression node types.
-	 * <p>
-	 * General template for implementation on each concrete ASTNode class:
-	 * <pre>
-	 * <code>
-	 * boolean visitChildren = visitor.visit(this);
-	 * if (visitChildren) {
-	 *    // visit children in normal left to right reading order
-	 *    acceptChild(visitor, getProperty1());
-	 *    acceptChildren(visitor, rawListProperty);
-	 *    acceptChild(visitor, getProperty2());
-	 * }
-	 * visitor.endVisit(this);
-	 * </code>
-	 * </pre>
-	 * Note that the caller (<code>accept</code>) take cares of invoking
-	 * <code>visitor.preVisit(this)</code> and <code>visitor.postVisit(this)</code>.
-	 * </p>
-	 * 
-	 * @param visitor the visitor object
-	 */
-	protected abstract void accept0(ParseVisitor visitor);
-
-	/**
-	 * Accepts the given visitor on a visit of the current node.
-	 * <p>
-	 * This method should be used by the concrete implementations of
-	 * <code>accept0</code> to traverse optional properties. Equivalent
-	 * to <code>child.accept(visitor)</code> if <code>child</code>
-	 * is not <code>null</code>.
-	 * </p>
-	 * 
-	 * @param visitor the visitor object
-	 * @param child the child Expression node to dispatch too, or <code>null</code>
-	 *    if none. It actually must be an instance of PTExpressionImpl, but 
-	 *    it would be too difficult to put the cast in each call to acceptChild.
-	 */
-	protected final void acceptChild(ParseVisitor visitor, PTExpression child) {
-		if (child == null) {
-			return;
-		}
-		((PTExpressionImpl) child).childAccept0(visitor);
-	}
-	
-	/**
-	 * Called ONLY by PTExpressionImpl for the child to accept the visitor, but
-	 * it doesn't catch StopVisiting.
-	 * @param visitor
-	 * 
-	 * @since 1.1.0.1
-	 */
-	protected final void childAccept0(ParseVisitor visitor) {
-		if (visitor == null) {
-			throw new IllegalArgumentException();
-		}
-		// begin with the generic pre-visit
-		visitor.preVisit(this);
-		// dynamic dispatch to internal method for type-specific visit/endVisit
-		accept0(visitor);
-		// end with the generic post-visit
-		visitor.postVisit(this);
-	}
-	
-	/**
-	 * Accepts the given visitor on a visit of the given live list of
-	 * child nodes. 
-	 * @param visitor the visitor object
-	 * @param children the child Expression nodes to dispatch to, or <code>null</code> if none.
-	 */
-	protected final void acceptChildren(ParseVisitor visitor, List children) {
-		if (children != null) {
-			int size = children.size();
-			for (int i = 0; i < size; i++) {
-				acceptChild(visitor, (PTExpression) children.get(i));
-			}
-		} 
-	}
-	
-	public String toString() {
-		// allocate a buffer that is large enough to hold an average compilation unit
-		StringBuffer buffer = new StringBuffer(6000);
-		int p = buffer.length();
-		try {
-			appendDebugString(buffer);
-		} catch (RuntimeException e) {
-			// since debugger sometimes call toString methods, problems can easily happen when
-			// toString is called on an instance that is being initialized
-			buffer.setLength(p);
-			buffer.append("!"); //$NON-NLS-1$
-			buffer.append(standardToString());
-		}
-		// convert to a string, but lose the extra space in the string buffer by copying
-		return buffer.toString();
-	}
-	
-	protected final String standardToString() {
-		return super.toString();
-	}
-	
-	protected void appendDebugString(StringBuffer buffer) {
-		// print the subtree by default
-		appendPrintString(buffer);
-	}
-	
-	/*
-	 * Appends a standard Java source code representation of this subtree to the given
-	 * string buffer.
-	 * 
-	 * @param buffer the string buffer to append to
-	 */
-	protected final void appendPrintString(StringBuffer buffer) {
-		NaiveExpressionFlattener printer = new NaiveExpressionFlattener();
-		this.accept(printer);
-		buffer.append(printer.getResult());
-	}	
-
-} //ExpressionImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTFieldAccessImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTFieldAccessImpl.java
deleted file mode 100644
index 7e87e15..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTFieldAccessImpl.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTFieldAccessImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.PTFieldAccess;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Field Access</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTFieldAccessImpl#getReceiver <em>Receiver</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTFieldAccessImpl#getField <em>Field</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTFieldAccessImpl extends PTExpressionImpl implements PTFieldAccess {
-	/**
-	 * The cached value of the '{@link #getReceiver() <em>Receiver</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReceiver()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression receiver = null;
-
-	/**
-	 * The default value of the '{@link #getField() <em>Field</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getField()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String FIELD_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getField() <em>Field</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getField()
-	 * @generated
-	 * @ordered
-	 */
-	protected String field = FIELD_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTFieldAccessImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTFieldAccess();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getReceiver() {
-		return receiver;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReceiver(PTExpression newReceiver, NotificationChain msgs) {
-		PTExpression oldReceiver = receiver;
-		receiver = newReceiver;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_FIELD_ACCESS__RECEIVER, oldReceiver, newReceiver);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReceiver(PTExpression newReceiver) {
-		if (newReceiver != receiver) {
-			NotificationChain msgs = null;
-			if (receiver != null)
-				msgs = ((InternalEObject)receiver).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_FIELD_ACCESS__RECEIVER, null, msgs);
-			if (newReceiver != null)
-				msgs = ((InternalEObject)newReceiver).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_FIELD_ACCESS__RECEIVER, null, msgs);
-			msgs = basicSetReceiver(newReceiver, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_FIELD_ACCESS__RECEIVER, newReceiver, newReceiver));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getField() {
-		return field;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setField(String newField) {
-		String oldField = field;
-		field = newField;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_FIELD_ACCESS__FIELD, oldField, field));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_FIELD_ACCESS__RECEIVER:
-					return basicSetReceiver(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_FIELD_ACCESS__RECEIVER:
-				return getReceiver();
-			case InstantiationPackage.PT_FIELD_ACCESS__FIELD:
-				return getField();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_FIELD_ACCESS__RECEIVER:
-				setReceiver((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_FIELD_ACCESS__FIELD:
-				setField((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_FIELD_ACCESS__RECEIVER:
-				setReceiver((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_FIELD_ACCESS__FIELD:
-				setField(FIELD_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_FIELD_ACCESS__RECEIVER:
-				return receiver != null;
-			case InstantiationPackage.PT_FIELD_ACCESS__FIELD:
-				return FIELD_EDEFAULT == null ? field != null : !FIELD_EDEFAULT.equals(field);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getReceiver());
-		}
-		visitor.endVisit(this);
-	}	
-
-} //FieldAccessImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInfixExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInfixExpressionImpl.java
deleted file mode 100644
index cec8776..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInfixExpressionImpl.java
+++ /dev/null
@@ -1,394 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTInfixExpressionImpl.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.PTInfixExpression;
-import org.eclipse.jem.internal.instantiation.PTInfixOperator;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Infix Expression</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInfixExpressionImpl#getLeftOperand <em>Left Operand</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInfixExpressionImpl#getOperator <em>Operator</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInfixExpressionImpl#getRightOperand <em>Right Operand</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInfixExpressionImpl#getExtendedOperands <em>Extended Operands</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTInfixExpressionImpl extends PTExpressionImpl implements PTInfixExpression {
-	/**
-	 * The cached value of the '{@link #getLeftOperand() <em>Left Operand</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLeftOperand()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression leftOperand = null;
-
-	/**
-	 * The default value of the '{@link #getOperator() <em>Operator</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOperator()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final PTInfixOperator OPERATOR_EDEFAULT = PTInfixOperator.TIMES_LITERAL;
-
-	/**
-	 * The cached value of the '{@link #getOperator() <em>Operator</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOperator()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTInfixOperator operator = OPERATOR_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getRightOperand() <em>Right Operand</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRightOperand()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression rightOperand = null;
-
-	/**
-	 * The cached value of the '{@link #getExtendedOperands() <em>Extended Operands</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExtendedOperands()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList extendedOperands = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTInfixExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTInfixExpression();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getLeftOperand() {
-		return leftOperand;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLeftOperand(PTExpression newLeftOperand, NotificationChain msgs) {
-		PTExpression oldLeftOperand = leftOperand;
-		leftOperand = newLeftOperand;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND, oldLeftOperand, newLeftOperand);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLeftOperand(PTExpression newLeftOperand) {
-		if (newLeftOperand != leftOperand) {
-			NotificationChain msgs = null;
-			if (leftOperand != null)
-				msgs = ((InternalEObject)leftOperand).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND, null, msgs);
-			if (newLeftOperand != null)
-				msgs = ((InternalEObject)newLeftOperand).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND, null, msgs);
-			msgs = basicSetLeftOperand(newLeftOperand, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND, newLeftOperand, newLeftOperand));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTInfixOperator getOperator() {
-		return operator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOperator(PTInfixOperator newOperator) {
-		PTInfixOperator oldOperator = operator;
-		operator = newOperator == null ? OPERATOR_EDEFAULT : newOperator;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INFIX_EXPRESSION__OPERATOR, oldOperator, operator));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getRightOperand() {
-		return rightOperand;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRightOperand(PTExpression newRightOperand, NotificationChain msgs) {
-		PTExpression oldRightOperand = rightOperand;
-		rightOperand = newRightOperand;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND, oldRightOperand, newRightOperand);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRightOperand(PTExpression newRightOperand) {
-		if (newRightOperand != rightOperand) {
-			NotificationChain msgs = null;
-			if (rightOperand != null)
-				msgs = ((InternalEObject)rightOperand).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND, null, msgs);
-			if (newRightOperand != null)
-				msgs = ((InternalEObject)newRightOperand).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND, null, msgs);
-			msgs = basicSetRightOperand(newRightOperand, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND, newRightOperand, newRightOperand));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getExtendedOperands() {
-		if (extendedOperands == null) {
-			extendedOperands = new EObjectContainmentEList(PTExpression.class, this, InstantiationPackage.PT_INFIX_EXPRESSION__EXTENDED_OPERANDS);
-		}
-		return extendedOperands;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND:
-					return basicSetLeftOperand(null, msgs);
-				case InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND:
-					return basicSetRightOperand(null, msgs);
-				case InstantiationPackage.PT_INFIX_EXPRESSION__EXTENDED_OPERANDS:
-					return ((InternalEList)getExtendedOperands()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND:
-				return getLeftOperand();
-			case InstantiationPackage.PT_INFIX_EXPRESSION__OPERATOR:
-				return getOperator();
-			case InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND:
-				return getRightOperand();
-			case InstantiationPackage.PT_INFIX_EXPRESSION__EXTENDED_OPERANDS:
-				return getExtendedOperands();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND:
-				setLeftOperand((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__OPERATOR:
-				setOperator((PTInfixOperator)newValue);
-				return;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND:
-				setRightOperand((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__EXTENDED_OPERANDS:
-				getExtendedOperands().clear();
-				getExtendedOperands().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND:
-				setLeftOperand((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__OPERATOR:
-				setOperator(OPERATOR_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND:
-				setRightOperand((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__EXTENDED_OPERANDS:
-				getExtendedOperands().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INFIX_EXPRESSION__LEFT_OPERAND:
-				return leftOperand != null;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__OPERATOR:
-				return operator != OPERATOR_EDEFAULT;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__RIGHT_OPERAND:
-				return rightOperand != null;
-			case InstantiationPackage.PT_INFIX_EXPRESSION__EXTENDED_OPERANDS:
-				return extendedOperands != null && !extendedOperands.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getLeftOperand());
-			acceptChild(visitor, getRightOperand());
-			acceptChildren(visitor, extendedOperands);
-		}
-		visitor.endVisit(this);
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.PTInfixExpression#asCompressedExpression()
-	 */
-	public PTExpression asCompressedExpression() {
-		// If no left and no right
-		if(getLeftOperand() == null && getRightOperand() != null){
-			// no extends so just use the right operand
-			if(getExtendedOperands().isEmpty()){
-				return getRightOperand();
-			} else {
-				// The right becomes the new left
-				setLeftOperand(getRightOperand());
-				// The first operand becomes the right one
-				setRightOperand((PTExpression) getExtendedOperands().remove(0));
-				return this;
-			}
-		} else if (getRightOperand() == null && getLeftOperand() != null){
-			// no extends so just use the left operand
-			if(getExtendedOperands().isEmpty()){
-				return getLeftOperand();
-			} else {
-				// The right becomes the first extended
-				setRightOperand((PTExpression)getExtendedOperands().remove(0));
-				return this;
-			}			
-		}	
-		return this;
-	}
-} //InfixExpressionImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInstanceReferenceImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInstanceReferenceImpl.java
deleted file mode 100644
index 86f5d0d..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInstanceReferenceImpl.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/**
- * <copyright>
- * </copyright>
- *
- * %W%
- * @version %I% %H%
- */
-package org.eclipse.jem.internal.instantiation.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTInstanceReference;
-
-import org.eclipse.jem.internal.instantiation.base.IJavaInstance;
-
-import org.eclipse.jem.internal.instantiation.*;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>PT Instance Reference</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInstanceReferenceImpl#getReference <em>Reference</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTInstanceReferenceImpl extends PTExpressionImpl implements PTInstanceReference {
-	/**
-	 * The cached value of the '{@link #getReference() <em>Reference</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReference()
-	 * @generated
-	 * @ordered
-	 */
-	protected IJavaInstance reference = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTInstanceReferenceImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTInstanceReference();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IJavaInstance getReference() {
-		if (reference != null && reference.eIsProxy()) {
-			IJavaInstance oldReference = reference;
-			reference = (IJavaInstance)eResolveProxy((InternalEObject)reference);
-			if (reference != oldReference) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, InstantiationPackage.PT_INSTANCE_REFERENCE__REFERENCE, oldReference, reference));
-			}
-		}
-		return reference;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IJavaInstance basicGetReference() {
-		return reference;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReference(IJavaInstance newReference) {
-		IJavaInstance oldReference = reference;
-		reference = newReference;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INSTANCE_REFERENCE__REFERENCE, oldReference, reference));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCE_REFERENCE__REFERENCE:
-				if (resolve) return getReference();
-				return basicGetReference();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCE_REFERENCE__REFERENCE:
-				setReference((IJavaInstance)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCE_REFERENCE__REFERENCE:
-				setReference((IJavaInstance)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCE_REFERENCE__REFERENCE:
-				return reference != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.PTExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-	
-	public String toString() {
-		return "InstanceRef{" + reference + "}";
-	}
-
-} //PTInstanceReferenceImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInstanceofImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInstanceofImpl.java
deleted file mode 100644
index 172892e..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInstanceofImpl.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTInstanceofImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.PTInstanceof;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Instanceof</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInstanceofImpl#getOperand <em>Operand</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInstanceofImpl#getType <em>Type</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTInstanceofImpl extends PTExpressionImpl implements PTInstanceof {
-	/**
-	 * The cached value of the '{@link #getOperand() <em>Operand</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOperand()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression operand = null;
-
-	/**
-	 * The default value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TYPE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected String type = TYPE_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTInstanceofImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTInstanceof();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getOperand() {
-		return operand;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetOperand(PTExpression newOperand, NotificationChain msgs) {
-		PTExpression oldOperand = operand;
-		operand = newOperand;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INSTANCEOF__OPERAND, oldOperand, newOperand);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOperand(PTExpression newOperand) {
-		if (newOperand != operand) {
-			NotificationChain msgs = null;
-			if (operand != null)
-				msgs = ((InternalEObject)operand).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_INSTANCEOF__OPERAND, null, msgs);
-			if (newOperand != null)
-				msgs = ((InternalEObject)newOperand).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_INSTANCEOF__OPERAND, null, msgs);
-			msgs = basicSetOperand(newOperand, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INSTANCEOF__OPERAND, newOperand, newOperand));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getType() {
-		return type;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setType(String newType) {
-		String oldType = type;
-		type = newType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INSTANCEOF__TYPE, oldType, type));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_INSTANCEOF__OPERAND:
-					return basicSetOperand(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCEOF__OPERAND:
-				return getOperand();
-			case InstantiationPackage.PT_INSTANCEOF__TYPE:
-				return getType();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCEOF__OPERAND:
-				setOperand((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_INSTANCEOF__TYPE:
-				setType((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCEOF__OPERAND:
-				setOperand((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_INSTANCEOF__TYPE:
-				setType(TYPE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INSTANCEOF__OPERAND:
-				return operand != null;
-			case InstantiationPackage.PT_INSTANCEOF__TYPE:
-				return TYPE_EDEFAULT == null ? type != null : !TYPE_EDEFAULT.equals(type);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getOperand());
-		}
-		visitor.endVisit(this);
-	}
-
-} //InstanceofImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInvalidExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInvalidExpressionImpl.java
deleted file mode 100644
index ff8dd59..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTInvalidExpressionImpl.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTInvalidExpressionImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTInvalidExpression;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Invalid Expression</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTInvalidExpressionImpl#getMessage <em>Message</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTInvalidExpressionImpl extends PTExpressionImpl implements PTInvalidExpression {
-	/**
-	 * The default value of the '{@link #getMessage() <em>Message</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMessage()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String MESSAGE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getMessage() <em>Message</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMessage()
-	 * @generated
-	 * @ordered
-	 */
-	protected String message = MESSAGE_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTInvalidExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTInvalidExpression();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getMessage() {
-		return message;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMessage(String newMessage) {
-		String oldMessage = message;
-		message = newMessage;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_INVALID_EXPRESSION__MESSAGE, oldMessage, message));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INVALID_EXPRESSION__MESSAGE:
-				return getMessage();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INVALID_EXPRESSION__MESSAGE:
-				setMessage((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INVALID_EXPRESSION__MESSAGE:
-				setMessage(MESSAGE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_INVALID_EXPRESSION__MESSAGE:
-				return MESSAGE_EDEFAULT == null ? message != null : !MESSAGE_EDEFAULT.equals(message);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-
-} //InvalidExpressionImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTMethodInvocationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTMethodInvocationImpl.java
deleted file mode 100644
index c3504ff..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTMethodInvocationImpl.java
+++ /dev/null
@@ -1,298 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTMethodInvocationImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.common.util.EList;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTMethodInvocation;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Method Invocation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTMethodInvocationImpl#getReceiver <em>Receiver</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTMethodInvocationImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTMethodInvocationImpl#getArguments <em>Arguments</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTMethodInvocationImpl extends PTExpressionImpl implements PTMethodInvocation {
-	/**
-	 * The cached value of the '{@link #getReceiver() <em>Receiver</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReceiver()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression receiver = null;
-
-	/**
-	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String NAME_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected String name = NAME_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getArguments() <em>Arguments</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getArguments()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList arguments = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTMethodInvocationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTMethodInvocation();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getReceiver() {
-		return receiver;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReceiver(PTExpression newReceiver, NotificationChain msgs) {
-		PTExpression oldReceiver = receiver;
-		receiver = newReceiver;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER, oldReceiver, newReceiver);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReceiver(PTExpression newReceiver) {
-		if (newReceiver != receiver) {
-			NotificationChain msgs = null;
-			if (receiver != null)
-				msgs = ((InternalEObject)receiver).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER, null, msgs);
-			if (newReceiver != null)
-				msgs = ((InternalEObject)newReceiver).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER, null, msgs);
-			msgs = basicSetReceiver(newReceiver, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER, newReceiver, newReceiver));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getName() {
-		return name;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setName(String newName) {
-		String oldName = name;
-		name = newName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_METHOD_INVOCATION__NAME, oldName, name));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getArguments() {
-		if (arguments == null) {
-			arguments = new EObjectContainmentEList(PTExpression.class, this, InstantiationPackage.PT_METHOD_INVOCATION__ARGUMENTS);
-		}
-		return arguments;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER:
-					return basicSetReceiver(null, msgs);
-				case InstantiationPackage.PT_METHOD_INVOCATION__ARGUMENTS:
-					return ((InternalEList)getArguments()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER:
-				return getReceiver();
-			case InstantiationPackage.PT_METHOD_INVOCATION__NAME:
-				return getName();
-			case InstantiationPackage.PT_METHOD_INVOCATION__ARGUMENTS:
-				return getArguments();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER:
-				setReceiver((PTExpression)newValue);
-				return;
-			case InstantiationPackage.PT_METHOD_INVOCATION__NAME:
-				setName((String)newValue);
-				return;
-			case InstantiationPackage.PT_METHOD_INVOCATION__ARGUMENTS:
-				getArguments().clear();
-				getArguments().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER:
-				setReceiver((PTExpression)null);
-				return;
-			case InstantiationPackage.PT_METHOD_INVOCATION__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_METHOD_INVOCATION__ARGUMENTS:
-				getArguments().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_METHOD_INVOCATION__RECEIVER:
-				return receiver != null;
-			case InstantiationPackage.PT_METHOD_INVOCATION__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case InstantiationPackage.PT_METHOD_INVOCATION__ARGUMENTS:
-				return arguments != null && !arguments.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getReceiver());
-			acceptChildren(visitor, arguments);
-		}
-		visitor.endVisit(this);
-	}
-} //MethodInvocationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNameImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNameImpl.java
deleted file mode 100644
index 91190db..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNameImpl.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTNameImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTName;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Name</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTNameImpl#getName <em>Name</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTNameImpl extends PTExpressionImpl implements PTName {
-	/**
-	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String NAME_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected String name = NAME_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTNameImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTName();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getName() {
-		return name;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setName(String newName) {
-		String oldName = name;
-		name = newName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_NAME__NAME, oldName, name));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NAME__NAME:
-				return getName();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NAME__NAME:
-				setName((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NAME__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NAME__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-
-} //NameImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNullLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNullLiteralImpl.java
deleted file mode 100644
index 8c2691e..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNullLiteralImpl.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTNullLiteralImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EClass;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTNullLiteral;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Null Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class PTNullLiteralImpl extends PTExpressionImpl implements PTNullLiteral {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTNullLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTNullLiteral();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}	
-
-} //NullLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNumberLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNumberLiteralImpl.java
deleted file mode 100644
index 56d94b3..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTNumberLiteralImpl.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTNumberLiteralImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTNumberLiteral;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Number Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTNumberLiteralImpl#getToken <em>Token</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTNumberLiteralImpl extends PTExpressionImpl implements PTNumberLiteral {
-	/**
-	 * The default value of the '{@link #getToken() <em>Token</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getToken()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TOKEN_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getToken() <em>Token</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getToken()
-	 * @generated
-	 * @ordered
-	 */
-	protected String token = TOKEN_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTNumberLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTNumberLiteral();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getToken() {
-		return token;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setToken(String newToken) {
-		String oldToken = token;
-		token = newToken;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_NUMBER_LITERAL__TOKEN, oldToken, token));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NUMBER_LITERAL__TOKEN:
-				return getToken();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NUMBER_LITERAL__TOKEN:
-				setToken((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NUMBER_LITERAL__TOKEN:
-				setToken(TOKEN_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_NUMBER_LITERAL__TOKEN:
-				return TOKEN_EDEFAULT == null ? token != null : !TOKEN_EDEFAULT.equals(token);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (token: ");
-		result.append(token);
-		result.append(')');
-		return result.toString();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-} //NumberLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTParenthesizedExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTParenthesizedExpressionImpl.java
deleted file mode 100644
index 1ee8dff..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTParenthesizedExpressionImpl.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTParenthesizedExpressionImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTParenthesizedExpression;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Parenthesized Expression</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTParenthesizedExpressionImpl#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTParenthesizedExpressionImpl extends PTExpressionImpl implements PTParenthesizedExpression {
-	/**
-	 * The cached value of the '{@link #getExpression() <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExpression()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression expression = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTParenthesizedExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTParenthesizedExpression();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getExpression() {
-		return expression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetExpression(PTExpression newExpression, NotificationChain msgs) {
-		PTExpression oldExpression = expression;
-		expression = newExpression;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION, oldExpression, newExpression);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExpression(PTExpression newExpression) {
-		if (newExpression != expression) {
-			NotificationChain msgs = null;
-			if (expression != null)
-				msgs = ((InternalEObject)expression).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION, null, msgs);
-			if (newExpression != null)
-				msgs = ((InternalEObject)newExpression).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION, null, msgs);
-			msgs = basicSetExpression(newExpression, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION, newExpression, newExpression));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION:
-					return basicSetExpression(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION:
-				return getExpression();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION:
-				setExpression((PTExpression)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION:
-				setExpression((PTExpression)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PARENTHESIZED_EXPRESSION__EXPRESSION:
-				return expression != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			acceptChild(visitor, getExpression());
-		}
-		visitor.endVisit(this);
-	}	
-
-} //ParenthesizedExpressionImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTPrefixExpressionImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTPrefixExpressionImpl.java
deleted file mode 100644
index ff150a4..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTPrefixExpressionImpl.java
+++ /dev/null
@@ -1,256 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTPrefixExpressionImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTPrefixExpression;
-import org.eclipse.jem.internal.instantiation.PTPrefixOperator;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Prefix Expression</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTPrefixExpressionImpl#getOperator <em>Operator</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTPrefixExpressionImpl#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTPrefixExpressionImpl extends PTExpressionImpl implements PTPrefixExpression {
-	/**
-	 * The default value of the '{@link #getOperator() <em>Operator</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOperator()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final PTPrefixOperator OPERATOR_EDEFAULT = PTPrefixOperator.PLUS_LITERAL;
-
-	/**
-	 * The cached value of the '{@link #getOperator() <em>Operator</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOperator()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTPrefixOperator operator = OPERATOR_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getExpression() <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExpression()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression expression = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTPrefixExpressionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTPrefixExpression();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTPrefixOperator getOperator() {
-		return operator;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOperator(PTPrefixOperator newOperator) {
-		PTPrefixOperator oldOperator = operator;
-		operator = newOperator == null ? OPERATOR_EDEFAULT : newOperator;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_PREFIX_EXPRESSION__OPERATOR, oldOperator, operator));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getExpression() {
-		return expression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetExpression(PTExpression newExpression, NotificationChain msgs) {
-		PTExpression oldExpression = expression;
-		expression = newExpression;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION, oldExpression, newExpression);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExpression(PTExpression newExpression) {
-		if (newExpression != expression) {
-			NotificationChain msgs = null;
-			if (expression != null)
-				msgs = ((InternalEObject)expression).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION, null, msgs);
-			if (newExpression != null)
-				msgs = ((InternalEObject)newExpression).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION, null, msgs);
-			msgs = basicSetExpression(newExpression, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION, newExpression, newExpression));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION:
-					return basicSetExpression(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__OPERATOR:
-				return getOperator();
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION:
-				return getExpression();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__OPERATOR:
-				setOperator((PTPrefixOperator)newValue);
-				return;
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION:
-				setExpression((PTExpression)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__OPERATOR:
-				setOperator(OPERATOR_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION:
-				setExpression((PTExpression)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__OPERATOR:
-				return operator != OPERATOR_EDEFAULT;
-			case InstantiationPackage.PT_PREFIX_EXPRESSION__EXPRESSION:
-				return expression != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		boolean visitChildren = visitor.visit(this);
-		if (visitChildren) {
-			// visit children in normal left to right reading order
-			acceptChild(visitor, getExpression());
-		}
-		visitor.endVisit(this);
-	}
-
-} //PrefixExpressionImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTStringLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTStringLiteralImpl.java
deleted file mode 100644
index a2b8910..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTStringLiteralImpl.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTStringLiteralImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTStringLiteral;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>String Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTStringLiteralImpl#getEscapedValue <em>Escaped Value</em>}</li>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTStringLiteralImpl#getLiteralValue <em>Literal Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTStringLiteralImpl extends PTExpressionImpl implements PTStringLiteral {
-	/**
-	 * The default value of the '{@link #getEscapedValue() <em>Escaped Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getEscapedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ESCAPED_VALUE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getEscapedValue() <em>Escaped Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getEscapedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected String escapedValue = ESCAPED_VALUE_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getLiteralValue() <em>Literal Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLiteralValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String LITERAL_VALUE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getLiteralValue() <em>Literal Value</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLiteralValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected String literalValue = LITERAL_VALUE_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTStringLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTStringLiteral();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getEscapedValue() {
-		return escapedValue;
-	}
-
-	public void setEscapedValue(String newEscapedValue) {
-		stringLiteralSet = false;
-		setLiteralValueGen(LITERAL_VALUE_EDEFAULT);
-		setEscapedValueGen(newEscapedValue);		
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setEscapedValueGen(String newEscapedValue) {
-		String oldEscapedValue = escapedValue;
-		escapedValue = newEscapedValue;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_STRING_LITERAL__ESCAPED_VALUE, oldEscapedValue, escapedValue));
-	}
-
-	private boolean stringLiteralSet;
-	
-	public String getLiteralValue() {
-		if (!stringLiteralSet && escapedValue != ESCAPED_VALUE_EDEFAULT) {
-			String s = getEscapedValue();
-			int len = s.length();
-			if (len < 2 || s.charAt(0) != '\"' || s.charAt(len-1) != '\"' ) {
-				throw new IllegalArgumentException();
-			}
-			
-			StringBuffer buffer = new StringBuffer(len);
-			int stop = len-1;
-			for (int i = 1; i < stop; i++) {
-				char ati = s.charAt(i);
-				if (ati == '\\') {
-					if (++i < stop) {
-						ati = s.charAt(i);
-						if (ati == 'u') {
-							int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
-							if (i+4 >= stop
-									|| (c1 = Character.getNumericValue(s.charAt(++i))) > 15
-									|| c1 < 0
-									|| (c2 = Character.getNumericValue(s.charAt(++i))) > 15
-									|| c2 < 0
-									|| (c3 = Character.getNumericValue(s.charAt(++i))) > 15
-									|| c3 < 0
-									|| (c4 = Character.getNumericValue(s.charAt(++i))) > 15
-									|| c4 < 0){
-								throw new IllegalArgumentException("illegal string literal");//$NON-NLS-1$
-							} else
-								buffer.append((char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4));
-						} else
-							buffer.append(PTCharacterLiteralImpl.getCharEscaped(ati));
-					} else
-						throw new IllegalArgumentException("illegal string literal");//$NON-NLS-1$
-				} else
-					buffer.append(ati);	
-			}
-			
-			stringLiteralSet = true;
-			setLiteralValueGen(buffer.toString());
-		}
-		
-		return getLiteralValueGen();
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getLiteralValueGen() {
-		return literalValue;
-	}
-
-	public void setLiteralValue(String newLiteralValue) {
-		stringLiteralSet = true;
-		setLiteralValueGen(newLiteralValue);
-		
-		StringBuffer b = new StringBuffer(newLiteralValue.length()+2);
-		b.append('\"'); // opening delimiter
-		int stop = newLiteralValue.length();
-		for (int i = 0; i < stop; i++) {
-			PTCharacterLiteralImpl.appendCharacter(newLiteralValue.charAt(i), b);	
-		}
-		b.append('\"'); // closing delimiter
-		setEscapedValueGen(b.toString());
-		
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLiteralValueGen(String newLiteralValue) {
-		String oldLiteralValue = literalValue;
-		literalValue = newLiteralValue;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_STRING_LITERAL__LITERAL_VALUE, oldLiteralValue, literalValue));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_STRING_LITERAL__ESCAPED_VALUE:
-				return getEscapedValue();
-			case InstantiationPackage.PT_STRING_LITERAL__LITERAL_VALUE:
-				return getLiteralValue();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_STRING_LITERAL__ESCAPED_VALUE:
-				setEscapedValue((String)newValue);
-				return;
-			case InstantiationPackage.PT_STRING_LITERAL__LITERAL_VALUE:
-				setLiteralValue((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_STRING_LITERAL__ESCAPED_VALUE:
-				setEscapedValue(ESCAPED_VALUE_EDEFAULT);
-				return;
-			case InstantiationPackage.PT_STRING_LITERAL__LITERAL_VALUE:
-				setLiteralValue(LITERAL_VALUE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_STRING_LITERAL__ESCAPED_VALUE:
-				return ESCAPED_VALUE_EDEFAULT == null ? escapedValue != null : !ESCAPED_VALUE_EDEFAULT.equals(escapedValue);
-			case InstantiationPackage.PT_STRING_LITERAL__LITERAL_VALUE:
-				return LITERAL_VALUE_EDEFAULT == null ? literalValue != null : !LITERAL_VALUE_EDEFAULT.equals(literalValue);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-
-} //StringLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTThisLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTThisLiteralImpl.java
deleted file mode 100644
index 35be71a..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTThisLiteralImpl.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTThisLiteralImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EClass;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTThisLiteral;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>This Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class PTThisLiteralImpl extends PTExpressionImpl implements PTThisLiteral {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTThisLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTThisLiteral();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}	
-
-} //ThisLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTTypeLiteralImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTTypeLiteralImpl.java
deleted file mode 100644
index 93c1c13..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/PTTypeLiteralImpl.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: PTTypeLiteralImpl.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.*;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.PTTypeLiteral;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Type Literal</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.PTTypeLiteralImpl#getType <em>Type</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PTTypeLiteralImpl extends PTExpressionImpl implements PTTypeLiteral {
-	/**
-	 * The default value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TYPE_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getType()
-	 * @generated
-	 * @ordered
-	 */
-	protected String type = TYPE_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PTTypeLiteralImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getPTTypeLiteral();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getType() {
-		return type;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setType(String newType) {
-		String oldType = type;
-		type = newType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PT_TYPE_LITERAL__TYPE, oldType, type));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_TYPE_LITERAL__TYPE:
-				return getType();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_TYPE_LITERAL__TYPE:
-				setType((String)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_TYPE_LITERAL__TYPE:
-				setType(TYPE_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PT_TYPE_LITERAL__TYPE:
-				return TYPE_EDEFAULT == null ? type != null : !TYPE_EDEFAULT.equals(type);
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	public String toString() {
-		return super.toString();	// Really want toString to be final at PTExpression, but EMF doesn't allow it.
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.instantiation.impl.ExpressionImpl#accept0(org.eclipse.jem.internal.instantiation.ParseVisitor)
-	 */
-	protected void accept0(ParseVisitor visitor) {
-		visitor.visit(this);
-		visitor.endVisit(this);
-	}
-} //TypeLiteralImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/ParseTreeAllocationImpl.java b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/ParseTreeAllocationImpl.java
deleted file mode 100644
index fd838f5..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/ParseTreeAllocationImpl.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.instantiation.impl;
-/*
- *  $RCSfile: ParseTreeAllocationImpl.java,v $
- *  $Revision: 1.5 $  $Date: 2005/10/03 19:20:41 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.jem.internal.instantiation.PTExpression;
-import org.eclipse.jem.internal.instantiation.InstantiationPackage;
-import org.eclipse.jem.internal.instantiation.ParseTreeAllocation;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Parse Tree Allocation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.internal.instantiation.impl.ParseTreeAllocationImpl#getExpression <em>Expression</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ParseTreeAllocationImpl extends JavaAllocationImpl implements ParseTreeAllocation {
-	/**
-	 * The cached value of the '{@link #getExpression() <em>Expression</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExpression()
-	 * @generated
-	 * @ordered
-	 */
-	protected PTExpression expression = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ParseTreeAllocationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return InstantiationPackage.eINSTANCE.getParseTreeAllocation();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PTExpression getExpression() {
-		return expression;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetExpression(PTExpression newExpression, NotificationChain msgs) {
-		PTExpression oldExpression = expression;
-		expression = newExpression;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION, oldExpression, newExpression);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExpression(PTExpression newExpression) {
-		if (newExpression != expression) {
-			NotificationChain msgs = null;
-			if (expression != null)
-				msgs = ((InternalEObject)expression).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION, null, msgs);
-			if (newExpression != null)
-				msgs = ((InternalEObject)newExpression).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION, null, msgs);
-			msgs = basicSetExpression(newExpression, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION, newExpression, newExpression));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION:
-					return basicSetExpression(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION:
-				return getExpression();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION:
-				setExpression((PTExpression)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION:
-				setExpression((PTExpression)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case InstantiationPackage.PARSE_TREE_ALLOCATION__EXPRESSION:
-				return expression != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		return getExpression() != null ? getExpression().toString() : super.toString();
-	}
-
-	public boolean isParseTree() {
-		return true;
-	}
-
-} //ParseTreeAllocationImpl
diff --git a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/messages.properties b/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/messages.properties
deleted file mode 100644
index 43b44ad..0000000
--- a/plugins/org.eclipse.jem/javainst/org/eclipse/jem/internal/instantiation/impl/messages.properties
+++ /dev/null
@@ -1,11 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-NaiveExpressionFlattener_InvalidExpression= invalid: "{0}"
diff --git a/plugins/org.eclipse.jem/model/instance.ecore b/plugins/org.eclipse.jem/model/instance.ecore
deleted file mode 100644
index 6a4ff9f..0000000
--- a/plugins/org.eclipse.jem/model/instance.ecore
+++ /dev/null
@@ -1,498 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ecore:EPackage xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="instantiation"
-    nsURI="http:///org/eclipse/jem/internal/instantiation.ecore" nsPrefix="org.eclipse.jem.internal.instantiation">
-  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-    <details key="documentation" value="Java Instantiation Package"/>
-  </eAnnotations>
-  <eClassifiers xsi:type="ecore:EClass" name="IJavaDataTypeInstance" instanceClassName="org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance"
-      abstract="true" interface="true" eSuperTypes="#//IJavaInstance"/>
-  <eClassifiers xsi:type="ecore:EClass" name="IJavaInstance" instanceClassName="org.eclipse.jem.internal.instantiation.base.IJavaInstance"
-      abstract="true" interface="true"/>
-  <eClassifiers xsi:type="ecore:EClass" name="IJavaObjectInstance" instanceClassName="org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance"
-      abstract="true" interface="true" eSuperTypes="#//IJavaInstance">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This interface is the instance of an java object in the java model."/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="JavaAllocation" abstract="true">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This class is the abstract base class of the allocation class. It is the value of the &quot;allocation&quot; property on a Java Object so that the actual allocation can be controlled. For example, there could be one for just init string, or one for serialized."/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="InitStringAllocation" eSuperTypes="#//JavaAllocation">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This is used when the allocation string can be parsed by the remote vm. It uses the allocString."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="initString" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the initialization string for this object."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ImplicitAllocation" eSuperTypes="#//JavaAllocation">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This class is for an implicit allocation where the object comes from the feature of another object. It is the live Java value from the remote vm."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="parent" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.emf.ecore/model/Ecore.ecore#//EObject"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="feature" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.emf.ecore/model/Ecore.ecore#//EStructuralFeature"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ParseTreeAllocation" eSuperTypes="#//JavaAllocation">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Allocations via Parse Trees."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="expression" lowerBound="1"
-        eType="#//PTExpression" containment="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTExpression" abstract="true"/>
-  <eClassifiers xsi:type="ecore:EClass" name="PTArrayAccess" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Array access. e.g. x[3]. &#xD;&#xA;&#xD;&#xA;Unlike AST, the entire expression of type x[3][4] will be done in one expression rather than having a separate ArrayAccess for each dimension. This is just a simplification. This can only be used if it is a simple array access where it is of the form {expression}[expression][expression]."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="array" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The expression representing the array to access."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="indexes" lowerBound="1"
-        upperBound="-1" eType="#//PTExpression" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The expressions representing the indexes of the access."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTArrayCreation" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Array Creation expression, e.g. new int[3] or new java.langString[][] {{&quot;a&quot;}, {&quot;b&quot;}}"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The fully-qualified type, e.g. int[][] or java.lang.String[], including the number of dimension brackets."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="dimensions" upperBound="-1"
-        eType="#//PTExpression" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The list of expressions for the dimensions. You can have [3][4][] but [][33] is invalid. So for each dimension that has an expression, there will be an entry in the list, in the correct order. When you reach the empty dimensions, the list will end too. "/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="initializer" eType="#//PTArrayInitializer"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the initializer, if any, for this array. E.g. new int[] {2,3}. It is the {2,3}."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTArrayInitializer" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Array initialization expression. This is the entire expression, e.g. {2, 3}, or {{2,3}, 4}. In the second case, the {2,3} will be an ArrayInitializer contained within the expressions list for the top ArrayInitializer."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="expressions" upperBound="-1"
-        eType="#//PTExpression" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This isthe list of expressions within the initializer, e.g. {2, 3}, or {{2,3}, 4}. In the first case it will be two NumberLiterals. In the second case, the {2,3} will be an ArrayInitializer, followed by a NumberLiteral."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTBooleanLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This represents a primitive boolean literal, i.e. true or false directly in the code."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="booleanValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The value of the literal."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTCastExpression" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Cast expression, e.g. (short) 10"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the fully-qualified type of the cast, e.g. int or java.lang.String"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="expression" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The expression being casted."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTCharacterLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This represents a primitive character expression, e.g. 'a' or '\r'."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="escapedValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the escaped character. In other words the literal exactly as it is in the java file. E.g. 'a' or '\r'. Including the surrounding single quotes themselves."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="charValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EChar"
-        transient="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The actual primitive character without the quotes. Escape are evaluated and turned into their character value. This is a transient field. If not set when created when queried it will create it. Typically it will be set when created from an AST node since the node already has evaluated it."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTClassInstanceCreation" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Class instance creation expression. E.g. new String(&quot;a&quot;)"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the type of the class. E.g. java.lang.String. This should be fully-qualified for allocation purposes. It should also be in reflection format, i.e. if X is an inner class of j.Y, then the type here should be &quot;j.Y$X&quot;. "/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="arguments" upperBound="-1"
-        eType="#//PTExpression" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The arguments to the constructor."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTConditionalExpression" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="The test Expresson, e.g. (x=3) ? 1 : 2"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="condition" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The condition expression."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="true" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The true expression"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="false" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The false expression."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTFieldAccess" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Access a field expression, e.g. java.awt.Color.red"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="receiver" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The expression representing the object that the field is in, e.g. java.awt.Color."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="field" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The name of the field being accessed, e.g. red."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTInfixExpression" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="An expression with an operator that has two operands, e.g. 3 + 4."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="leftOperand" eType="#//PTExpression"
-        containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="operator" eType="#//PTInfixOperator">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The operator, e.g. +"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rightOperand" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The right expression. i.e. 4 of &quot;3 + 4&quot;"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="extendedOperands" upperBound="-1"
-        eType="#//PTExpression" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Used when there are a series of infix operations of the same operator, e.g. 1 + 2 + 3 + 4. 1 and 2 will go into left and right, while {3, 4} will go into the extended operands. "/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EEnum" name="PTInfixOperator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Enumerator for the operator on an InfixExpression."/>
-    </eAnnotations>
-    <eLiterals name="TIMES">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="* operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="DIVIDE" value="1">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="/ operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="REMAINDER" value="2">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="% operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="PLUS" value="3">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="+ operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="MINUS" value="4">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="- operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="LEFT_SHIFT" value="5">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="&lt;&lt; operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="RIGHT_SHIFT_SIGNED" value="6">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=">> operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="RIGHT_SHIFT_UNSIGNED" value="7">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=">>> operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="LESS" value="8">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="&lt;  operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="GREATER" value="9">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="> operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="LESS_EQUALS" value="10">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="&lt;= operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="GREATER_EQUALS" value="11">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=">= operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="EQUALS" value="12">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="== operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="NOT_EQUALS" value="13">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="!= operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="XOR" value="14">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="^ operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="AND" value="15">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="&amp; operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="OR" value="16">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="|  operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="CONDITIONAL_AND" value="17">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="&amp;&amp; operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="CONDITIONAL_OR" value="18">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="|| operator"/>
-      </eAnnotations>
-    </eLiterals>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTInstanceof" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Instanceof expression, e.g. x instanceof java.lang.String"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="operand" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The value to test, e.g. x in x instanceof java.lang.String"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The type of the instance test, e.g. java.lang.String. It must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTMethodInvocation" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="MethodInvocation expression, e.g. x.getY(3)"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="receiver" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Who the method is invoked against. This may be not set, which means &quot;this&quot;. It may also be a Name, which would mean a class like &quot;java.lang.String&quot;"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The name of the method being invoked."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="arguments" upperBound="-1"
-        eType="#//PTExpression" containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The list of arguments, if any, to the method."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTName" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This represents a name. This can happen for the receiver of a method invocation, e.g. x.getY() or java.lang.String.valueOf(10). In these cases you would have a name of &quot;x&quot; or &quot;java.lang.String&quot;."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The name, which can be a type or a variable. If it is a type, then  it must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTNullLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Represents the expression &quot;null&quot;"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTNumberLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Represent a number primitive literal, e.g. 10. One optimization that will be performed is that if an expression is of the form +number or -number, it will be converted from a PrefixExpression with a NumberLiteral to just a NumberLiteral. This will simplify the model."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="token" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The token value, e.g. 10, 10d, or -10.75"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTParenthesizedExpression" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="An expression within parenthesis, e.g. (x+3)"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="expression" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The expression wrapped by the parenthesis, e.g. (x+3) then the expression is &quot;x+3&quot;"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTPrefixExpression" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="A one operand operator, where the operator comes before the operand, e.g. - (x+3). In AST, even -3 is modeled as a PrefixExpression of operator &quot;-&quot; and expression of NumberLiteral(3). But we optimize this away and just use a NumberLiteral(-3) directly instead."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="operator" eType="#//PTPrefixOperator">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The operator of this expression."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="expression" eType="#//PTExpression"
-        containment="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The expression that the operator is applied to."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EEnum" name="PTPrefixOperator">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="The prefix expression operator. We are not modeling ++ and --."/>
-    </eAnnotations>
-    <eLiterals name="PLUS">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="+ operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="MINUS" value="1">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="- operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="COMPLEMENT" value="2">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="~ operator"/>
-      </eAnnotations>
-    </eLiterals>
-    <eLiterals name="NOT" value="3">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="! operator"/>
-      </eAnnotations>
-    </eLiterals>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTStringLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Representation of a string literal, e.g. &quot;asdf&quot;."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="escapedValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the escaped string. In other words the literal exactly as it is in the java file. E.g. &quot;ab&quot; or &quot;c\r&quot;. Including the surrounding quotes themselves."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="literalValue" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"
-        transient="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The actual string without the quotes. Escape are evaluated and turned into their character value. This is a transient field. If not set when created when queried it will create it. Typically it will be set when created from an AST node since the node already has evaluated it."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTThisLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Represents &quot;this&quot;, e.g. this.getX() will be a MethodInvocation with the receiver being a ThisLiteral. We can't handle the format XYZ.this because that is for inner classes and we don't support that right now."/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTTypeLiteral" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This represents a literal of the form j.XYZ.class. For instance in a method invocation x.getX(jXYZ.class) the argument will be a TypeLiteral."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="type" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The type of the literal.  It must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTInvalidExpression" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This is used when we have some expression we just can't evaluate for our purposes. It allows us to tell the evaluation what is actually wrong. It should be placed as the root expression to prevent processing much of the tree and then finally fail."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="message" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="A message as to why it is invalid."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTInstanceReference" eSuperTypes="#//PTExpression">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="reference" lowerBound="1"
-        eType="#//IJavaInstance"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PTAnonymousClassDeclaration" eSuperTypes="#//PTExpression">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="An anonymous class declaration. Currently we only store the &#xD;&#xA;entire declaration as a string, including the &quot;new AClass() {...}&quot;."/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="declaration" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="The declaration text."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="imports" upperBound="-1"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString" transient="true">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="This is the imports needed in the main class by this declaration. This is a transient attribute. It is not serialized, nor is it parsed into from existing code. Its only purpose is to help code generation on a brand new declaration to know what imports should be added to the main class."/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-</ecore:EPackage>
diff --git a/plugins/org.eclipse.jem/model/instance.genmodel b/plugins/org.eclipse.jem/model/instance.genmodel
deleted file mode 100644
index e1c764a..0000000
--- a/plugins/org.eclipse.jem/model/instance.genmodel
+++ /dev/null
@@ -1,141 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<genmodel:GenModel xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.jem/javainst"
-    editDirectory="/org.eclipse.jem.edit/src" editorDirectory="/org.eclipse.jem.editor/src"
-    modelPluginID="" modelName="instance" editPluginClass="org.eclipse.jem.internal.instantiation.provider.instanceEditPlugin"
-    editorPluginClass="org.eclipse.jem.internal.instantiation.presentation.instanceEditorPlugin"
-    updateClasspath="false" booleanFlagsField="eFlags" booleanFlagsReservedBits="8"
-    importerID="org.eclipse.emf.importer.rose" usedGenPackages="../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore">
-  <foreignModel>..\rose\instance.mdl</foreignModel>
-  <foreignModel>WorkspaceRoot</foreignModel>
-  <foreignModel>../..</foreignModel>
-  <genPackages prefix="Instantiation" basePackage="org.eclipse.jem.internal" adapterFactory="false"
-      ecorePackage="instance.ecore#/">
-    <genEnums ecoreEnum="instance.ecore#//PTInfixOperator">
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/TIMES"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/DIVIDE"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/REMAINDER"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/PLUS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/MINUS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/LEFT_SHIFT"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/RIGHT_SHIFT_SIGNED"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/RIGHT_SHIFT_UNSIGNED"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/LESS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/GREATER"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/LESS_EQUALS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/GREATER_EQUALS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/EQUALS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/NOT_EQUALS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/XOR"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/AND"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/OR"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/CONDITIONAL_AND"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTInfixOperator/CONDITIONAL_OR"/>
-    </genEnums>
-    <genEnums ecoreEnum="instance.ecore#//PTPrefixOperator">
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTPrefixOperator/PLUS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTPrefixOperator/MINUS"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTPrefixOperator/COMPLEMENT"/>
-      <genEnumLiterals ecoreEnumLiteral="instance.ecore#//PTPrefixOperator/NOT"/>
-    </genEnums>
-    <genClasses ecoreClass="instance.ecore#//IJavaDataTypeInstance"/>
-    <genClasses ecoreClass="instance.ecore#//IJavaInstance"/>
-    <genClasses ecoreClass="instance.ecore#//IJavaObjectInstance"/>
-    <genClasses ecoreClass="instance.ecore#//JavaAllocation"/>
-    <genClasses ecoreClass="instance.ecore#//InitStringAllocation">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//InitStringAllocation/initString"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//ImplicitAllocation">
-      <genFeatures notify="false" createChild="false" ecoreFeature="ecore:EReference instance.ecore#//ImplicitAllocation/parent"/>
-      <genFeatures notify="false" createChild="false" ecoreFeature="ecore:EReference instance.ecore#//ImplicitAllocation/feature"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//ParseTreeAllocation">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//ParseTreeAllocation/expression"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTExpression"/>
-    <genClasses ecoreClass="instance.ecore#//PTArrayAccess">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTArrayAccess/array"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTArrayAccess/indexes"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTArrayCreation">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTArrayCreation/type"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTArrayCreation/dimensions"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTArrayCreation/initializer"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTArrayInitializer">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTArrayInitializer/expressions"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTBooleanLiteral">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTBooleanLiteral/booleanValue"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTCastExpression">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTCastExpression/type"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTCastExpression/expression"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTCharacterLiteral">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTCharacterLiteral/escapedValue"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTCharacterLiteral/charValue"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTClassInstanceCreation">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTClassInstanceCreation/type"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTClassInstanceCreation/arguments"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTConditionalExpression">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTConditionalExpression/condition"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTConditionalExpression/true"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTConditionalExpression/false"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTFieldAccess">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTFieldAccess/receiver"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTFieldAccess/field"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTInfixExpression">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTInfixExpression/leftOperand"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTInfixExpression/operator"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTInfixExpression/rightOperand"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTInfixExpression/extendedOperands"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTInstanceof">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTInstanceof/operand"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTInstanceof/type"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTMethodInvocation">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTMethodInvocation/receiver"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTMethodInvocation/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTMethodInvocation/arguments"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTName">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTName/name"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTNullLiteral"/>
-    <genClasses ecoreClass="instance.ecore#//PTNumberLiteral">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTNumberLiteral/token"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTParenthesizedExpression">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTParenthesizedExpression/expression"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTPrefixExpression">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTPrefixExpression/operator"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference instance.ecore#//PTPrefixExpression/expression"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTStringLiteral">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTStringLiteral/escapedValue"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTStringLiteral/literalValue"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTThisLiteral"/>
-    <genClasses ecoreClass="instance.ecore#//PTTypeLiteral">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTTypeLiteral/type"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTInvalidExpression">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTInvalidExpression/message"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTInstanceReference">
-      <genFeatures notify="false" createChild="false" ecoreFeature="ecore:EReference instance.ecore#//PTInstanceReference/reference"/>
-    </genClasses>
-    <genClasses ecoreClass="instance.ecore#//PTAnonymousClassDeclaration">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTAnonymousClassDeclaration/declaration"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute instance.ecore#//PTAnonymousClassDeclaration/imports"/>
-    </genClasses>
-  </genPackages>
-</genmodel:GenModel>
diff --git a/plugins/org.eclipse.jem/model/java.ecore b/plugins/org.eclipse.jem/model/java.ecore
deleted file mode 100644
index 2f8aa37..0000000
--- a/plugins/org.eclipse.jem/model/java.ecore
+++ /dev/null
@@ -1,353 +0,0 @@
-<?xml version="1.0" encoding="ASCII"?>
-<ecore:EPackage xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="java"
-    nsURI="java.xmi" nsPrefix="org.eclipse.jem.java">
-  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-    <details key="documentation" value="Changes to synch up with Java3e:&#xD;&#xA;- deleted JavaElement, BodyElement which didn't add anything useful&#xD;&#xA;- deleted NestedClass and the association which described nesting, contents can be used instead&#xD;&#xA;- deleted extends/extendedBy which is replaced with MOF subtype/supertype&#xD;&#xA;- deleted the clumsy main diagram&#xD;&#xA;- moved the MOF inheritance details to the MOF binding diagram&#xD;&#xA;- deleted &quot;final&quot; on JavaParameter, don't know what that was supposed to be&#xD;&#xA;- deleted the Category junk&#xD;&#xA;- changed the Block-typed attributes on Field, Method, Initializer to be associations to Block&#xD;&#xA;&#xD;&#xA;Outstanding questions/issues:&#xD;&#xA;- JavaParameterKind should go away if we get the base Parameter kind fixed up&#xD;&#xA;"/>
-  </eAnnotations>
-  <eClassifiers xsi:type="ecore:EClass" name="JavaClass" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EClass">
-    <eOperations name="isNested" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eOperations name="getField" eType="#//Field">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return an Field with the passed name, or null."/>
-      </eAnnotations>
-      <eParameters name="fieldName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    </eOperations>
-    <eOperations name="getFieldExtended" eType="#//Field">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=" Return an Field with the passed name from this JavaClass or any supertypes.&#xD;&#xA;&#xD;&#xA;Return null if a Field named fieldName is not found."/>
-      </eAnnotations>
-      <eParameters name="fieldName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    </eOperations>
-    <eOperations name="getFieldNamed" eType="#//Field">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return an Field with the passed name, or null."/>
-      </eAnnotations>
-      <eParameters name="fieldName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    </eOperations>
-    <eOperations name="getFieldsExtended" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return all fields, including those from supertypes."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getMethod" eType="#//Method">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the method of this name and these parameters. It will not look up the supertype hierarchy."/>
-      </eAnnotations>
-      <eParameters name="methodName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-      <eParameters name="parameterTypes" eType="#//JTypeList">
-        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-          <details key="documentation" value="List of parameter types."/>
-        </eAnnotations>
-      </eParameters>
-    </eOperations>
-    <eOperations name="getMethodElementSignatures" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return a List of Strings that represent MethodElement signatures from most general to most specific."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getMethodExtended" eType="#//Method">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the method of this name and these parameters. It will look up the supertype hierarchy."/>
-      </eAnnotations>
-      <eParameters name="methodName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-      <eParameters name="parameterTypes" eType="#//JTypeList">
-        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-          <details key="documentation" value="List of parameter types."/>
-        </eAnnotations>
-      </eParameters>
-    </eOperations>
-    <eOperations name="getMethodsExtended" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return all methods, including those from supertypes."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getOnlySpecificMethods" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return a List of Methods that begins with @aMethodNamePrefix and is not included in the @excludedNames list. If @aMethodNamePrefix is null, all methods will be returned.&#xD;&#xA;"/>
-      </eAnnotations>
-      <eParameters name="aMethodNamePrefix" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-      <eParameters name="excludedNames" eType="#//JTypeList"/>
-    </eOperations>
-    <eOperations name="getPublicMethod" eType="#//Method">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return a method matching the name, and non-return parameters with fully qualified types matching all the types in the list, if it exists.  It will not look up the supertype hierarchy."/>
-      </eAnnotations>
-      <eParameters name="methodName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-      <eParameters name="parameterTypes" eType="#//JTypeList">
-        <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-          <details key="documentation" value="List of parameter types."/>
-        </eAnnotations>
-      </eParameters>
-    </eOperations>
-    <eOperations name="getPublicMethods" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return all methods, it will not go up the supertype hierarchy."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getPublicMethodsExtended" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return all public methods, including those from supertypes."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getPublicMethodsNamed" eType="#//JTypeList">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Returns a filtered list on the methods of this class, having a name equal to that of the parameter."/>
-      </eAnnotations>
-      <eParameters name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    </eOperations>
-    <eOperations name="getSupertype" eType="#//JavaClass"/>
-    <eOperations name="implementsInterface" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Test whether the receiver implements the passed interface (or one of its supertypes)."/>
-      </eAnnotations>
-      <eParameters name="interfaceType" eType="#//JavaClass"/>
-    </eOperations>
-    <eOperations name="infoString" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return a string showing our details."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="inheritsFrom" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Tests whether this class inherits from the passed in class."/>
-      </eAnnotations>
-      <eParameters name="javaClass" eType="#//JavaClass"/>
-    </eOperations>
-    <eOperations name="isExistingType" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Does this type exist."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="isInterface" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this an interface."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="setSupertype">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set the supertype."/>
-      </eAnnotations>
-      <eParameters name="javaclass" eType="#//JavaClass"/>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="kind" eType="#//TypeKind"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="public" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="final" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="implementsInterfaces" upperBound="-1"
-        eType="#//JavaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="classImport" upperBound="-1"
-        eType="#//JavaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="packageImports" upperBound="-1"
-        eType="#//JavaPackage"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fields" upperBound="-1"
-        eType="#//Field" containment="true" eOpposite="#//Field/javaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="methods" upperBound="-1"
-        eType="#//Method" containment="true" eOpposite="#//Method/javaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="initializers" upperBound="-1"
-        eType="#//Initializer" containment="true" eOpposite="#//Initializer/javaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="declaredClasses" upperBound="-1"
-        eType="#//JavaClass" eOpposite="#//JavaClass/declaringClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="declaringClass" eType="#//JavaClass"
-        eOpposite="#//JavaClass/declaredClasses"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="javaPackage" eType="#//JavaPackage"
-        changeable="false" volatile="true" transient="true" eOpposite="#//JavaPackage/javaClasses"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="events" upperBound="-1"
-        eType="#//JavaEvent" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="allEvents" upperBound="-1"
-        eType="#//JavaEvent" volatile="true" transient="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Initializer">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="isStatic" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBooleanObject"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="javaClass" eType="#//JavaClass"
-        transient="true" eOpposite="#//JavaClass/initializers"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="source" eType="#//Block"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="JavaParameter" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EParameter">
-    <eOperations name="isArray" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this parameter type an array type."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="isReturn" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this a return parameter."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getJavaType" eType="#//JTypeJavaHelpers"/>
-    <eOperations name="getQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="final" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="parameterKind" eType="#//JavaParameterKind"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Method" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EOperation">
-    <eOperations name="getContainingJavaClass" eType="#//JavaClass">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return the java class that this method is defined in."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getMethodElementSignature" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return a String with the the method name and its parameters. e.g. &lt;code> setFirstName(java.lang.String) &lt;/code> .&#xD;&#xA; "/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getParameter" eType="#//JavaParameter">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return a Parameter with the passed name, or null."/>
-      </eAnnotations>
-      <eParameters name="parameterName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    </eOperations>
-    <eOperations name="getReturnType" eType="#//JTypeJavaHelpers">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the return type."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="setReturnType">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set the return type"/>
-      </eAnnotations>
-      <eParameters name="type" eType="#//JTypeJavaHelpers"/>
-    </eOperations>
-    <eOperations name="getSignature" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Replicate the functionality of java.lang.reflect.Method.toString().&#xD;&#xA;&#xD;&#xA;Returns a string describing this Method.  The string is formatted as the method access modifiers, if any, followed by the method return type, followed by a space, followed by the class declaring the method, followed by a period, followed by the method name, followed by a parenthesized, comma-separated list of the method's formal parameter types. If the method throws checked exceptions, the parameter list is followed by a space, followed by the word throws followed by a comma-separated list of the thrown exception types.&#xD;&#xA;&#xD;&#xA;For example:&#xD;&#xA;&#xD;&#xA;    public boolean java.lang.Object.equals(java.lang.Object)&#xD;&#xA;&#xD;&#xA;The access modifiers are placed in canonical order as specified by &quot;The Java Language Specification&quot;.  This is public, &lt;tt>protected&lt;/tt> or &lt;tt>private&lt;/tt> first, and then other modifiers in the following order: &lt;tt>abstract&lt;/tt>, &lt;tt>static&lt;/tt>, &lt;tt>final&lt;/tt>, &lt;tt>synchronized&lt;/tt> &lt;tt>native&lt;/tt>.&#xD;&#xA;"/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="isGenerated" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Returns true if the method is system generated.&#xD;&#xA;This is usually determined by the @generated tag in the comment."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="setIsGenerated">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set the isGenerated flag."/>
-      </eAnnotations>
-      <eParameters name="generated" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    </eOperations>
-    <eOperations name="isVoid" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this a void return type method."/>
-      </eAnnotations>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="abstract" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="native" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="synchronized" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="final" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="constructor" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="static" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="javaVisibility" eType="#//JavaVisibilityKind"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="parameters" upperBound="-1"
-        eType="#//JavaParameter" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="javaExceptions" upperBound="-1"
-        eType="#//JavaClass"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="javaClass" eType="#//JavaClass"
-        transient="true" eOpposite="#//JavaClass/methods"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="source" eType="#//Block"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Field" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//ETypedElement">
-    <eOperations name="getContainingJavaClass" eType="#//JavaClass">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the class that this field is within."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="isArray" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this field an array type."/>
-      </eAnnotations>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="final" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="static" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="javaVisibility" eType="#//JavaVisibilityKind"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="transient" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="volatile" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="javaClass" eType="#//JavaClass"
-        transient="true" eOpposite="#//JavaClass/fields"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="initializer" eType="#//Block"
-        containment="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EEnum" name="TypeKind">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="UNDEFINED=1 CLASS=2 INTERFACE=3 EXCEPTION=4"/>
-    </eAnnotations>
-    <eLiterals name="UNDEFINED"/>
-    <eLiterals name="CLASS" value="1"/>
-    <eLiterals name="INTERFACE" value="2"/>
-    <eLiterals name="EXCEPTION" value="3"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Block">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="source" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="contents" upperBound="-1"
-        eType="#//Block" containment="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Comment" eSuperTypes="#//Block"/>
-  <eClassifiers xsi:type="ecore:EClass" name="Statement" eSuperTypes="#//Block"/>
-  <eClassifiers xsi:type="ecore:EClass" name="JavaPackage" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EPackage">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="javaClasses" upperBound="-1"
-        eType="#//JavaClass" changeable="false" volatile="true" transient="true" eOpposite="#//JavaClass/javaPackage"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EEnum" name="JavaVisibilityKind">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="PACKAGE=1&#xD;&#xA;PUBLIC=2&#xD;&#xA;PRIVATE=3&#xD;&#xA;PROTECTED=4"/>
-    </eAnnotations>
-    <eLiterals name="PUBLIC"/>
-    <eLiterals name="PRIVATE" value="1"/>
-    <eLiterals name="PROTECTED" value="2"/>
-    <eLiterals name="PACKAGE" value="3"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EEnum" name="JavaParameterKind">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="IN=0&#xD;&#xA;OUT=1&#xD;&#xA;INOUT=2&#xD;&#xA;RETURN=3"/>
-    </eAnnotations>
-    <eLiterals name="IN"/>
-    <eLiterals name="OUT" value="1"/>
-    <eLiterals name="INOUT" value="2"/>
-    <eLiterals name="RETURN" value="3"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="JavaDataType" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EClass">
-    <eOperations name="getDefaultValueString" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Return the default string representing the default value of the primitive."/>
-      </eAnnotations>
-    </eOperations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ArrayType" eSuperTypes="#//JavaClass">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="Describes a Java Array type&#xD;&#xA;   For multi-dimensional arrays, it is unlikely that the component type will be&#xD;&#xA;   specified directly.  This would require instantiating a chain of component types&#xD;&#xA;   such as String[][][][]->String[][][]->String[][]->String[]->String.&#xD;&#xA;&#xD;&#xA;  The component type relationship will be computed if the finalComponentType&#xD;&#xA;  and array dimensions is specified.&#xD;&#xA; &#xD;&#xA;  For this reason, the preferred way to create is through the JavaRefFactory factory method:&#xD;&#xA;       createArrayType(JavaClass finalComponentType, int dimensions)"/>
-    </eAnnotations>
-    <eOperations name="getFinalComponentType" eType="#//JTypeJavaHelpers">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the final component type for this Array Type.&#xD;&#xA;&#xD;&#xA;In order to ensure a unique instance, we will resolve this type using reflection. It turns out to be most efficient to just do this by trimming the name."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="getComponentTypeAsHelper" eType="#//JTypeJavaHelpers">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Get the component type of this array. &#xD;&#xA;&#xD;&#xA;If this is a multi-dimensional array, the component type will be the nested array type."/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="isPrimitiveArray" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Is this an array of java primitives"/>
-      </eAnnotations>
-    </eOperations>
-    <eOperations name="setComponentType">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="Set the component type."/>
-      </eAnnotations>
-      <eParameters name="helperComponentType" eType="#//JTypeJavaHelpers"/>
-    </eOperations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="arrayDimensions" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentType" lowerBound="1"
-        eType="ecore:EClass ../../org.eclipse.emf.ecore/model/Ecore.ecore#//EClassifier"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EDataType" name="JTypeJavaHelpers" instanceClassName="org.eclipse.jem.java.JavaHelpers">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="This interface is a common interface between JavaClass and JavaDataType plus some common helper methods."/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EDataType" name="JTypeList" instanceClassName="java.util.List">
-    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-      <details key="documentation" value="java.util.List type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="JavaEvent" abstract="true" eSuperTypes="../../org.eclipse.emf.ecore/model/Ecore.ecore#//EStructuralFeature"/>
-</ecore:EPackage>
diff --git a/plugins/org.eclipse.jem/model/javaModel.genmodel b/plugins/org.eclipse.jem/model/javaModel.genmodel
deleted file mode 100644
index c94fd6a..0000000
--- a/plugins/org.eclipse.jem/model/javaModel.genmodel
+++ /dev/null
@@ -1,174 +0,0 @@
-<?xml version="1.0" encoding="ASCII"?>
-<genmodel:GenModel xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.jem/mofjava"
-    editDirectory="/org.eclipse.jem.edit/src" editorDirectory="/org.eclipse.jem.editor/src"
-    modelPluginID="" modelName="Java" modelPluginClass="" editPluginClass="java.provider.JavaEditPlugin"
-    editorPluginClass="java.presentation.JavaEditorPlugin" updateClasspath="false"
-    booleanFlagsField="eFlags" booleanFlagsReservedBits="8" usedGenPackages="../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore">
-  <foreignModel>..\rose\javaModel.mdl</foreignModel>
-  <foreignModel>WorkspaceRoot</foreignModel>
-  <foreignModel>../..</foreignModel>
-  <genPackages prefix="JavaRef" basePackage="org.eclipse.jem" classPackageSuffix="internal.impl"
-      ecorePackage="java.ecore#/">
-    <genEnums ecoreEnum="java.ecore#//TypeKind">
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//TypeKind/UNDEFINED"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//TypeKind/CLASS"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//TypeKind/INTERFACE"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//TypeKind/EXCEPTION"/>
-    </genEnums>
-    <genEnums ecoreEnum="java.ecore#//JavaVisibilityKind">
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaVisibilityKind/PUBLIC"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaVisibilityKind/PRIVATE"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaVisibilityKind/PROTECTED"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaVisibilityKind/PACKAGE"/>
-    </genEnums>
-    <genEnums ecoreEnum="java.ecore#//JavaParameterKind">
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaParameterKind/IN"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaParameterKind/OUT"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaParameterKind/INOUT"/>
-      <genEnumLiterals ecoreEnumLiteral="java.ecore#//JavaParameterKind/RETURN"/>
-    </genEnums>
-    <genDataTypes ecoreDataType="java.ecore#//JTypeJavaHelpers"/>
-    <genDataTypes ecoreDataType="java.ecore#//JTypeList"/>
-    <genClasses ecoreClass="java.ecore#//JavaClass">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//JavaClass/kind"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//JavaClass/public"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//JavaClass/final"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/implementsInterfaces"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/classImport"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/packageImports"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//JavaClass/fields"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//JavaClass/methods"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//JavaClass/initializers"/>
-      <genFeatures property="None" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/declaredClasses"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/declaringClass"/>
-      <genFeatures property="Readonly" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/javaPackage"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//JavaClass/events"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaClass/allEvents"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/isNested"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getField">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getField/fieldName"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getFieldExtended">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getFieldExtended/fieldName"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getFieldNamed">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getFieldNamed/fieldName"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getFieldsExtended"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getMethod">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getMethod/methodName"/>
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getMethod/parameterTypes"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getMethodElementSignatures"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getMethodExtended">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getMethodExtended/methodName"/>
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getMethodExtended/parameterTypes"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getMethodsExtended"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getOnlySpecificMethods">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getOnlySpecificMethods/aMethodNamePrefix"/>
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getOnlySpecificMethods/excludedNames"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getPublicMethod">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getPublicMethod/methodName"/>
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getPublicMethod/parameterTypes"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getPublicMethods"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getPublicMethodsExtended"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getPublicMethodsNamed">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/getPublicMethodsNamed/name"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/getSupertype"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/implementsInterface">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/implementsInterface/interfaceType"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/infoString"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/inheritsFrom">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/inheritsFrom/javaClass"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/isExistingType"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/isInterface"/>
-      <genOperations ecoreOperation="java.ecore#//JavaClass/setSupertype">
-        <genParameters ecoreParameter="java.ecore#//JavaClass/setSupertype/javaclass"/>
-      </genOperations>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//Initializer">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Initializer/isStatic"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//Initializer/javaClass"/>
-      <genFeatures property="Readonly" createChild="false" ecoreFeature="ecore:EReference java.ecore#//Initializer/source"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//JavaParameter">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//JavaParameter/final"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//JavaParameter/parameterKind"/>
-      <genOperations ecoreOperation="java.ecore#//JavaParameter/isArray"/>
-      <genOperations ecoreOperation="java.ecore#//JavaParameter/isReturn"/>
-      <genOperations ecoreOperation="java.ecore#//JavaParameter/getJavaType"/>
-      <genOperations ecoreOperation="java.ecore#//JavaParameter/getQualifiedName"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//Method">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/abstract"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/native"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/synchronized"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/final"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/constructor"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/static"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Method/javaVisibility"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//Method/parameters"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//Method/javaExceptions"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//Method/javaClass"/>
-      <genFeatures property="Readonly" createChild="false" ecoreFeature="ecore:EReference java.ecore#//Method/source"/>
-      <genOperations ecoreOperation="java.ecore#//Method/getContainingJavaClass"/>
-      <genOperations ecoreOperation="java.ecore#//Method/getMethodElementSignature"/>
-      <genOperations ecoreOperation="java.ecore#//Method/getParameter">
-        <genParameters ecoreParameter="java.ecore#//Method/getParameter/parameterName"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//Method/getReturnType"/>
-      <genOperations ecoreOperation="java.ecore#//Method/setReturnType">
-        <genParameters ecoreParameter="java.ecore#//Method/setReturnType/type"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//Method/getSignature"/>
-      <genOperations ecoreOperation="java.ecore#//Method/isGenerated"/>
-      <genOperations ecoreOperation="java.ecore#//Method/setIsGenerated">
-        <genParameters ecoreParameter="java.ecore#//Method/setIsGenerated/generated"/>
-      </genOperations>
-      <genOperations ecoreOperation="java.ecore#//Method/isVoid"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//Field">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Field/final"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Field/static"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Field/javaVisibility"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Field/transient"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Field/volatile"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//Field/javaClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//Field/initializer"/>
-      <genOperations ecoreOperation="java.ecore#//Field/getContainingJavaClass"/>
-      <genOperations ecoreOperation="java.ecore#//Field/isArray"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//Block">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Block/source"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//Block/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference java.ecore#//Block/contents"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//Comment"/>
-    <genClasses ecoreClass="java.ecore#//Statement"/>
-    <genClasses ecoreClass="java.ecore#//JavaPackage">
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference java.ecore#//JavaPackage/javaClasses"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//JavaDataType">
-      <genOperations ecoreOperation="java.ecore#//JavaDataType/getDefaultValueString"/>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//ArrayType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute java.ecore#//ArrayType/arrayDimensions"/>
-      <genFeatures property="Readonly" createChild="false" ecoreFeature="ecore:EReference java.ecore#//ArrayType/componentType"/>
-      <genOperations ecoreOperation="java.ecore#//ArrayType/getFinalComponentType"/>
-      <genOperations ecoreOperation="java.ecore#//ArrayType/getComponentTypeAsHelper"/>
-      <genOperations ecoreOperation="java.ecore#//ArrayType/isPrimitiveArray"/>
-      <genOperations ecoreOperation="java.ecore#//ArrayType/setComponentType">
-        <genParameters ecoreParameter="java.ecore#//ArrayType/setComponentType/helperComponentType"/>
-      </genOperations>
-    </genClasses>
-    <genClasses ecoreClass="java.ecore#//JavaEvent"/>
-  </genPackages>
-</genmodel:GenModel>
diff --git a/plugins/org.eclipse.jem/mofjava/javaadapters.properties b/plugins/org.eclipse.jem/mofjava/javaadapters.properties
deleted file mode 100644
index c8d8a81..0000000
--- a/plugins/org.eclipse.jem/mofjava/javaadapters.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem/mofjava/javaadapters.properties,v $
-# $Revision: 1.5 $  $Date: 2005/08/24 20:20:25 $
-#
-
-Failed_reflecting_values_ERROR_       = IWAV0002E Failed reflecting values.
-Could_Not_Reflect_Methods_ERROR_      = IWAV0003E Could not reflect methods for {0} because one of the methods references a type that could not be loaded.  Exception: {1}
-Could_Not_Reflect_Constructors_ERROR_ = IWAV0142E Could not reflect constructors for {0} because one of the methods references a type that could not be loaded.  Exception: {1}
-Could_Not_Reflect_Fields_ERROR_       = IWAV0143E Could not reflect fields for {0} because one of the fields is a type that could not be loaded. Exception: {1}
-Error_Looking_Up_Type_ERROR_          = IWAV0144E Error looking up type {0}.  Exception: {1}
-Error_Introspecting_Flags_ERROR_      = IWAV0145E Error introspecting flags on {0}.  Exception: {1}
-Error_Setting_GenFlag_ERROR_          = IWAV0153E Error setting the generated flag on {0}.  Exception: {1}
-Java_Inh_Cycle_ERROR_                 = IWAV0154E Detected an inheritance cycle when {0} trys to extend {1}.
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/core/JEMPlugin.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/core/JEMPlugin.java
deleted file mode 100644
index 08cf242..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/core/JEMPlugin.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JEMPlugin.java,v $
- *  $Revision: 1.8 $  $Date: 2005/08/24 20:20:25 $ 
- */
-package org.eclipse.jem.internal.core;
-
-import org.eclipse.core.runtime.Plugin;
-import org.osgi.framework.BundleContext;
-
-import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jem.util.logger.proxyrender.EclipseLogger;
-
-
-/**
- * org.eclipse.jem plugin
- */
-public class JEMPlugin extends Plugin {
-
-	private static JEMPlugin PLUGIN;
-	private Logger logger;
-	
-	public JEMPlugin() {
-		PLUGIN = this;
-	}
-	
-	public static JEMPlugin getPlugin() {
-		return PLUGIN;
-	}
-
-	
-	/* (non-Javadoc)
-	 * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
-	 */
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-		logger = EclipseLogger.getEclipseLogger(this);		
-	}
-	
-	public Logger getLogger() {
-		return logger;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/IJavaClassAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/IJavaClassAdaptor.java
deleted file mode 100644
index 95cbb90..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/IJavaClassAdaptor.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: IJavaClassAdaptor.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:25 $ 
- */
-/**
- * Insert the type's description here.
- * Creation date: (8/27/2001 1:17:46 PM)
- * @author: Administrator
- */
-public interface IJavaClassAdaptor {
-/**
- * Return true if the sourceType is null or if
- * it is a binary type.
- */
-boolean isSourceTypeFromBinary() ;
-/**
- * Return true if the sourceType can be found.
- */
-boolean sourceTypeExists() ;
-
-/**
- * Reflect the fields
- * @return <code>true</code> if reflection occurred.
- * 
- * @since 1.0.0
- */
-boolean reflectFieldsIfNecessary();	
-
-/**
- * Reflect the methods.
- * @return <code>true</code> if reflection occurred.
- * 
- * @since 1.0.0
- */
-boolean reflectMethodsIfNecessary();
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/IJavaMethodAdapter.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/IJavaMethodAdapter.java
deleted file mode 100644
index 550630b..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/IJavaMethodAdapter.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IJavaMethodAdapter.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:25 $ 
- */
-package org.eclipse.jem.internal.java.adapters;
- 
-
-/**
- * Used to reflect methods
- * @since 1.0.0
- */
-public interface IJavaMethodAdapter {
-
-	/**
-	 * Reflect the generated if necessary.
-	 * @return <code>true</code> if reflection occurred.
-	 * 
-	 * @since 1.0.0
-	 */
-	public boolean reflectGeneratedIfNecessary();
-	
-	/**
-	 * Reflect the names of the method parameters if necessary.
-	 * @return <code>true</code> if reflection occurred.
-	 * 
-	 * @since 1.0.0
-	 */
-	public boolean reflectParamNamesIfNecessary();
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/InternalReadAdaptable.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/InternalReadAdaptable.java
deleted file mode 100644
index 7b6feb4..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/InternalReadAdaptable.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: InternalReadAdaptable.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:25 $ 
- */
-
-public interface InternalReadAdaptable extends org.eclipse.emf.common.notify.Notifier {
-/**
- * Implementers of this interface need to contain the following method
- * implementations:
- * public Object primRefValue(EObject a) {
- *	return super.getValue(a);
- * }
- * public Object getValue(EObject a) {
- *	return ReflectionAdaptor.getValue(this, a);
- * }
- */
-//public Object primRefValue(EObject a);
-void setReflected(boolean aBoolean);
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaArrayTypeReflectionAdapter.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaArrayTypeReflectionAdapter.java
deleted file mode 100644
index 60c6281..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaArrayTypeReflectionAdapter.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaArrayTypeReflectionAdapter.java,v $
- *  $Revision: 1.8 $  $Date: 2005/09/14 23:30:35 $ 
- */
-package org.eclipse.jem.internal.java.adapters;
-
-import java.util.List;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.jem.java.ArrayType;
-import org.eclipse.jem.java.InheritanceCycleException;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaHelpers;
-import org.eclipse.jem.java.JavaRefFactory;
-import org.eclipse.jem.java.internal.impl.ArrayTypeImpl;
-
-/**
- * Array type reflection adapter. Since arrays are very constant we don't need any fancy reflection to the source type (class object). It really
- * doesn't do anything. It is just here so that it exists. Everything is constant or depends on the final component type.
- * 
- * @since 1.0.0
- */
-public class JavaArrayTypeReflectionAdapter extends JavaReflectionAdaptor implements IJavaClassAdaptor {
-
-	public JavaArrayTypeReflectionAdapter(Notifier target) {
-		super(target);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#getReflectionSource()
-	 */
-	public Object getReflectionSource() {
-		return null; // There isn't any for arrays.
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-	 */
-	public boolean hasReflectionSource() {
-		// This method is used to determine if valid, so we pass on to use the final component.
-		ArrayType jh = (ArrayType) getTarget();
-		JavaHelpers fc = jh.getFinalComponentType();
-		return (fc.isPrimitive() || ((JavaClass) fc).isExistingType());
-	}
-	
-	public boolean hasCachedReflectionSource() {
-		ArrayType jh = (ArrayType) getTarget();
-		JavaHelpers fc = jh.getFinalComponentType();
-		if(fc.isPrimitive())
-		    return true;
-		else {
-		    JavaReflectionAdaptor reflectionAdaptor = (JavaReflectionAdaptor) EcoreUtil.getExistingAdapter(fc, ReflectionAdaptor.TYPE_KEY);
-		    return (reflectionAdaptor != null) ? reflectionAdaptor.hasCachedReflectionSource() : false;		    
-		} 
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.java.adapters.ReflectionAdaptor#reflectValues()
-	 */
-	public boolean reflectValues() {
-		ArrayTypeImpl at = (ArrayTypeImpl) getTarget();
-
-		// Arrays are always:
-		//		final
-		//		Supertype of java.lang.Object
-		//		implements java.lang.Cloneable, java.io.Serializable
-		at.setFinal(true);
-		try {
-			at.setSupertype((JavaClass) JavaRefFactory.eINSTANCE.reflectType("java.lang.Object", (EObject) getTarget())); //$NON-NLS-1$
-		} catch (InheritanceCycleException e) {
-		}
-		List list = at.getImplementsInterfacesGen();
-		list.add(JavaRefFactory.eINSTANCE.createClassRef("java.lang.Cloneable")); //$NON-NLS-1$
-		list.add(JavaRefFactory.eINSTANCE.createClassRef("java.io.Serializable")); //$NON-NLS-1$
-		return super.reflectValues();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#flushReflectedValues(boolean)
-	 */
-	protected boolean flushReflectedValues(boolean clearCachedModelObject) {
-		ArrayTypeImpl at = (ArrayTypeImpl) getTarget();
-		at.getImplementsInterfacesGen().clear();
-		return true;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.java.adapters.IJavaClassAdaptor#isSourceTypeFromBinary()
-	 */
-	public boolean isSourceTypeFromBinary() {
-		return false;
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.java.adapters.IJavaClassAdaptor#reflectFieldsIfNecessary()
-	 */
-	public synchronized boolean reflectFieldsIfNecessary() {
-		return reflectValuesIfNecessary();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.java.adapters.IJavaClassAdaptor#reflectMethodsIfNecessary()
-	 */
-	public synchronized boolean reflectMethodsIfNecessary() {
-		return reflectValuesIfNecessary();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.internal.java.adapters.IJavaClassAdaptor#sourceTypeExists()
-	 */
-	public boolean sourceTypeExists() {
-		return hasReflectionSource();
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionAdapterFactory.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionAdapterFactory.java
deleted file mode 100644
index 9bb360d..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionAdapterFactory.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: JavaReflectionAdapterFactory.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.emf.common.notify.Adapter;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EPackage;
-
-import org.eclipse.jem.java.JavaRefPackage;
-public abstract class JavaReflectionAdapterFactory extends AdapterFactoryImpl {
-	// Maintain a mapping of the source objects to the adaptors which have
-	// relfected from them.  This allows a flush operation to force those
-	// adapters to re-reflect.
-	protected HashMap reflected = new HashMap();
-	/**
-	 * Key for the type of adapters that this factory creates. (Used in isFactoryForType()).
-	 */
-	public static final String TYPE_KEY = ReadAdaptor.TYPE_KEY;
-	protected boolean isBusyIteratingReflected = false;
-	protected Map registerQueue;
-	protected List unregisterQueue;
-/**
- * JavaReflectionAdapterFactory constructor comment.
- */
-public JavaReflectionAdapterFactory() {
-	super();
-}
-public Adapter createAdapter(Notifier target) {
-	ReflectionAdaptor adapter = null;
-	EObject object = (EObject) target;
-	JavaRefPackage pack = getJavaRefPackage();
-	if (object.eClass() == pack.getJavaClass())
-		adapter = createJavaClassAdaptor(target);
-	else
-		if (object.eClass() == pack.getArrayType())
-			adapter = createArrayTypeAdaptor(target);
-		else
-			if (object.eClass() == pack.getMethod())
-				adapter = createJavaMethodAdaptor(target);
-			else
-				if (object.eClass() == pack.getField())
-					adapter = createJavaFieldAdaptor(target);
-	return adapter;
-}
-
-protected ReflectionAdaptor createArrayTypeAdaptor(Notifier target) {
-	return new JavaArrayTypeReflectionAdapter(target);
-}
-
-protected abstract ReflectionAdaptor createJavaClassAdaptor(Notifier target) ;
-protected abstract ReflectionAdaptor createJavaFieldAdaptor(Notifier target) ;
-protected abstract ReflectionAdaptor createJavaMethodAdaptor(Notifier target) ;
-// Flush the adapter for a source object
-public Notification disAssociateSource(String source) {
-	return disAssociateSource(source, true);
-}
-
-public Notification disAssociateSource(String source, boolean doNotify) {
-	JavaReflectionAdaptor a = (JavaReflectionAdaptor) reflected.get(source);
-	Notification notification = null;
-	if (a != null) {
-		if (doNotify)
-			a.releaseSourceType();
-		else
-			notification = a.releaseSourceTypeNoNotification();
-	}
-	return notification;
-}
-public void flushAll() {}
-// Flush the adapter for a source object
-public void flushReflection(String source) {}
-protected JavaRefPackage getJavaRefPackage() {
-	return (JavaRefPackage) EPackage.Registry.INSTANCE.getEPackage(JavaRefPackage.eNS_URI);
-}
-public void registerReflection(String source, ReflectionAdaptor adapter) {
-	if (isBusyIteratingReflected) {
-		if (registerQueue == null)
-			registerQueue = new HashMap();
-		registerQueue.put(source, adapter);
-	} else
-		reflected.put(source, adapter);
-}
-public void unregisterReflection(String source) {
-	if (isBusyIteratingReflected) {
-		if (unregisterQueue == null)
-			unregisterQueue = new ArrayList();
-		unregisterQueue.add(source);
-	} else
-		reflected.remove(source);
-}
-public void disAssociateSourcePlusInner(String source) {
-	disAssociateSourcePlusInner(source, true);
-}
-
-public Notification disAssociateSourcePlusInner(String source, boolean doNotify) {
-	isBusyIteratingReflected = true;
-	Notification notification = null;
-	try {
-		String innerName = source + '$';
-		Iterator it = reflected.entrySet().iterator();
-		Map.Entry entry;
-		String key;
-		JavaReflectionAdaptor adaptor;
-		while (it.hasNext()) {
-			entry = (Map.Entry) it.next();
-			key = (String) entry.getKey();
-			if (key.equals(source) || key.startsWith(innerName)) {
-				adaptor = (JavaReflectionAdaptor) reflected.get(key);
-				if (adaptor != null) {
-					if (doNotify)
-						adaptor.releaseSourceType();
-					else
-						notification = adaptor.releaseSourceTypeNoNotification();
-				}
-			}
-		}
-	} finally {
-		finishedIteratingReflected();
-	}
-	return notification;
-}
-
-protected void finishedIteratingReflected() {
-	isBusyIteratingReflected = false;
-	if (unregisterQueue != null && !unregisterQueue.isEmpty()) {
-		for (int i = 0; i < unregisterQueue.size(); i++) {
-			reflected.remove(unregisterQueue.get(i));
-		}
-		unregisterQueue.clear();
-	}
-	if (registerQueue != null && !registerQueue.isEmpty()) {
-		Iterator it = registerQueue.entrySet().iterator();
-		Map.Entry entry;
-		while (it.hasNext()) {
-			entry = (Map.Entry) it.next();
-			reflected.put(entry.getKey(), entry.getValue());
-		}
-		registerQueue.clear();
-	}
-}
-public boolean isFactoryForType(Object type) {
-	return TYPE_KEY.equals(type);
-}
-}
-
-
-
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionAdaptor.java
deleted file mode 100644
index 50a07d6..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionAdaptor.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: JavaReflectionAdaptor.java,v $
- *  $Revision: 1.13 $  $Date: 2005/09/14 23:30:35 $ 
- */
-import java.util.List;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.util.logger.proxy.Logger;
-	
-/**
- * 
- */
-public abstract class JavaReflectionAdaptor extends ReflectionAdaptor {
-	private static final String C_METHOD_DEFAULT_CTOR = String.valueOf(C_METHOD_PARM_DELIMITER) + S_CONSTRUCTOR_TOKEN;
-	protected static final String LEFT_BRACKET = "[";//$NON-NLS-1$
-	
-	/**
-	 * Special notification event type. This is sent against a JavaClass (as the target) whenever flush of the reflection occurs. It will be
-	 * sent under the notification event type of REFLECTION_EVENT.
-	 * @since 1.1.0
-	 */
-	public static final EAttribute FLUSH_REFLECTION_EVENT = EcorePackage.eINSTANCE.getEcoreFactory().createEAttribute();
-	
-	/**
-	 * Special notification event type. This is sent against a JavaClass (as the target) whenever flush of a new class (i.e. 
-	 * no source was found) of the reflection occurs. It will be
-	 * sent under the notification event type of REFLECTION_EVENT.
-	 * @since 1.1.0
-	 */
-	public static final EAttribute FLUSH_NEW_REFLECTION_EVENT = EcorePackage.eINSTANCE.getEcoreFactory().createEAttribute();
-
-	/*
-	 * Fill in the name. Not really needed but it would be nice.
-	 */
-	static {
-		FLUSH_REFLECTION_EVENT.setName("flushReflectedValues");    //$NON-NLS-1$
-		FLUSH_NEW_REFLECTION_EVENT.setName("flushNewReflectedValues"); //$NON-NLS-1$
-	}
-	protected boolean hasFlushed = false;
-	protected boolean isFlushing = false;
-/**
- * JavaReflectionAdapter constructor comment.
- */
-public JavaReflectionAdaptor() {
-	super();
-}
-/**
- * JavaReflectionAdapter constructor comment.
- * @param target org.eclipse.emf.common.notify.Notifier
- */
-public JavaReflectionAdaptor(org.eclipse.emf.common.notify.Notifier target) {
-	super(target);
-}
-/**
- * createBlock - instantiate a Block containing the passed source
- */
-public Block createBlock(String name, String sourceString) {
-	Block newBlock = getJavaFactory().createBlock();
-	newBlock.setName(name + "_" + "block");//$NON-NLS-2$//$NON-NLS-1$
-	newBlock.setSource(sourceString);
-	return newBlock;
-}
-/**
- * setSuper - set our supertype here, implemented interface are handled separately
- */
-public JavaClass createJavaClassRef(String targetName) {
-	JavaClass ref = org.eclipse.jem.java.internal.impl.JavaRefFactoryImpl.getActiveFactory().createJavaClass();
-   JavaURL javaurl = new JavaURL(targetName);
-  ((InternalEObject) ref).eSetProxyURI(URI.createURI(javaurl.getFullString()));
-   return ref;
-}
-/**
- * createJavaParameter - instantiate a Java Parameter based on the passed name and type name (a simple name, NOT A SIGNATURE!!!)
- * The id for a parameter has to be complex in order to be parsable into class, method, and parm.
- * It is created by appending the parm name to the method id, with a known separator.
- * It will look something like "Foo.doSomething(java.lang.Integer-arg0"
- */
-public JavaParameter createJavaParameter(Method parentMethod, String parmName, String parmTypeName) {
-	JavaParameter newParm = getJavaFactory().createJavaParameter();
-	if (parmName!=null)
-	   newParm.setName(parmName);
-// ((InternalEObject)newParm).eSetID(parentMethod.eID() + C_METHODID_PARMID_DELIMITER + parmName);
-	String classRefString = parmTypeName;
-	newParm.setEType(createJavaClassRef(classRefString));
-	return newParm;
-}
-/**
- * This method will return a List of dimensions for a typeName.
- * For example "foo[][]" would return a List of Integers
- * 1, 1.  At some point we may want to actually capture the size
- * for Fields but we would need the initializer source to determine that.
- */
-public List getArrayDimensions(String typeName) {
-	List dimensions = new java.util.ArrayList();
-	if (typeName != null) {
-		int begin = 0;
-		int index = -1;
-		while (begin < typeName.length()) {
-			index = typeName.indexOf(LEFT_BRACKET, begin);
-			if (index > -1) {
-				dimensions.add(new Integer(1));
-				begin = index + 1;
-			} else {
-				begin = typeName.length();
-			}
-		}
-	}
-	return dimensions;
-}
-/* Get the Java Factory
- */
-protected static JavaRefFactory getJavaFactory() {
-	return ((org.eclipse.jem.java.JavaRefPackage)EPackage.Registry.INSTANCE.getEPackage(org.eclipse.jem.java.JavaRefPackage.eNS_URI)).getJavaRefFactory();
-}
-public abstract Object getReflectionSource();
-/**
- * getTypeNamesFromMethodUUID - Pull the parm type names out of a method ID
- * 		It will be in the form: "simpleclass.methodName(com.fronk.Parm1_type,parm2type"
- */
-protected static String[] getTypeNamesFromMethodID(String methodID) {
-	if (methodID.charAt(methodID.length()-1) == C_METHOD_PARM_DELIMITER || methodID.endsWith(C_METHOD_DEFAULT_CTOR))
-		return emptyStringArray;
-		
-	// Count the parms first.  The number of parms is the number of occurrences of ',' + 1
-	int numParms = 1;
-	int pos = -1;
-	// Skip the '.' after classname
-	pos = methodID.indexOf(C_CLASS_MEMBER_DELIMITER, ++pos);
-	// Look for the start of the parms
-	int parmPos = methodID.indexOf(C_METHOD_PARM_DELIMITER, ++pos);
-	pos = parmPos;
-	while ((pos = methodID.indexOf(C_PARM_PARM_DELIMITER, ++pos)) != -1)
-		numParms++;
-	String[] parmTypeNames = new String[numParms];
-	// now collect the parm names
-	// skip the method name
-	pos = parmPos;
-	int i = 0, end;
-	do {
-		end = methodID.indexOf(C_PARM_PARM_DELIMITER, pos + 1);
-		// This is the last parameter, we may need to strip a trailing &V for a constructor
-		if (end == -1)
-			end = methodID.indexOf(S_CONSTRUCTOR_TOKEN, pos + 1);
-		// otherwise take the rest of the ID
-		if (end == -1)
-			end = methodID.length();
-		parmTypeNames[i++] = methodID.substring(pos + 1, end);
-	} while ((pos = methodID.indexOf(C_PARM_PARM_DELIMITER, ++pos)) != -1);
-	return parmTypeNames;
-}
-public abstract boolean hasCachedReflectionSource();
-
-public boolean hasReflectionSource() {
-    return getReflectionSource() != null;
-}
-
-/**
- * Subclasses should override.
- *
- */
-public void releaseSourceType(){
-}
-
-/**
- * Subclasses should override.
- * @return
- */
-public Notification releaseSourceTypeNoNotification() {
-	return null;
-}
-
-public static void releaseSourceType(JavaClass javaClass) {
-	if (javaClass == null)
-		return;
-
-	JavaReflectionAdaptor existing = (JavaReflectionAdaptor) retrieveAdaptorFrom(javaClass);
-	if (existing != null)
-		existing.releaseSourceType();
-}
-/*
- * This method is called by a Field Adaptor to set the type of aField
- * to be aTypeName.  aTypeName may contain array brackets which need
- * to be detected in order to set the array dimensions on aField.
- */
-protected void setFieldType(Field aField, String aTypeName) {
-	if (aField != null && aTypeName != null) {
-		String classRefString = aTypeName;
-		aField.setEType(createJavaClassRef(classRefString));
-	}
-}
-public final boolean flushReflectedValuesIfNecessary() {
-	return flushReflectedValuesIfNecessary(false);
-}
-public final boolean flushReflectedValuesIfNecessary(boolean clearCachedModelObject) {
-	Notification not = flushReflectedValuesIfNecessaryNoNotification(clearCachedModelObject);
-	if (not != null)
-		getTarget().eNotify(not);
-	return hasFlushed;
-}
-
-public synchronized Notification flushReflectedValuesIfNecessaryNoNotification(boolean clearCachedModelObject) {
-	if (!hasFlushed && !isFlushing) {
-		boolean isExisting = hasCachedReflectionSource();
-		try {
-			isFlushing = true;
-			hasReflected = false;
-			hasFlushed = flushReflectedValues(clearCachedModelObject);
-		} catch (Throwable e) {
-			hasFlushed = false;
-			Logger.getLogger().log(e);
-			if (e instanceof RuntimeException)
-				throw (RuntimeException) e;
-			else if (e instanceof Error)
-				throw (Error) e;
-			else
-				throw new RuntimeException(e.getMessage());
-		} finally {
-			isFlushing = false;
-			postFlushReflectedValuesIfNecessary(isExisting);
-		}
-		return createFlushNotification(isExisting);
-	}
-	return null;
-}
-
-/**
- * @param isExisting
- * @return
- */
-protected Notification createFlushNotification(boolean isExisting) {
-	EStructuralFeature feature = isExisting ? FLUSH_REFLECTION_EVENT : FLUSH_NEW_REFLECTION_EVENT;
-	return new ENotificationImpl((InternalEObject)getTarget(),EVENT, feature, null, null);
-}
-protected void postFlushReflectedValuesIfNecessary(boolean isExisting) {
-}
-/**
- * Subclasses should override to perform the actual clearing of the values.
- */
-protected boolean flushReflectedValues(boolean clearCachedModelObject) {
-	return true;
-}
-/**
- * Return a boolean indicating whether reflection had occurred.
- */
-public boolean reflectValuesIfNecessary() {
-	if (isFlushing)
-		return false;
-	return super.reflectValuesIfNecessary();
-}
-
-/**
- * reflectValues - template method, subclasses override to pump values into target
- */
-public boolean reflectValues() {
-	hasFlushed = false;
-	return true;
-}
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionKey.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionKey.java
deleted file mode 100644
index 4c2b231..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaReflectionKey.java
+++ /dev/null
@@ -1,395 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: JavaReflectionKey.java,v $
- *  $Revision: 1.8 $  $Date: 2005/09/14 23:30:35 $ 
- */
-import java.util.*;
-
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.adapters.IJavaReflectionKey;
-import org.eclipse.jem.java.adapters.IJavaReflectionKeyExtension;
-
-/**
- * This key handles Java Reflection. It creates the appropriate type of entries if
- * they are not already in the resource. There is an extension mechanism for other
- * types of ids that are not recognized by this key. They are registered with the
- * JavaXMIFactory that is used to create these keys, and the factory will pass in
- * a List of these registered extension processers (IJavaReflectionKeyExtension).
- * 
- * Creation date: (10/4/2000 8:24:36 AM)
- * @author: Administrator
- */
-public class JavaReflectionKey implements IJavaReflectionKey {
-	private static final Collection PRIMITIVES = new ArrayList(8);
-
-	static { initializePrimitivesCollection(); }
-	
-	protected JavaXMIFactoryImpl.JavaXMIResource resource; //FB
-	protected List extensions;
-
-public JavaReflectionKey(List extensions, JavaXMIFactoryImpl.JavaXMIResource resource) {
-  this.extensions = extensions;
-  this.resource = resource;
-}
-//FB END
-
-/* 
- * Create an ArrayType instance in the current document
- * Handles the push and pop of the current document.
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#createArrayType()
- */
-public ArrayType createArrayType() {
-	return getJavaFactory().createArrayType();
-}
-/* 
- * Create a JavaClass instance in the current document
- * Handles the push and pop of the current document.
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#createJavaClass()
- */
-public JavaClass createJavaClass() {
-	return getJavaFactory().createJavaClass();
-}
-/**
- * Create a data type and put it in the primitives resource
- */
-protected EClassifier getJavaDataType(String typeName) {
-	JavaDataType result = getJavaFactory().createJavaDataType();
-	result.setName(typeName);
-	// ((InternalEObject)result).eSetID(typeName);
-	//result.eSetUUID((UUID) null);
-	//result.setEPackage(getPackage());
-	getPackage().getEClassifiers().add(result);
-	resource.setID(result, typeName);	
-	return result;
-}
-/* 
- * Create a Field instance in the current document
- * Handles the push and pop of the current document.
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#createJavaField()
- */
-public Field createJavaField() {
-	return getJavaFactory().createField();
-}
-/* 
- * Create a Method instance in the current document
- * Handles the push and pop of the current document.
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#createJavaMethod()
- */
-public Method createJavaMethod() {
-	return getJavaFactory().createMethod();
-}
-/* 
- * Create a JavaParameter instance in the current document
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#createJavaParameter()
- */
-public JavaParameter createJavaParameter() {
-	return getJavaFactory().createJavaParameter();
-}
-//FB/**
-//FB * Override to try to introspect objects
-//FB * that aren't found using the default mechanism.
-//FB */
-//FBpublic Object get(Object key) {
-//FB 	Object javaObject = super.get(key);
-//FB 	if (javaObject == null) {
-//FB 		javaObject = getObjectFromExtensions((String) key);
-//FB 		if (javaObject == null)
-//FB 			javaObject = getJavaObject((String) key);
-//FB 	}
-//FB	return javaObject;
-//FB}
-
-//FB ADDED
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#get(java.lang.String)
- */
-public Object get(String key) {
-	Object javaObject = getObjectFromExtensions(key);
-	if (javaObject == null)
-		javaObject = getJavaObject(key);
-	return javaObject;
-}
-//FB END
-
-/*
- * Instantiate the named class.
- * If we make it to this point, the class has not yet been instantiated or reflected.
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#getArrayType(java.lang.String)
- */
-public EClassifier getArrayType(String typeName) {
-	ArrayType arrayType = this.createArrayType();
-	arrayType.setName(typeName);
-	// ((InternalEObject)arrayType).eSetID(typeName);
-	//arrayType.eSetUUID((UUID) null);
-	int pos = -1, braces = 0;
-	do {
-		pos = typeName.indexOf("[", pos+1);//$NON-NLS-1$
-		if (pos != -1)
-			braces++;
-	} while (pos != -1);
-	arrayType.setArrayDimensions(braces);
-	//arrayType.setEPackage(getPackage());
-	getPackage().getEClassifiers().add(arrayType);
-	resource.setID(arrayType, typeName);	
-	return arrayType;
-}
-/*
- * Instantiate the named class.
- * If we make it to this point, teh class has not yet been instantiated or reflected.
- */
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#getJavaClass(java.lang.String)
- */
-public EClassifier getJavaClass(String typeName) {
-	JavaClass javaClass = this.createJavaClass();
-	javaClass.setName(typeName);
-	// ((InternalEObject)javaClass).eSetID(javaClass.getName());
-	//javaClass.eSetUUID((UUID) null);
-	// javaClass.setEPackage(getPackage());
-	getPackage().getEClassifiers().add(javaClass);
-	resource.setID(javaClass, typeName);
-	return javaClass;
-}
-/* Get the Java Factory
- */
-protected static JavaRefFactory getJavaFactory() {
-	return JavaRefFactory.eINSTANCE;
-}
-/**
- * This allows for the direct retrieval of fields with the following notation:
- * field: java:/com.ibm.foo#Test.foo
- * 
- */
-protected Field getJavaField(String keyValue) {
-	Field result = null;
-	String className, memberName;
-	int memberDelimiter = keyValue.indexOf(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
-	className = keyValue.substring(0, memberDelimiter);
-	memberName = keyValue.substring(memberDelimiter + 1);
-	EClassifier javaClass = (EClassifier) primGet(className);
-	// if we haven't already instantiated the containing class, then go do it.
-	if (javaClass == null)
-		javaClass = getJavaType(className);
-	if ((javaClass != null) && !((JavaHelpers) javaClass).isPrimitive()) {
-		// We have a class. Now we need to force reflection, this will cause
-		// the JavaReflectionKey to be updated and have the member added to the
-		// list.
-		((JavaClass) javaClass).getFields();
-		//FB result = (Field) super.get(keyValue); // It should now be registered.
-		result = (Field) primGet(keyValue); // It should now be registered.
-		
-		if (result == null) {
-			Field tempField = createJavaField();
-			tempField.setName(memberName);
-			// ((InternalEObject)tempField).eSetID(keyValue);
-			//tempField.eSetUUID((UUID) null);
-			((JavaClass) javaClass).getFields().add(tempField);
-			result = tempField;
-		}
-	}
-	return result;
-}
-/**
- * This allows for the retrieval of methods with the following notation:
- * method: java:/com.ibm.foo#Test.foofoo(
- * 
- */
-protected Method getJavaMethod(String keyValue) {
-	Method result = null;
-	String className, memberName;
-	int memberDelimiter = keyValue.indexOf(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
-	className = keyValue.substring(0, memberDelimiter);
-	int parmDelimiter = keyValue.indexOf(ReflectionAdaptor.C_METHOD_PARM_DELIMITER, memberDelimiter);
-	memberName = keyValue.substring(memberDelimiter + 1, parmDelimiter);
-	EClassifier javaClass = (EClassifier) primGet(className);
-	// if we haven't already instantiated the containing class, then go do it.
-	if (javaClass == null)
-		javaClass = getJavaType(className);
-	if ((javaClass != null) && !((JavaHelpers) javaClass).isPrimitive()) {
-		// We have a class. Now we need to force reflection, this will cause
-		// the JavaReflectionKey to be updated and have the member added to the
-		// list.
-		((JavaClass) javaClass).getMethods();
-		result = (Method) primGet(keyValue); // It should now be registered.
-		
-		if (result == null) {
-			Method tempMethod = createJavaMethod();
-			tempMethod.setName(memberName);
-			resource.setID(tempMethod, keyValue);
-			((JavaClass) javaClass).getMethods().add(tempMethod);
-			result = tempMethod;
-		}
-	}
-	return result;
-}
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#getJavaObject(java.lang.String)
- */
-public EObject getJavaObject(String keyValue) {
-	EObject result = null;
-	int index = keyValue.indexOf(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
-	if (index > 0) {
-		// The reference is to a member: field, method, or parameter.
-		// Take the most specific case first, a parameter.
-		// Only a parameter should contain the methodID to parmID delimiter.
-		boolean isParameter = (keyValue.indexOf(ReflectionAdaptor.C_METHODID_PARMID_DELIMITER, index) != -1);
-		if (isParameter) {
-			result = getJavaParameter(keyValue);
-		} else {
-			// The target is a field or method. If it has a "(", then it is a method.
-			// If it is not found, then we will create a temporary object.
-			int parmStart = keyValue.indexOf(ReflectionAdaptor.C_METHOD_PARM_DELIMITER, index);
-			boolean isField = parmStart == -1;
-			if (isField) {
-				result = getJavaField(keyValue);
-			} else {
-				result = getJavaMethod(keyValue);
-			}
-		}
-	} else {
-		result = getJavaType(keyValue);
-	}
-	return result;
-}
-
-/**
- * See if the extensions can resolve this first.
- */
-protected Object getObjectFromExtensions(String keyValue) {
-	if (extensions != null) {
-		for (Iterator iter = extensions.iterator(); iter.hasNext();) {
-			IJavaReflectionKeyExtension extension = (IJavaReflectionKeyExtension) iter.next();
-			Object obj = extension.getObject(keyValue, this);
-			if (obj != null)
-				return obj;
-		}
-	}
-
-	return null;
-}
-/**
- * This allows for the retrieval of parameters with the following notation:
- * parameter: java:/com.ibm.foo#Test.foofoo(-arg0
- * 
- */
-protected JavaParameter getJavaParameter(String keyValue) {
-	JavaParameter result = null;
-	String parmName;
-	int memberDelimiter = keyValue.indexOf(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
-	int parmDelimiter = keyValue.indexOf(ReflectionAdaptor.C_METHODID_PARMID_DELIMITER, memberDelimiter);
-	parmName = keyValue.substring(parmDelimiter + 1);
-	// getMethod() will find or create a method
-	Method method = this.getJavaMethod(keyValue.substring(parmDelimiter));
-	if (method != null) {
-		result = method.getParameter(parmName);
-		if (result == null) {
-			JavaParameter tempParameter = createJavaParameter();
-			tempParameter.setName(parmName);
-			// ((InternalEObject)tempParameter).eSetID(keyValue);
-			// tempParameter.eSetUUID((UUID) null);
-			method.getParameters().add(tempParameter);
-			result = tempParameter;
-		}
-	}
-	return result;
-}
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#getJavaType(java.lang.String)
- */
-public EClassifier getJavaType(String typeName) {
-	if (isPrimitive(typeName))
-		return getJavaDataType(typeName);
-	else if (isArray(typeName))
-		return getArrayType(typeName);
-	else if (isValidJavaIdentifier(typeName))
-		return getJavaClass(typeName);
-	return null;
-}
-
-protected boolean isValidJavaIdentifier(String typeName) {
-	if (typeName.length() > 0) {
-		if (Character.isJavaIdentifierStart(typeName.charAt(0))) {
-			// Starts with a valid java identifier character.
-			// Now see if the rest are valid.
-			for (int i = 1; i < typeName.length(); i++) {
-				if (!Character.isJavaIdentifierPart(typeName.charAt(i)))
-					return false; // Not valid
-			}
-			return true;
-		}
-	}
-	return false;
-}
-
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#primGet(java.lang.String)
- */
-public Object primGet(String key) {
-	return resource.primGetEObject(key);
-}
-protected EPackage getPackage() {
-	//FB return (EPackage) super.get(JavaPackage.PACKAGE_ID);
-	// return (EPackage) resource.getEObject(JavaPackage.PACKAGE_ID); //FB
-	//return (EPackage) resource.getEObject(JavaPackage.PACKAGE_ID); //FB
-	return (EPackage)EcoreUtil.getObjectByType(resource.getContents(), EcorePackage.eINSTANCE.getEPackage());
-}
-/**
- * Insert the method's description here.
- * Creation date: (10/4/2000 9:56:53 AM)
- */
-private static void initializePrimitivesCollection() {
-	PRIMITIVES.add(N_VOID);
-	PRIMITIVES.add(N_BOOLEAN);
-	PRIMITIVES.add(N_BYTE);
-	PRIMITIVES.add(N_CHAR);
-	PRIMITIVES.add(N_DOUBLE);
-	PRIMITIVES.add(N_FLOAT);
-	PRIMITIVES.add(N_INT);
-	PRIMITIVES.add(N_LONG);
-	PRIMITIVES.add(N_SHORT);
-}
-/* (non-Javadoc)
- * @see org.eclipse.jem.internal.java.adapters.IJavaReflectionKey#isArray(java.lang.String)
- */
-public boolean isArray(String typeName) {
-	return typeName.endsWith("[]");//$NON-NLS-1$
-}
-/**
- * Insert the method's description here.
- * Creation date: (10/4/2000 9:54:23 AM)
- * @return boolean
- * @param typeName java.lang.String
- */
-private boolean isPrimitive(String typeName) {
-	return PRIMITIVES.contains(typeName);
-}
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaXMIFactoryImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaXMIFactoryImpl.java
deleted file mode 100644
index 0fda308..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/JavaXMIFactoryImpl.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: JavaXMIFactoryImpl.java,v $
- *  $Revision: 1.8 $  $Date: 2005/09/14 23:30:35 $ 
- */
-import java.io.IOException;
-import java.util.*;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
-import org.eclipse.jem.java.JavaPackage;
-import org.eclipse.jem.java.JavaRefFactory;
-import org.eclipse.jem.java.adapters.*;
-import org.eclipse.jem.java.internal.impl.JavaFactoryImpl;
-
-/**
- * Factory to create the Resource for the Java protocol.
- * 
- * It allows extensions to the reflection key to be registered with it.
- * 
- * Creation date: (10/4/2000 8:22:23 AM)
- * @author: Administrator
- */
-public class JavaXMIFactoryImpl extends XMIResourceFactoryImpl implements JavaXMIFactory {
-	private static final String SCHEMA_SEPERATOR = ":/"; //$NON-NLS-1$
-	protected List extensions = new ArrayList();
-
-	/**
-	 * JavaXMIFactoryImpl constructor comment.
-	 */
-	public JavaXMIFactoryImpl() {
-		super();
-	}
-
-	
-	public void registerReflectionKeyExtension(IJavaReflectionKeyExtension extension) {
-		extensions.add(extension);
-	}
-
-	
-	public void deregisterReflectionKeyExtension(IJavaReflectionKeyExtension extension) {
-		extensions.remove(extension);
-	}
-
-	protected void createJavaPackage(String packageName, String xmiuri, Resource resource) {
-		// changed to allow a zero-length package name 
-		// for the special case of "java:/#int", etc.
-		JavaRefFactory jfac = JavaRefFactory.eINSTANCE;
-		JavaPackage pack = jfac.createJavaPackage();
-		// Need to create and add special JavaFactory for instantiation to work.
-		JavaFactoryImpl fact = new JavaFactoryImpl();
-		pack.setEFactoryInstance(fact);
-		if (packageName.length() > 0) {
-			// Standard Java package
-			pack.setNsPrefix(packageName);
-			pack.setName(packageName);
-		} else {
-			// Primitive package
-			pack.setNsPrefix(JavaPackage.PRIMITIVE_PACKAGE_NAME);
-			pack.setName(JavaPackage.PRIMITIVE_PACKAGE_NAME);
-		}
-
-		pack.setNsURI(xmiuri);
-		resource.getContents().add(pack);
-		((XMIResource) pack.eResource()).setID(pack, JavaPackage.PACKAGE_ID);
-	}
-	public static class JavaXMIResource extends XMIResourceImpl {
-		protected IJavaReflectionKey reflectionKey;
-
-		public JavaXMIResource(URI uri) {
-			super(uri);
-		}
-
-		public void setReflectionKey(IJavaReflectionKey key) {
-			reflectionKey = key;
-		}
-
-		public void load(Map options) throws IOException {
-			try {
-				super.load(options);
-			} catch (Exception exception) {
-			}
-		}
-
-		public EObject getEObject(String uriFragment) {
-			EObject result = super.getEObject(uriFragment);
-			if (result == null && reflectionKey != null) {
-				result = (EObject) reflectionKey.get(uriFragment);
-			}
-			return result;
-		}
-		
-		/**
-		 * Used by JavaReflectionKey to look directly into ID table to bypass an infinite loop. It will 
-		 * call here because it may not of first been found, but then added, so now is found.
-		 * 
-		 * @param uriFragment
-		 * @return
-		 * 
-		 * @since 1.1.0
-		 */
-		EObject primGetEObject(String uriFragment) {
-			return super.getEObject(uriFragment);
-		}
-		
-		/* (non-Javadoc)
-		 * @see org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl#useIDAttributes()
-		 */
-		protected boolean useIDAttributes() {
-			return false;
-		}
-
-	}
-
-	public Resource createResource(URI uri) {
-		JavaXMIResource resource = new JavaXMIResource(uri);
-		resource.setReflectionKey(new JavaReflectionKey(extensions, resource));
-
-		String uriString = uri.toString();
-		createJavaPackage(stripScheme(uriString), uriString, resource);
-
-		return resource;
-	}
-
-	public static void register() {
-		Resource.Factory.Registry.INSTANCE.getProtocolToFactoryMap().put(JavaXMIFactory.SCHEME, JavaXMIFactory.INSTANCE);
-	}
-
-	/**
-	 * Strip the trailing identifier, if any, from the uri.  An identifier
-	 * begins with # or |.
-	 */
-	private String stripScheme(String uri) {
-		int index = uri.indexOf(SCHEMA_SEPERATOR);
-		if (index != -1)
-			return uri.substring(index + SCHEMA_SEPERATOR.length(), uri.length());
-		else
-			return uri;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/ReadAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/ReadAdaptor.java
deleted file mode 100644
index e6f02d9..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/ReadAdaptor.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: ReadAdaptor.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:25 $ 
- */
-
-import org.eclipse.emf.ecore.EObject;
-/**
- * Extended Adaptor interface which adds support for an adapter
- * providing default values for attributes.
- * Creation date: (6/6/2000 4:41:19 PM)
- * @author: Scott Rich
- */
-public interface ReadAdaptor extends org.eclipse.emf.common.notify.Adapter {
-	public static final String TYPE_KEY = "JavaReflection"; //$NON-NLS-1$
-	public Object getValueIn(EObject object, EObject attribute);
-	public boolean reflectValuesIfNecessary(); //FB
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/ReflectionAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/ReflectionAdaptor.java
deleted file mode 100644
index 92e8396..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/ReflectionAdaptor.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters;
-/*
- *  $RCSfile: ReflectionAdaptor.java,v $
- *  $Revision: 1.12 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import java.util.logging.Level;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-import org.eclipse.jem.util.logger.proxy.Logger;
-/**
- * ReflectionAdaptor - a read adaptor base implementation which does a bulk
- * 	load of relflected values on the first request.
- * 	Subclasses can optimize to defer some properties.
- * 	Properties may also be deferred by setting their values with proxy references,
- * 	for example, for supertype and other referenced types.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public abstract class ReflectionAdaptor extends org.eclipse.emf.common.notify.impl.AdapterImpl implements ReadAdaptor {
-	public static final char C_CLASS_MEMBER_DELIMITER = '.';
-	public static final char C_METHOD_PARM_DELIMITER = '(';
-	public static final char C_METHODID_PARMID_DELIMITER = '-';
-	public static final char C_PARM_PARM_DELIMITER = ',';
-	public static final char PATH_DELIMITER = '/';
-	// SW id contains & in xml file casues exception throw during load
-        // public static final String S_CONSTRUCTOR_TOKEN = "&V";//$NON-NLS-1$
-	public static final String S_CONSTRUCTOR_TOKEN = "_V";//$NON-NLS-1$ // SW
-	// cache a static empty String[] for no parm methods
-	protected static String[] emptyStringArray = new String[0];
-	
-	
-	/**
-	 * Notification event type for special Reflection notifications. This will be the event type for the special ones, like REFLECTION_EVENT.
-	 * The listener should listen for this event type, and then check the feature for the type of special event (like REFLECTION_EVENT).
-	 * @since 1.1.0
-	 */
-	public static final int EVENT = -3456;	// Using a funny number to try to eliminate confliction with any other specials that may of occur from other code on the JavaClass.
-	
-	/**
-	 * Special notification event type. This is sent against a JavaClass (as the target) whenever reflection occurs. It will be
-	 * sent under the notification event type of REFLECTION_EVENT.
-	 * @since 1.1.0
-	 */
-	public static final EAttribute REFLECTION_EVENT = EcoreFactory.eINSTANCE.createEAttribute();
-
-	/*
-	 * Fill in the name. Not really needed but it would be nice.
-	 */
-	static {REFLECTION_EVENT.setName("reflectValues");} //$NON-NLS-1$
-	
-	protected boolean hasReflected = false;
-	protected boolean isReflecting = false;
-public ReflectionAdaptor() {
-	super();
-}
-public ReflectionAdaptor(Notifier target) {
-	super();
-	setTarget(target);
-}
-/**
- * Helper method to ensure full initialization of the target.  Required
- * for serialization.
- */
-public static void forceDeferredReadFor(EObject target) {
-	ReflectionAdaptor adaptor = retrieveAdaptorFrom(target);
-	if (adaptor != null) {
-		adaptor.reflectValuesIfNecessary();
-	}
-}
-protected Resource getTargetResource() {
-	if (getTarget() != null)
-		return ((org.eclipse.emf.ecore.EObject) getTarget()).eResource();
-	return null;
-}
-/**
- * Helper method to fetch the adaptor from the object, and if it exists, get the adapted
- * value for the attribute.  Overloaded for many-sided attributes where the return value would
- * otherwise be an enumeration; in this case will return an Array instead. 
- */
-public static Object getValue(EObject object, EReference attribute) {	
-//FB	ReflectionAdaptor adaptor = retrieveAdaptorFrom(object);
-//FB	if (adaptor != null)
-//FB		return adaptor.getValueIn(object, attribute);
-//FB	return ((IReadAdaptable) object).primRefValue(attribute);
-	return object.eGet(attribute); //FB
-	
-}
-/*Helper method to fetch the adaptor from the object, and if it exists, get the adapted
- *value for the attribute.
- */
-public static Object getValue(EObject object, EObject attribute) {	
-//FB	ReflectionAdaptor adaptor = retrieveAdaptorFrom(object);
-//FB	if (adaptor != null)
-//FB		return adaptor.getValueIn(object, attribute);
-//FB	return ((IReadAdaptable) object).primRefValue(attribute);
-	return object.eGet((EStructuralFeature)attribute); //FB
-}
-/**
- * getValueIn method comment.
- */
-public Object getValueIn(EObject object, EObject attribute) {
-//FB	reflectValuesIfNecessary();
-//FB	return ((IReadAdaptable) object).primRefValue(attribute);
-	return object.eGet((EStructuralFeature)attribute); //FB
-}
-/**
- * isAdaptorForType method comment.
- */
-public boolean isAdapterForType(Object type) {
-	return (type == ReadAdaptor.TYPE_KEY);
-}
-/**
- * reflectValues - template method, subclasses override to pump values into target
- */
-public abstract boolean reflectValues();
-/**
- * Return a boolean indicating whether reflection had occurred.
- */
-public synchronized boolean reflectValuesIfNecessary() {
-	if (!hasReflected && !isReflecting) {
-		try {
-			isReflecting = true;
-			if (!((EObject)getTarget()).eIsProxy())
-				hasReflected = reflectValues();
-			else
-				hasReflected = false;	// AS long we are a proxy, we won't reflect.
-		} catch (Throwable e) {
-			hasReflected = false;
-			Logger logger = Logger.getLogger();
-			if (logger.isLoggingLevel(Level.WARNING)) {
-				logger.log(ResourceHandler.getString("Failed_reflecting_values_ERROR_"), Level.WARNING); //$NON-NLS-1$ = "Failed reflecting values!!!"
-				logger.logWarning(e);
-			}
-		} finally {
-			isReflecting = false;
-			getTarget().eNotify(new ENotificationImpl((InternalEObject)getTarget(), EVENT, REFLECTION_EVENT, null, null, Notification.NO_INDEX));
-		}
-	}
-	return hasReflected;
-}
-public static ReflectionAdaptor retrieveAdaptorFrom(EObject object) {
-	synchronized (object) {
-		return (ReflectionAdaptor)EcoreUtil.getRegisteredAdapter(object, ReadAdaptor.TYPE_KEY);
-	}
-}
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JDKAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JDKAdaptor.java
deleted file mode 100644
index 6e423e8..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JDKAdaptor.java
+++ /dev/null
@@ -1,320 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters.jdk;
-/*
- *  $RCSfile: JDKAdaptor.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:20:25 $ 
- */
-
-import java.lang.reflect.Array;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor;
-/**
- * Insert the type's description here.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public abstract class JDKAdaptor extends JavaReflectionAdaptor {
-	public JavaJDKAdapterFactory adapterFactory;
-	public JDKAdaptor(Notifier target, JavaJDKAdapterFactory anAdapterFactory) {
-		super(target);
-		setAdapterFactory(anAdapterFactory);
-	}
-	/**
-	 * computeMethodID - generate the unique ID to be used to identify a constructor.
-	 * Similar to a Signature, but hopefully more readable.
-	 * The name format will be:
-	 * 	simpleClassName.simpleClassName(com.fronk.ParmType1_parmType2&V
-	 * Note: This implementation is tightly coupled with ReflectionAdapter.getTypeNamesFromMethodID().
-	 *
-	 * It has to be done separately for JDK because Constructors and Methods are different classes.
-	 * However, in the Java Model they are both just Methods with a flag indicating Constructor.
-	 */
-	public static String computeMethodID(java.lang.reflect.Constructor jdkConstructor) {
-		StringBuffer out = new StringBuffer();
-		String className = getSimpleName(jdkConstructor.getDeclaringClass().getName());
-		out.append(className);
-		out.append(C_CLASS_MEMBER_DELIMITER);
-		out.append(computeMethodName(jdkConstructor));
-		out.append(C_METHOD_PARM_DELIMITER);
-		Class[] parmTypes = jdkConstructor.getParameterTypes();
-		for (int i = 0; i < parmTypes.length; i++) {
-			out.append(parmTypes[i].getName());
-			if (i < parmTypes.length - 1)
-				out.append(C_PARM_PARM_DELIMITER);
-		}
-		out.append(S_CONSTRUCTOR_TOKEN); //It's a constructor
-		return out.toString();
-	}
-	/**
-	 * computeMethodID - generate the unique ID to be used to identify a method.
-	 * Similar to a Signature, but hopefully more readable.
-	 * If there are no parms, it will end with a "(" so that it can be distictive from a field.
-	 * The name format will be:
-	 * 	simpleClassName.methodName(com.fronk.ParmType1_parmType2
-	 * Note: This implementation is tightly coupled with ReflectionAdapter.getTypeNamesFromMethodID().
-	 */
-	public static String computeMethodID(java.lang.reflect.Method jdkMethod) {
-		StringBuffer out = new StringBuffer();
-		String className = getSimpleName(jdkMethod.getDeclaringClass().getName());
-		out.append(className);
-		out.append(C_CLASS_MEMBER_DELIMITER);
-		out.append(computeMethodName(jdkMethod));
-		out.append(C_METHOD_PARM_DELIMITER);
-		Class[] parmTypes = jdkMethod.getParameterTypes();
-		for (int i = 0; i < parmTypes.length; i++) {
-			out.append(parmTypes[i].getName());
-			if (i < parmTypes.length - 1)
-				out.append(C_PARM_PARM_DELIMITER);
-		}
-		if (jdkMethod.getDeclaringClass().getName().equals(jdkMethod.getName()))
-			out.append(S_CONSTRUCTOR_TOKEN); //It's a constructor
-		return out.toString();
-	}
-	/**
-	 * computeMethodName - generate the name to be used to identify a constructor.
-	 * For the moment, names are simple, and UUID's are complex.
-	 *
-	 * It has to be done separately for JDK because Constructors and Methods are different classes.
-	 * However, in the Java Model they are both just Methods with a flag indicating Constructor. 
-	 */
-	public static String computeMethodName(java.lang.reflect.Constructor jdkConstructor) {
-		return getSimpleName(jdkConstructor.getName()); // CTOR names come back fully-qualified with package.
-	}
-	/**
-	 * computeMethodName - generate the name to be used to identify a method.
-	 * For the moment, names are simple, and UUID's are complex.
-	 */
-	public static String computeMethodName(java.lang.reflect.Method jdkMethod) {
-		return jdkMethod.getName();
-	}
-	/**
-	 * createJavaField - instantiate a Java Field based on the passed Field
-	 * We are deferring field contents assuming that its adaptor will reflect its details.
-	 */
-	public Field createJavaField(java.lang.reflect.Field reflectedField, XMIResource resource) {
-		Field newField = getJavaFactory().createField();
-		newField.setName(reflectedField.getName());
-		String className = getSimpleName(reflectedField.getDeclaringClass().getName());
-		resource.setID(newField, className + C_CLASS_MEMBER_DELIMITER + reflectedField.getName());
-		return newField;
-	}
-	/**
-	 * createJavaMethod - instantiate a Java Method based on the passed Java Reflection Constructor
-	 * We are deferring method contents assuming that its adaptor will reflect its details.
-	 * We need to store enough info in the empty Method to find its Java source.
-	 * The ID will eventually hold enough info to identify the source, so we use it.
-	 */
-	public Method createJavaMethod(java.lang.reflect.Constructor jdkConstructor, XMIResource resource) {
-		Method newMethod = getJavaFactory().createMethod();
-		// We use a simple name, but a complex ID 
-		newMethod.setName(computeMethodName(jdkConstructor));
-		resource.setID(newMethod, computeMethodID(jdkConstructor));
-		return newMethod;
-	}
-	/**
-	 * createJavaMethod - instantiate a Java Method based on the passed Java Reflection Method
-	 * We are deferring method contents assuming that its adaptor will reflect its details.
-	 * We need to store enough info in the empty Method to find its Java source.
-	 * The ID will eventually hold enough info to identify the source, so we use it.
-	 */
-	public Method createJavaMethod(java.lang.reflect.Method jdkMethod, XMIResource resource) {
-		Method newMethod = getJavaFactory().createMethod();
-		// We use a simple name, but a complex ID 
-		newMethod.setName(computeMethodName(jdkMethod));
-		resource.setID(newMethod, computeMethodID(jdkMethod));
-		return newMethod;
-	}
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (11/07/00 3:43:55 PM)
-	 * @return org.eclipse.jem.java.adapters.JavaJDKAdapterFactory
-	 */
-	public JavaJDKAdapterFactory getAdapterFactory() {
-		return adapterFactory;
-	}
-	public ClassLoader getAlternateClassLoader() {
-		return getAdapterFactory().getContextClassLoader();
-	}
-	/*****************************************************************************
-	* Method to convert the textual form of a primitive type into its Class object
-	*
-	* @param type The primitive type's textual representation
-	*/
-	public static Class getPrimitiveType(String type) {
-		Class c = null;
-
-		if (type.equals(byte.class.getName())) {
-			c = byte.class;
-		} else if (type.equals(short.class.getName())) {
-			c = short.class;
-		} else if (type.equals(int.class.getName())) {
-			c = int.class;
-		} else if (type.equals(long.class.getName())) {
-			c = long.class;
-		} else if (type.equals(float.class.getName())) {
-			c = float.class;
-		} else if (type.equals(double.class.getName())) {
-			c = double.class;
-		} else if (type.equals(boolean.class.getName())) {
-			c = boolean.class;
-		} else if (type.equals(char.class.getName())) {
-			c = char.class;
-		} else if (type.equals(void.class.getName())) {
-			c = void.class;
-		}
-
-		return c;
-	}
-	/**
-	 * Returns the last segment of a '.'-separated qualified name.
-	 * Returns the given name if it is not qualified.
-	 * For example:
-	 * <pre>
-	 * getSimpleName("java.lang.Object") -> "Object"
-	 * </pre>
-	 */
-	public static String getSimpleName(String name) {
-		int lastDot = name.lastIndexOf('.');
-		if (lastDot == -1)
-			return name;
-		return name.substring(lastDot + 1);
-	}
-	public Class getType(JavaHelpers modelClass) {
-		Class result = null;
-		if (modelClass.isArray()) {
-			ArrayType arrayType = (ArrayType) modelClass;
-			Class componentClass = getType(arrayType.getFinalComponentType());
-			result = (Array.newInstance(componentClass, new int[arrayType.getArrayDimensions()])).getClass();
-		} else if (modelClass.isPrimitive()) {
-			result = getType(modelClass.getQualifiedName());
-		} else {
-			result = getType(((JavaClass) modelClass).getQualifiedNameForReflection());
-		}
-		return result;
-	}
-	public Class getType(String qualifiedName) {
-		// Try for a primitive type ("int","char",etc.) first
-		Class primType = getPrimitiveType(qualifiedName);
-		if (primType == null) {
-			// Changed for defect #212147 botp@ausaix19.austin.ibm.com@7630 system.
-			//
-			// Search only one of the following classloaders (the first one that exists) in this order. If not found
-			// in a classloader, it will not roll-over to another class loader. This is to avoid problems where a
-			// class may exist in more than one classloader. You get errors when this happens due to one class that
-			// was found in only one classloader that refers to another class that was found in both classloaders.
-			// They don't match when trying to reflect later.
-			// 1) Alternate classloader (if exists)
-			// 2) Thread context classloader (if exists)
-			// 3) System classloader (if exists)
-			// 4) Class.forName().
-			if (getAlternateClassLoader() != null) {
-				try {
-					return getAlternateClassLoader().loadClass(qualifiedName);
-				} catch (ClassNotFoundException cnf2) {
-					return null;
-				}
-			}
-			
-			ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
-			if (contextClassLoader != null) {
-				try {
-					return contextClassLoader.loadClass(qualifiedName);
-				} catch (ClassNotFoundException e) {
-					return null;
-				}
-			}
-			
-			ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
-			if (systemClassLoader != null) {
-				try {
-					return systemClassLoader.loadClass(qualifiedName);
-				} catch (ClassNotFoundException e) {
-					return null;
-				}
-			}
-			
-			try {
-				return Class.forName(qualifiedName);
-			} catch (ClassNotFoundException e) {
-				return null;
-			}
-		} else
-			return primType;
-	}
-	/*
-	 * Utility routine to paper over array type names
-	 * Borrowed from a package-visibility helper on java.lang.reflect.Field
-	 */
-	static String getTypeName(Class type) {
-		if (type.isArray()) {
-			try {
-				Class cl = type;
-				int dimensions = 0;
-				while (cl.isArray()) {
-					dimensions++;
-					cl = cl.getComponentType();
-				}
-				StringBuffer sb = new StringBuffer();
-				sb.append(cl.getName());
-				for (int i = 0; i < dimensions; i++) {
-					sb.append("[]"); //$NON-NLS-1$
-				}
-				return sb.toString();
-			} catch (Throwable e) { /*FALLTHRU*/
-			}
-		}
-		return type.getName();
-	}
-
-	/*****************************************************************************
-	* Method to convert the textual form of a primitive type into its Class object
-	*
-	* @param type The primitive type's textual representation
-	*/
-	public static Class primitiveForName(String type) {
-		Class c = null;
-
-		if (type.equals(byte.class.getName())) {
-			c = byte.class;
-		} else if (type.equals(short.class.getName())) {
-			c = short.class;
-		} else if (type.equals(int.class.getName())) {
-			c = int.class;
-		} else if (type.equals(long.class.getName())) {
-			c = long.class;
-		} else if (type.equals(float.class.getName())) {
-			c = float.class;
-		} else if (type.equals(double.class.getName())) {
-			c = double.class;
-		} else if (type.equals(boolean.class.getName())) {
-			c = boolean.class;
-		} else if (type.equals(char.class.getName())) {
-			c = char.class;
-		} else if (type.equals(void.class.getName())) {
-			c = void.class;
-		}
-
-		return c;
-	}
-
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (11/07/00 3:43:55 PM)
-	 * @param newAdapterFactory org.eclipse.jem.java.adapters.JavaJDKAdapterFactory
-	 */
-	public void setAdapterFactory(JavaJDKAdapterFactory newAdapterFactory) {
-		adapterFactory = newAdapterFactory;
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaClassJDKAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaClassJDKAdaptor.java
deleted file mode 100644
index 13916fb..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaClassJDKAdaptor.java
+++ /dev/null
@@ -1,341 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaClassJDKAdaptor.java,v $
- *  $Revision: 1.14 $  $Date: 2005/09/14 23:30:35 $ 
- */
-
-package org.eclipse.jem.internal.java.adapters.jdk;
-
-import java.util.List;
-import java.util.logging.Level;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-
-
-import org.eclipse.jem.internal.java.adapters.IJavaClassAdaptor;
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.internal.impl.JavaClassImpl;
-import org.eclipse.jem.util.logger.proxy.Logger;
-
-/**
- * Reflect the class using standard java.reflect methods.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public class JavaClassJDKAdaptor extends JDKAdaptor implements IJavaClassAdaptor {
-
-	protected Class sourceType = null;
-
-	public JavaClassJDKAdaptor(Notifier target, JavaJDKAdapterFactory anAdapterFactory) {
-		super(target, anAdapterFactory);
-	}
-
-	/**
-	 * addFields - reflect our fields
-	 */
-	protected void addFields() {
-		XMIResource resource = (XMIResource) getJavaClassTarget().eResource();
-		List targetFields = getJavaClassTarget().getFieldsGen();
-		targetFields.clear();
-		java.lang.reflect.Field[] fields = {};
-		try {
-			fields = getSourceType().getDeclaredFields();
-		} catch (NoClassDefFoundError error) {
-			System.out.println(ResourceHandler.getString(
-					"Could_Not_Reflect_Fields_ERROR_", new Object[] { getJavaClassTarget().getQualifiedName(), error.getMessage()})); //$NON-NLS-1$
-		}
-		for (int i = 0; i < fields.length; i++) {
-			targetFields.add(createJavaField(fields[i], resource));
-		}
-	}
-
-	/**
-	 * addMethods - reflect our methods
-	 */
-	protected void addMethods() {
-		// We need to first do methods and then do constructors because the JDK treats them as two
-		// different objects, which the Java Model treats them as both Method's.
-		XMIResource resource = (XMIResource) getJavaClassTarget().eResource();
-		List targetMethods = getJavaClassTarget().getMethodsGen();
-		targetMethods.clear();
-		java.lang.reflect.Method[] methods = {};
-		try {
-			methods = getSourceType().getDeclaredMethods();
-		} catch (NoClassDefFoundError error) {
-			Logger logger = Logger.getLogger();
-			if (logger.isLoggingLevel(Level.WARNING)) {
-				logger
-						.log(
-								ResourceHandler
-										.getString(
-												"Could_Not_Reflect_Methods_ERROR_", new Object[] { getJavaClassTarget().getQualifiedName(), error.toString()}), Level.WARNING); //$NON-NLS-1$
-			}
-		}
-		for (int i = 0; i < methods.length; i++) {
-			targetMethods.add(createJavaMethod(methods[i], resource));
-		}
-
-		// Now do the constructors
-		java.lang.reflect.Constructor[] ctors = {};
-		try {
-			ctors = getSourceType().getDeclaredConstructors();
-		} catch (NoClassDefFoundError error) {
-			Logger logger = Logger.getLogger();
-			if (logger.isLoggingLevel(Level.WARNING)) {
-				logger
-						.log(
-								ResourceHandler
-										.getString(
-												"Could_Not_Reflect_Constructors_ERROR_", new Object[] { getJavaClassTarget().getQualifiedName(), error.getMessage()}), Level.WARNING); //$NON-NLS-1$
-			}
-		}
-		for (int i = 0; i < ctors.length; i++) {
-			targetMethods.add(createJavaMethod(ctors[i], resource));
-		}
-
-	}
-
-	/**
-	 * Clear the reflected fields list.
-	 */
-	protected boolean flushFields() {
-		getJavaClassTarget().getFieldsGen().clear();
-		return true;
-	}
-
-	/**
-	 * Clear the implements list.
-	 */
-	protected boolean flushImplements() {
-		getJavaClassTarget().getImplementsInterfacesGen().clear();
-		return true;
-	}
-
-	/**
-	 * Clear the reflected methods list.
-	 */
-	protected boolean flushMethods() {
-		getJavaClassTarget().getMethodsGen().clear();
-		return true;
-	}
-
-	protected boolean flushInnerClasses() {
-		getJavaClassTarget().getDeclaredClassesGen().clear();
-		return true;
-	}
-
-	protected boolean flushModifiers() {
-		JavaClass javaClassTarget = (JavaClass) getTarget();
-		javaClassTarget.setAbstract(false);
-		javaClassTarget.setFinal(false);
-		javaClassTarget.setPublic(false);
-		javaClassTarget.setKind(TypeKind.UNDEFINED_LITERAL);
-		return true;
-	}
-
-	/**
-	 * @see org.eclipse.jem.java.adapters.JavaReflectionAdaptor#flushReflectedValues(boolean)
-	 */
-	protected boolean flushReflectedValues(boolean clearCachedModelObject) {
-		boolean result = flushModifiers();
-		result &= flushSuper();
-		result &= flushImplements();
-		result &= flushMethods();
-		result &= flushFields();
-		result &= flushInnerClasses();
-		return result;
-	}
-
-	/**
-	 * @see org.eclipse.jem.java.adapters.JavaReflectionAdaptor#postFlushReflectedValuesIfNecessary()
-	 */
-	protected void postFlushReflectedValuesIfNecessary(boolean isExisting) {
-		getJavaClassTarget().setReflected(false);
-		super.postFlushReflectedValuesIfNecessary(isExisting);
-	}
-
-	/**
-	 * Set the supertype to be null.
-	 */
-	protected boolean flushSuper() {
-		List targetSupers = getJavaClassTarget().primGetESuperTypes();
-		targetSupers.clear();
-		return true;
-	}
-
-	/**
-	 * Return the target typed to a JavaClass.
-	 */
-	protected JavaClassImpl getJavaClassTarget() {
-		return (JavaClassImpl) getTarget();
-	}
-
-	public Object getReflectionSource() {
-		return getSourceType();
-	}
-    /* (non-Javadoc)
-     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-     */
-    public boolean hasCachedReflectionSource() {
-        return sourceType != null;
-    }
-
-	/**
-	 * getSourceType - return the java.lang.Class which describes our existing Java class
-	 */
-	protected Class getSourceType() {
-		if (sourceType == null) {
-			sourceType = getType((JavaClass) getTarget());
-		}
-		return sourceType;
-	}
-
-	/**
-	 * getValueIn method comment.
-	 */
-	public Object getValueIn(EObject object, EObject attribute) {
-		// At this point, this adapter does not dynamically compute any values,
-		// all values are pushed back into the target on the initial call.
-		return super.getValueIn(object, attribute);
-	}
-
-	/**
-	 * Return true if the sourceType is null or if it is a binary type. Reflection from the JDK is always from binary.
-	 */
-	public boolean isSourceTypeFromBinary() {
-		return true;
-	}
-
-	/**
-	 * reflectValues - template method, subclasses override to pump values into target. on entry: name, containing package (and qualified name), and
-	 * document must be set. Return true if successful JavaClass adaptor: - set modifiers - set name - set reference to super - create methods -
-	 * create fields - add imports
-	 */
-	public boolean reflectValues() {
-		super.reflectValues();
-		try {
-			if (getSourceType() != null) {
-				setModifiers();
-				setNaming();
-				try {
-					setSuper();
-				} catch (InheritanceCycleException e) {
-					Logger.getLogger().log(e);
-				}
-				setImplements();
-				addMethods();
-				addFields();
-				reflectInnerClasses();
-				getAdapterFactory().registerReflection(getSourceType().getName(), this);
-				//	addImports();
-				return true;
-			}
-			return false;
-		} finally {
-			//Don't cache the class beyond the operation of reflect values;
-			//this enables dynamic swapping of the alternate class loader
-			//for java reflection, as well as avoids potential memory leakage
-			sourceType = null;
-		}
-	}
-
-	/**
-	 *  
-	 */
-	protected void reflectInnerClasses() {
-		Class[] innerClasses = getSourceType().getClasses();
-		if (innerClasses.length != 0) {
-			List declaredClasses = getJavaClassTarget().getDeclaredClassesGen();
-			JavaClass inner;
-			ResourceSet set = getTargetResource().getResourceSet();
-			for (int i = 0; i < innerClasses.length; i++) {
-				inner = (JavaClass) JavaRefFactory.eINSTANCE.reflectType(innerClasses[i].getName(), set);
-				declaredClasses.add(inner);
-			}
-		}
-
-	}
-
-	/**
-	 * setImplements - set our implemented/super interfaces here For an interface, these are superclasses. For a class, these are implemented
-	 * interfaces.
-	 */
-	protected void setImplements() {
-		Class[] interfaces = getSourceType().getInterfaces();
-		// needs work, the names above will be simple names if we are relfecting from a source file
-		JavaClassImpl javaClassTarget = (JavaClassImpl) getTarget();
-		JavaClass ref;
-		List intList = javaClassTarget.getImplementsInterfacesGen();
-		intList.clear();
-		for (int i = 0; i < interfaces.length; i++) {
-			ref = createJavaClassRef(interfaces[i].getName());
-			intList.add(ref);
-		}
-	}
-
-	/**
-	 * setModifiers - set the attribute values related to modifiers here
-	 */
-	protected void setModifiers() {
-		JavaClass javaClassTarget = (JavaClass) getTarget();
-		javaClassTarget.setAbstract(java.lang.reflect.Modifier.isAbstract(getSourceType().getModifiers()));
-		javaClassTarget.setFinal(java.lang.reflect.Modifier.isFinal(getSourceType().getModifiers()));
-		javaClassTarget.setPublic(java.lang.reflect.Modifier.isPublic(getSourceType().getModifiers()));
-		// Set type to class or interface, not yet handling EXCEPTION
-		if (getSourceType().isInterface())
-			javaClassTarget.setKind(TypeKind.INTERFACE_LITERAL);
-		else
-			javaClassTarget.setKind(TypeKind.CLASS_LITERAL);
-	}
-
-	/**
-	 * setNaming - set the naming values here - qualified name (package name + name) must be set first, that is the path to the real Java class - ID -
-	 * simple name, identity within a package document - NO UUID!!!
-	 */
-	protected void setNaming() {
-		//	JavaClass javaClassTarget = (JavaClass) getTarget();
-		//	javaClassTarget.refSetUUID((String) null);
-		//	((XMIResource)javaClassTarget.eResource()).setID(javaClassTarget,getSimpleName(getSourceType().getName()));
-	}
-
-	/**
-	 * setSuper - set our supertype here, implemented interface are handled separately
-	 */
-	protected void setSuper() throws InheritanceCycleException {
-		Class superClass = null;
-		superClass = getSourceType().getSuperclass();
-		if (superClass != null) {
-			JavaClass javaClassTarget = (JavaClass) getTarget();
-			javaClassTarget.setSupertype(createJavaClassRef(superClass.getName()));
-		}
-	}
-
-	/**
-	 * Return true if the sourceType can be found.
-	 */
-	public boolean sourceTypeExists() {
-		return getSourceType() != null;
-	}
-
-	public boolean reflectFieldsIfNecessary() {
-		return reflectValuesIfNecessary();
-	}
-
-	public boolean reflectMethodsIfNecessary() {
-		return reflectValuesIfNecessary();
-	}
-}
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaFieldJDKAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaFieldJDKAdaptor.java
deleted file mode 100644
index fafa6c5..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaFieldJDKAdaptor.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters.jdk;
-/*
- *  $RCSfile: JavaFieldJDKAdaptor.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-/**
- * Insert the type's description here.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public class JavaFieldJDKAdaptor extends JDKAdaptor {
-	protected java.lang.reflect.Field sourceField = null;
-	protected Class parentType = null;
-	public JavaFieldJDKAdaptor(Notifier target, JavaJDKAdapterFactory anAdapterFactory) {
-		super(target, anAdapterFactory);
-	}
-	/**
-	 * getParentType - return the Class which corresponds to our parent JavaClass
-	 * we're going to do this a lot, so cache it.
-	 */
-	protected Class getParentType() {
-		if (parentType == null) {
-			Field targetField = (Field) getTarget();
-			JavaClass parentJavaClass = targetField.getJavaClass();
-			JavaClassJDKAdaptor pa = (JavaClassJDKAdaptor) EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
-			if (pa != null)
-				parentType = pa.getSourceType();
-		}
-		return parentType;
-	}
-	public Object getReflectionSource() {
-		return getSourceField();
-	}
-	
-    /* (non-Javadoc)
-     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-     */
-    public boolean hasCachedReflectionSource() {
-        return sourceField != null;
-    }
-	/**
-	 * getSourceField - return the java.lang.reflect.Field which describes our implementing field
-	 */
-	protected java.lang.reflect.Field getSourceField() {
-		if (sourceField == null) {
-			Class parent = this.getParentType();
-			if (parent != null) {
-				try {
-					sourceField = parent.getDeclaredField(((Field) getTarget()).getName());
-				} catch (NoSuchFieldException e) {
-					// OK, carry on
-				}
-			}
-		}
-		return sourceField;
-	}
-	public Field getTargetField() {
-		return (Field) getTarget();
-	}
-	/**
-	 * getValueIn method comment.
-	 */
-	public Object getValueIn(EObject object, EObject attribute) {
-		// At this point, this adapter does not dynamically compute any values,
-		// all values are pushed back into the target on the initial call.
-		return super.getValueIn(object, attribute);
-	}
-	/**
-	 * reflectValues - template method, subclasses override to pump values into target.
-	 * on entry: name, containing package (and qualified name), and document must be set.
-	 * JavaClass adaptor:
-	 *	- set modifiers
-	 *	- set name
-	 * 	- set type
-	 */
-	public boolean reflectValues() {
-		if (getSourceField() != null) {
-			setModifiers();
-			setType();
-			setInitializerIfPossible();
-			return true;
-		}
-		return false;
-	}
-	/**
-	 * Used for the very narrow case of final static Strings
-	 */
-	protected void setInitializerIfPossible() {
-		if (!(getTargetField().isStatic() && getTargetField().isFinal() && "java.lang.String".equals(((JavaHelpers) getTargetField().getEType()).getQualifiedName()))) //$NON-NLS-1$
-			return;
-
-		String value = null;
-		try {
-			value = (String) getSourceField().get(null);
-		} catch (IllegalAccessException ex) {
-			return;
-		}
-
-		if (value == null)
-			return;
-		else
-			value = "\"".concat(value).concat("\""); //$NON-NLS-2$//$NON-NLS-1$
-
-		Block aBlock = createBlock(getTargetField().getName(), value);
-		getTargetField().setInitializer(aBlock);
-	}
-	/**
-	 * setModifiers - set the attribute values related to modifiers here
-	 */
-	protected void setModifiers() {
-		Field javaFieldTarget = (Field) getTarget();
-		// For JDK reflection, I don't think we can set the initializer
-		int modifiers = getSourceField().getModifiers();
-		javaFieldTarget.setStatic(java.lang.reflect.Modifier.isStatic(modifiers));
-		javaFieldTarget.setTransient(java.lang.reflect.Modifier.isTransient(modifiers));
-		javaFieldTarget.setVolatile(java.lang.reflect.Modifier.isVolatile(modifiers));
-		javaFieldTarget.setFinal(java.lang.reflect.Modifier.isFinal(modifiers));
-		// Set visibility
-		if (java.lang.reflect.Modifier.isPublic(modifiers))
-			javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
-		else if (java.lang.reflect.Modifier.isPrivate(modifiers))
-			javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
-		else if (java.lang.reflect.Modifier.isProtected(modifiers))
-			javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
-		else
-			javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
-	}
-	/**
-	 * setType - set our type here
-	 */
-	protected void setType() {
-		String typeName = getTypeName(getSourceField().getType());
-		setFieldType(getTargetField(), typeName);
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaJDKAdapterFactory.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaJDKAdapterFactory.java
deleted file mode 100644
index bf0b5e4..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaJDKAdapterFactory.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters.jdk;
-/*
- *  $RCSfile: JavaJDKAdapterFactory.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import java.util.Iterator;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.jem.internal.java.adapters.JavaReflectionAdapterFactory;
-import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor;
-/**
- * Insert the type's description here.
- * Creation date: (6/13/2000 1:20:31 PM)
- * @author: Administrator
- */
-public class JavaJDKAdapterFactory extends JavaReflectionAdapterFactory {
-	protected ClassLoader contextClassLoader;
-	/**
-	 * JavaJDOMAdapterFactory constructor comment.
-	 */
-	public JavaJDKAdapterFactory() {
-		super();
-		//adapterKey = TYPE_NAME;
-	}
-	/**
-	 * JavaJDOMAdapterFactory constructor comment.
-	 */
-	public JavaJDKAdapterFactory(ClassLoader aClassLoader) {
-		this();
-		setContextClassLoader(aClassLoader);
-	}
-	protected ReflectionAdaptor createJavaClassAdaptor(Notifier target) {
-		return new JavaClassJDKAdaptor(target, this);
-	}
-	protected ReflectionAdaptor createJavaFieldAdaptor(Notifier target) {
-		return new JavaFieldJDKAdaptor(target, this);
-	}
-	protected ReflectionAdaptor createJavaMethodAdaptor(Notifier target) {
-		return new JavaMethodJDKAdaptor(target, this);
-	}
-	// Flush ALL adapters, worst case
-	public void flushAll() {
-		isBusyIteratingReflected = true;
-		try {
-			Iterator i = reflected.values().iterator();
-			while (i.hasNext())
-				 ((JavaClassJDKAdaptor) i.next()).flushReflectedValuesIfNecessary();
-		} finally {
-			finishedIteratingReflected();
-		}
-	}
-	// Flush the adapter for a source object
-	public void flushReflection(String source) {
-		JavaClassJDKAdaptor a = (JavaClassJDKAdaptor) reflected.get(source);
-		if (a != null)
-			a.flushReflectedValuesIfNecessary();
-	}
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (11/07/00 3:38:12 PM)
-	 * @return java.lang.ClassLoader
-	 */
-	public java.lang.ClassLoader getContextClassLoader() {
-		return contextClassLoader;
-	}
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (11/07/00 3:38:12 PM)
-	 * @param newContextClassLoader java.lang.ClassLoader
-	 */
-	public void setContextClassLoader(java.lang.ClassLoader newContextClassLoader) {
-		contextClassLoader = newContextClassLoader;
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaMethodJDKAdaptor.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaMethodJDKAdaptor.java
deleted file mode 100644
index f922fa0..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/jdk/JavaMethodJDKAdaptor.java
+++ /dev/null
@@ -1,245 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters.jdk;
-/*
- *  $RCSfile: JavaMethodJDKAdaptor.java,v $
- *  $Revision: 1.9 $  $Date: 2005/09/14 23:30:35 $ 
- */
-
-import java.util.List;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.xmi.XMIResource;
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter;
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-import org.eclipse.jem.java.internal.impl.MethodImpl;
-/**
- * Insert the type's description here.
- * Creation date: (6/6/2000 4:42:50 PM)
- * @author: Administrator
- */
-public class JavaMethodJDKAdaptor extends JDKAdaptor implements IJavaMethodAdapter {
-	protected java.lang.reflect.AccessibleObject sourceAccessible = null; // Could be method or ctor.
-	protected Class parentType = null;
-	// cache a static empty Class[] for no parm methods
-	protected static Class[] emptyClassArray = new Class[0];
-	// cache a static empty String[], too
-	protected static String[] emptyStringArray = new String[0];
-	public JavaMethodJDKAdaptor(Notifier target, JavaJDKAdapterFactory anAdapterFactory) {
-		super(target, anAdapterFactory);
-	}
-	/**
-	 * addExceptions - reflect our exception list
-	 */
-	protected void addExceptions() {
-		Class[] exceptions =
-			(getSourceAccessible() instanceof java.lang.reflect.Method)
-				? ((java.lang.reflect.Method) getSourceAccessible()).getExceptionTypes()
-				: ((java.lang.reflect.Constructor) getSourceAccessible()).getExceptionTypes();
-		//	EList exList = (EList) javaMethodTarget.primRefValue(JavaRefPackage.eINSTANCE.getMethod_JavaExceptions());
-		List exList = getMethodTarget().getJavaExceptionsGen();
-		for (int i = 0; i < exceptions.length; i++) {
-			exList.add(createJavaClassRef(exceptions[i].getName()));
-		}
-	}
-
-	protected MethodImpl getMethodTarget() {
-		return (MethodImpl) getTarget();
-	}
-	/**
-	 * addParameters - reflect our parms
-	 */
-	protected void addParameters() {
-		Class[] parmTypes =
-			(getSourceAccessible() instanceof java.lang.reflect.Method)
-				? ((java.lang.reflect.Method) getSourceAccessible()).getParameterTypes()
-				: ((java.lang.reflect.Constructor) getSourceAccessible()).getParameterTypes();
-		MethodImpl javaMethodTarget = getMethodTarget();
-		// 	List pList = (List) javaMethodTarget.primRefValue(JavaRefPackage.eINSTANCE.getMethod_Parameters());
-		List pList = javaMethodTarget.getParametersGen();
-		for (int i = 0; i < parmTypes.length; i++) {
-			pList.add(createJavaParameter(javaMethodTarget, "arg" + i, getTypeName(parmTypes[i]))); //$NON-NLS-1$
-		}
-	}
-	protected JavaClass getContainingJavaClass() {
-		return ((Method) getTarget()).getContainingJavaClass();
-	}
-	/**
-	 * getParentType - return the Class which corresponds to our parent JavaClass
-	 * we're going to do this a lot, so cache it.
-	 */
-	protected Class getParentType() {
-		if (parentType == null) {
-			Method targetMethod = (Method) getTarget();
-			JavaClass parentJavaClass = targetMethod.getContainingJavaClass();
-			JavaClassJDKAdaptor pa = (JavaClassJDKAdaptor) EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
-			if (pa != null)
-				parentType = pa.getSourceType();
-		}
-		return parentType;
-	}
-	/**
-	 * getParmTypeSignatures - return an array of Classes for our parameter types
-	 * 	For reflection purposes, we can only rely on our ID, since our parms may
-	 *  not yet be known.
-	 */
-	protected Class[] getParmTypes() {
-		Method javaMethodTarget = (Method) getTarget();
-		String id = ((XMIResource) javaMethodTarget.eResource()).getID(javaMethodTarget);
-		String[] typeNames = getTypeNamesFromMethodID(id);
-		if (typeNames == null)
-			return emptyClassArray;
-		int n = typeNames.length;
-		if (n == 0)
-			return emptyClassArray;
-		Class[] types = new Class[n];
-		for (int i = 0; i < n; ++i) {
-			types[i] = getType(typeNames[i]);
-		}
-		return types;
-	}
-	public Object getReflectionSource() {
-		return getSourceAccessible();
-	}
-	
-    /* (non-Javadoc)
-     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
-     */
-    public boolean hasCachedReflectionSource() { 
-        return sourceAccessible != null;
-    }
-	/**
-	 * getsourceMethod - return the java.lang.reflect.Method which describes our implementing method
-	 */
-	protected java.lang.reflect.AccessibleObject getSourceAccessible() {
-		if (sourceAccessible == null) {
-			Class parent = this.getParentType();
-			if (parent != null) {
-				Class[] parmTypes = this.getParmTypes();
-				try {
-					sourceAccessible = parent.getDeclaredMethod(((Method) getTarget()).getName(), parmTypes);
-				} catch (NoSuchMethodException e) {
-					// OK, can't reflect it
-				}
-
-				if (sourceAccessible == null) {
-					// It wasn't a method, try for constructor.
-					try {
-						sourceAccessible = parent.getDeclaredConstructor(parmTypes);
-					} catch (NoSuchMethodException e) {
-						// OK, can't reflect it
-					}
-				}
-			}
-		}
-		return sourceAccessible;
-	}
-	/**
-	 * getValueIn method comment.
-	 */
-	public Object getValueIn(EObject object, EObject attribute) {
-		// At this point, this adapter does not dynamically compute any values,
-		// all values are pushed back into the target on the initial call.
-		return super.getValueIn(object, attribute);
-	}
-	/**
-	 * reflectValues - template method, subclasses override to pump values into target.
-	 * on entry: UUID, name, containing package (and qualified name), and document must be set.
-	 * Method adaptor:
-	 *	- set modifiers
-	 *	- set name
-	 * 	- set return type
-	 * 	- add parameters
-	 * 	- add exceptions
-	 */
-	public boolean reflectValues() {
-		if (getSourceAccessible() != null) {
-			((Method) getTarget()).setIsGenerated(false);
-			setModifiers();
-			setNaming();
-			setReturnType();
-			addParameters();
-			addExceptions();
-			return true;
-		}
-		return false;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter#reflectGeneratedIfNecessary()
-	 */
-	public boolean reflectGeneratedIfNecessary() {
-		return reflectValuesIfNecessary();
-	}
-	
-	public boolean reflectParamNamesIfNecessary() {
-		return reflectValuesIfNecessary();
-	}
-	
-	/**
-	 * setModifiers - set the attribute values related to modifiers here
-	 */
-	protected void setModifiers() {
-		Method methodTarget = (Method) getTarget();
-		int modifiers =
-			(getSourceAccessible() instanceof java.lang.reflect.Method)
-				? ((java.lang.reflect.Method) getSourceAccessible()).getModifiers()
-				: ((java.lang.reflect.Constructor) getSourceAccessible()).getModifiers();
-		methodTarget.setAbstract(java.lang.reflect.Modifier.isAbstract(modifiers));
-		methodTarget.setFinal(java.lang.reflect.Modifier.isFinal(modifiers));
-		methodTarget.setNative(java.lang.reflect.Modifier.isNative(modifiers));
-		methodTarget.setStatic(java.lang.reflect.Modifier.isStatic(modifiers));
-		methodTarget.setSynchronized(java.lang.reflect.Modifier.isSynchronized(modifiers));
-		methodTarget.setConstructor(getSourceAccessible() instanceof java.lang.reflect.Constructor);
-		// Set visibility
-		JavaClass javaClass = getContainingJavaClass();
-		if ((javaClass.getKind() == TypeKind.INTERFACE_LITERAL) || (java.lang.reflect.Modifier.isPublic(modifiers)))
-			methodTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
-		else if (java.lang.reflect.Modifier.isPrivate(modifiers))
-			methodTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
-		else if (java.lang.reflect.Modifier.isProtected(modifiers))
-			methodTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
-		else
-			//Visibility must be package
-			methodTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
-	}
-	/**
-	 * setNaming - set the naming values here
-	 * 	- qualified name must be set first, that is the path to the real Java class
-	 *	- ID
-	 * 	- name-based UUID
-	 */
-	protected void setNaming() {
-		//
-		//	naming is currently a no-op since the name and UUID must be set prior to reflection
-		//	...and ID is redundant with UUID.
-		//	javaFieldTarget.setID(parent.getQualifiedName() + "_" + javaFieldTarget.getName());
-	}
-	/**
-	 * setType - set our return type here
-	 */
-	protected void setReturnType() {
-		if (getSourceAccessible() instanceof java.lang.reflect.Method) {
-			Class type = ((java.lang.reflect.Method) getSourceAccessible()).getReturnType();
-			Method javaMethodTarget = (Method) getTarget();
-			/*
-					JavaParameter newParameter = createJavaParameter(javaMethodTarget, "result", getTypeName(type));//$NON-NLS-1$
-					newParameter.setParameterKind(MetaJavaParameterKind.RETURN);
-					javaMethodTarget.getParameters().add(newParameter);
-			*/
-			javaMethodTarget.setEType(createJavaClassRef(getTypeName(type)));
-		}
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/nls/ResourceHandler.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/nls/ResourceHandler.java
deleted file mode 100644
index 11ef6dd..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/adapters/nls/ResourceHandler.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.adapters.nls;
-/*
- *  $RCSfile: ResourceHandler.java,v $
- *  $Revision: 1.3 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-import java.text.MessageFormat;
-
-public class ResourceHandler {
-
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("javaadapters");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
-	}
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle= getResourceBundle();
-		}
-		
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		} else {
-			return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-		}
-	}
-public static String getString(String key, Object[] args) {
-
-	try {return MessageFormat.format(getString(key), args);}
-	catch (IllegalArgumentException e) {return getString(key);}
-
-}
-}
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/beaninfo/IIntrospectionAdapter.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/beaninfo/IIntrospectionAdapter.java
deleted file mode 100644
index 01ef0fc..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/beaninfo/IIntrospectionAdapter.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.beaninfo;
-/*
- *  $RCSfile: IIntrospectionAdapter.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import org.eclipse.emf.common.util.BasicEList;
-import org.eclipse.emf.common.util.EList;
-
-
-/**
- * The interface for the Beaninfo adapter. The actual implementation
- * is in a separate project so that beaninfo code will not be loaded
- * unless it needs to be.
- */
-
-public interface IIntrospectionAdapter extends org.eclipse.emf.common.notify.Adapter {
-	public static final Class ADAPTER_KEY = IIntrospectionAdapter.class;
-	public void introspectIfNecessary();
-	public boolean isStale();
-	public EList getEStructuralFeatures();
-	public EList getEOperations();
-	public BasicEList getEAllOperations();
-	public EList getEvents();
-	public EList getAllEvents();
-	public EList getAllProperties();	
-}
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/init/JavaInit.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/init/JavaInit.java
deleted file mode 100644
index 7cc68ae..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/init/JavaInit.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.init;
-/*
- *  $RCSfile: JavaInit.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.internal.java.adapters.JavaXMIFactoryImpl;
-
-/**
- * Initialize the Java Reflection mechanisms. 
- */
-public class JavaInit {
-	protected static boolean initialized = false;
-	protected static boolean plugin_initialized = false;
-
-	public static void init() {
-		init(true);
-	}
-
-	public static void init(boolean shouldPreRegisterPackages) {
-		if (!initialized) {
-			initialized = true;
-			if (shouldPreRegisterPackages) {
-				preRegisterPackages();
-				setDefaultResourceFactory();
-			}
-			//Register resource factory
-			JavaXMIFactoryImpl.register();
-		}
-	}
-
-	private static void preRegisterPackages() {
-		//ecore
-		if (!EPackage.Registry.INSTANCE.containsKey("ecore.xmi")) //$NON-NLS-1$
-			EPackage.Registry.INSTANCE.put("ecore.xmi", new EPackage.Descriptor() { //$NON-NLS-1$
-			public EPackage getEPackage() {
-				return EcorePackage.eINSTANCE;
-			}
-		});
-		//java
-		if (!EPackage.Registry.INSTANCE.containsKey("java.xmi")) //$NON-NLS-1$
-			EPackage.Registry.INSTANCE.put("java.xmi", new EPackage.Descriptor() { //$NON-NLS-1$
-			public EPackage getEPackage() {
-				return JavaRefPackage.eINSTANCE;
-			}
-		});
-	}
-	protected static void setDefaultResourceFactory() {
-		//This is not done outside of Eclipse
-		if (Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().get(Resource.Factory.Registry.DEFAULT_EXTENSION) == null)
-			Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put(
-				Resource.Factory.Registry.DEFAULT_EXTENSION,
-				new XMIResourceFactoryImpl());
-	}
-
-	public static void setPluginInit(boolean bPluginInit) {
-		// Here's where the configuration file would be read.
-		plugin_initialized = bPluginInit;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationHandler.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationHandler.java
deleted file mode 100644
index 96702af..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationHandler.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.instantiation;
-/*
- *  $RCSfile: IInstantiationHandler.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import org.eclipse.emf.ecore.*;
-
-import org.eclipse.jem.java.JavaDataType;
-
-/**
- * The interface for the Instantiation handler. The actual implementation
- * is in a separate project so that instantiation code will not be loaded
- * unless it needs to be.
- */
-
-public interface IInstantiationHandler {
-	/**
-	 * Answers whether the adapter handles the datatype
-	 * or whether the standard EFactory does.
-	 */
-	public boolean handlesDataType(JavaDataType type);
-	
-	/**
-	 * Answers whether the adapter handles the EClass or the
-	 * standard EFactory does.
-	 */
-	public boolean handlesClass(EClass type);
-	
-	/**
-	 * If adapterHandlesInstance returns true, then
-	 * this method will be called to create the instance.
-	 */
-	public EObject create(EClass javaClass);
-
-}
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationHandlerFactoryAdapter.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationHandlerFactoryAdapter.java
deleted file mode 100644
index 9336177..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationHandlerFactoryAdapter.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.instantiation;
-/*
- *  $RCSfile: IInstantiationHandlerFactoryAdapter.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/14 23:30:35 $ 
- */
-import org.eclipse.emf.common.notify.Adapter;
-
-import org.eclipse.jem.java.internal.impl.JavaFactoryImpl;
-
-/**
- * This adapter is a factory for IInstantiationHandler's. It is attached as
- * an adapter on the ResourceSet that contains the java model. JavaXMIFactory
- * will use it to retrieve its IInstantiationHandler. If the adapter is not
- * found, then no instantiation handler exists.
- */
-public interface IInstantiationHandlerFactoryAdapter extends Adapter {
-	
-	public final static Class ADAPTER_KEY = IInstantiationHandlerFactoryAdapter.class;
-	
-	/**
-	 * Return an IInstantiationHandler.
-	 */
-	public IInstantiationHandler getInstantiationHandler(JavaFactoryImpl factory);
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationInstance.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationInstance.java
deleted file mode 100644
index cdc9de9..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/internal/java/instantiation/IInstantiationInstance.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.internal.java.instantiation;
-/*
- *  $RCSfile: IInstantiationInstance.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:25 $ 
- */
-import org.eclipse.jem.java.JavaHelpers;
-
-/**
- * The interface for an instance. The actual implementation
- * is in a separate project so that instantiation code will not be loaded
- * unless it needs to be.
- */
-public interface IInstantiationInstance {
-	/**
-	 * @return The JavaHelpers for the java type of the instance.
-	 */
-	public JavaHelpers getJavaType();
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/ArrayType.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/ArrayType.java
deleted file mode 100644
index 205a39b..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/ArrayType.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: ArrayType.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-import org.eclipse.emf.ecore.EClassifier;
-/**
- * Describes a Java Array type
- *    For multi-dimensional arrays, it is unlikely that the component type will be
- *    specified directly.  This would require instantiating a chain of component types
- *    such as String[][][][]->String[][][]->String[][]->String[]->String.
- * 
- *   The component type relationship will be computed if the finalComponentType
- *   and array dimensions is specified.
- *  
- *   For this reason, the preferred way to create is through the JavaRefFactory factory method:
- *        createArrayType(JavaClass finalComponentType, int dimensions)
- */
-public interface ArrayType extends JavaClass{
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the ArrayDimensions attribute
-	 */
-	int getArrayDimensions();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @param value The new value of the ArrayDimensions attribute
-	 */
-	void setArrayDimensions(int value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The ComponentType reference
-	 */
-	EClassifier getComponentType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.ArrayType#getComponentType <em>Component Type</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Type</em>' reference.
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	void setComponentType(EClassifier value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Get the final component type for this Array Type.
-	 * 
-	 * In order to ensure a unique instance, we will resolve this type using
-	 * reflection. It turns out to be most efficient to just do this by trimming the
-	 * name.
-	 */
-	JavaHelpers getFinalComponentType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Get the component type of this array. 
-	 * 
-	 * If this is a multi-dimensional array, the component type will be the nested
-	 * array type.
-	 */
-	JavaHelpers getComponentTypeAsHelper();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Is this an array of java primitives
-	 */
-	boolean isPrimitiveArray();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Set the component type.
-	 */
-	void setComponentType(JavaHelpers helperComponentType);
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Block.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Block.java
deleted file mode 100644
index d2864c6..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Block.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: Block.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-/**
- * @generated
- */
-public interface Block extends EObject{
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the Source attribute
-	 */
-	String getSource();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @param value The new value of the Source attribute
-	 */
-	void setSource(String value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the Name attribute
-	 */
-	String getName();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @param value The new value of the Name attribute
-	 */
-	void setName(String value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of Contents references
-	 */
-	EList getContents();
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Comment.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Comment.java
deleted file mode 100644
index 73c16ab..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Comment.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: Comment.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:24 $ 
- */
-package org.eclipse.jem.java;
-
-
-/**
- * @generated
- */
-public interface Comment extends Block {
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Field.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Field.java
deleted file mode 100644
index 0daaff4..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Field.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: Field.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.ETypedElement;
-
-/**
- * @generated
- */
-public interface Field extends ETypedElement{
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsFinal attribute
-	 */
-	boolean isFinal();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#isFinal <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Final</em>' attribute.
-	 * @see #isFinal()
-	 * @generated
-	 */
-	void setFinal(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsStatic attribute
-	 */
-	boolean isStatic();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#isStatic <em>Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Static</em>' attribute.
-	 * @see #isStatic()
-	 * @generated
-	 */
-	void setStatic(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the JavaVisibility attribute
-	 */
-	JavaVisibilityKind getJavaVisibility();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#getJavaVisibility <em>Java Visibility</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Java Visibility</em>' attribute.
-	 * @see org.eclipse.jem.java.JavaVisibilityKind
-	 * @see #getJavaVisibility()
-	 * @generated
-	 */
-	void setJavaVisibility(JavaVisibilityKind value);
-
-	/**
-	 * Returns the value of the '<em><b>Transient</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Transient</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Transient</em>' attribute.
-	 * @see #setTransient(boolean)
-	 * @see org.eclipse.jem.java.JavaRefPackage#getField_Transient()
-	 * @model
-	 * @generated
-	 */
-	boolean isTransient();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#isTransient <em>Transient</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Transient</em>' attribute.
-	 * @see #isTransient()
-	 * @generated
-	 */
-	void setTransient(boolean value);
-
-	/**
-	 * Returns the value of the '<em><b>Volatile</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Volatile</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Volatile</em>' attribute.
-	 * @see #setVolatile(boolean)
-	 * @see org.eclipse.jem.java.JavaRefPackage#getField_Volatile()
-	 * @model
-	 * @generated
-	 */
-	boolean isVolatile();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#isVolatile <em>Volatile</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Volatile</em>' attribute.
-	 * @see #isVolatile()
-	 * @generated
-	 */
-	void setVolatile(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The JavaClass reference
-	 */
-	JavaClass getJavaClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#getJavaClass <em>Java Class</em>}' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Java Class</em>' container reference.
-	 * @see #getJavaClass()
-	 * @generated
-	 */
-	void setJavaClass(JavaClass value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The Initializer reference
-	 */
-	Block getInitializer();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Field#getInitializer <em>Initializer</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Initializer</em>' containment reference.
-	 * @see #getInitializer()
-	 * @generated
-	 */
-	void setInitializer(Block value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Get the class that this field is within.
-	 */
-	JavaClass getContainingJavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Is this field an array type.
-	 */
-	boolean isArray();
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/InheritanceCycleException.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/InheritanceCycleException.java
deleted file mode 100644
index 1c9631d..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/InheritanceCycleException.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: InheritanceCycleException.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.text.MessageFormat;
-
-import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
-
-/**
- * @author DABERG
- *
- * To change the template for this generated type comment go to
- * Window>Preferences>Java>Code Generation>Code and Comments
- */
-public class InheritanceCycleException extends Exception {
-	/**
-	 * Comment for <code>serialVersionUID</code>
-	 * 
-	 * @since 1.1.0
-	 */
-	private static final long serialVersionUID = -2385690847427897656L;
-	private static String MSG_PATTERN = ResourceHandler.getString("Java_Inh_Cycle_ERROR_");//$NON-NLS-1$
-
-	/**
-	 * 
-	 */
-	public InheritanceCycleException(JavaClass aSubclass, JavaClass aSuperclass) {
-		this(MessageFormat.format(MSG_PATTERN, new String[]{aSubclass.getQualifiedName(), aSuperclass.getQualifiedName()}));
-	}
-
-	/**
-	 * @param s
-	 */
-	public InheritanceCycleException(String s) {
-		super(s);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Initializer.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Initializer.java
deleted file mode 100644
index be85f18..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Initializer.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: Initializer.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EObject;
-/**
- * @generated
- */
-public interface Initializer extends EObject{
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsStatic attribute
-	 */
-	Boolean getIsStatic();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @param value The new value of the IsStatic attribute
-	 */
-	void setIsStatic(Boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The JavaClass reference
-	 */
-	JavaClass getJavaClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Initializer#getJavaClass <em>Java Class</em>}' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Java Class</em>' container reference.
-	 * @see #getJavaClass()
-	 * @generated
-	 */
-	void setJavaClass(JavaClass value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The Source reference
-	 */
-	Block getSource();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Initializer#getSource <em>Source</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Source</em>' reference.
-	 * @see #getSource()
-	 * @generated
-	 */
-	void setSource(Block value);
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaClass.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaClass.java
deleted file mode 100644
index 8882184..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaClass.java
+++ /dev/null
@@ -1,420 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: JavaClass.java,v $
- *  $Revision: 1.7 $  $Date: 2005/09/15 13:42:04 $ 
- */
-import java.util.List;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-/**
- * <!-- begin-user-doc -->
- * @extends JavaHelpers
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getKind <em>Kind</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#isPublic <em>Public</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#isFinal <em>Final</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getImplementsInterfaces <em>Implements Interfaces</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getClassImport <em>Class Import</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getPackageImports <em>Package Imports</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getFields <em>Fields</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getMethods <em>Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getInitializers <em>Initializers</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getDeclaredClasses <em>Declared Classes</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getDeclaringClass <em>Declaring Class</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getJavaPackage <em>Java Package</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getEvents <em>Events</em>}</li>
- *   <li>{@link org.eclipse.jem.java.JavaClass#getAllEvents <em>All Events</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jem.java.JavaRefPackage#getJavaClass()
- * @model
- * @generated
- */
-public interface JavaClass extends EClass, JavaHelpers{
-
-	public static final String DEFAULT_METHOD_NAME = "*";
-	/**
-	 * Return a method matching the name, and non-return parameters with fully qualified types matching all the types in the list, if it exists.  It will not look up the supertype hierarchy.
-	 */
-	public Method getPublicMethodExtended(String methodName, List parameterTypes) ;
-	/**
-	 * Returns a filtered list on the methods of this class, having a name equal to that of the parameter.
-	 */
-	public List getPublicMethodsExtendedNamed(String name);
-
-	/**
-	 * Return an array listing our Fields, including inherited fields.
-	 * The field relationship is derived from contents.
-	 */  
-	public Field[] listFieldExtended();
-	/**
-	 * Return an array listing our Methods, including inherited methods.
-	 * The method relationship is derived from contents.
-	 */  
-	public Method[] listMethodExtended();
-//FB   /**
-//FB    * This is required for internal reflection. Do not use.
-//FB    */
-//FB   Object primRefValue(EObject feature);
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the Kind attribute
-	 */
-	TypeKind getKind();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.JavaClass#getKind <em>Kind</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Kind</em>' attribute.
-	 * @see org.eclipse.jem.java.TypeKind
-	 * @see #getKind()
-	 * @generated
-	 */
-	void setKind(TypeKind value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsPublic attribute
-	 */
-	boolean isPublic();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.JavaClass#isPublic <em>Public</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Public</em>' attribute.
-	 * @see #isPublic()
-	 * @generated
-	 */
-	void setPublic(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsFinal attribute
-	 */
-	boolean isFinal();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.JavaClass#isFinal <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Final</em>' attribute.
-	 * @see #isFinal()
-	 * @generated
-	 */
-	void setFinal(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of ImplementsInterfaces references
-	 */
-	EList getImplementsInterfaces();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of ClassImport references
-	 */
-	EList getClassImport();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of PackageImports references
-	 */
-	EList getPackageImports();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of Fields references
-	 */
-	EList getFields();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of Methods references
-	 */
-	EList getMethods();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of Initializers references
-	 */
-	EList getInitializers();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The DeclaringClass reference
-	 */
-	JavaClass getDeclaringClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.JavaClass#getDeclaringClass <em>Declaring Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Declaring Class</em>' reference.
-	 * @see #getDeclaringClass()
-	 * @generated
-	 */
-	void setDeclaringClass(JavaClass value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of DeclaredClasses references
-	 */
-	EList getDeclaredClasses();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The JavaPackage reference
-	 */
-	JavaPackage getJavaPackage();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of Events references
-	 */
-	EList getEvents();
-
-	/**
-	 * Returns the value of the '<em><b>All Events</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jem.java.JavaEvent}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>All Events</em>' reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>All Events</em>' reference list.
-	 * @see org.eclipse.jem.java.JavaRefPackage#getJavaClass_AllEvents()
-	 * @model type="org.eclipse.jem.java.JavaEvent" transient="true" volatile="true"
-	 * @generated
-	 */
-	EList getAllEvents();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	boolean isNested();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return an Field with the passed name, or null.
-	 */
-	Field getField(String fieldName);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 *  Return an Field with the passed name from this JavaClass or any supertypes.
-	 * 
-	 * Return null if a Field named fieldName is not found.
-	 */
-	Field getFieldExtended(String fieldName);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return an Field with the passed name, or null.
-	 */
-	Field getFieldNamed(String fieldName);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return all fields, including those from supertypes.
-	 */
-	List getFieldsExtended();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Get the method of this name and these parameters. It will not look up the
-	 * supertype hierarchy.
-	 */
-	Method getMethod(String methodName, List parameterTypes);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return a List of Strings that represent MethodElement signatures from most
-	 * general to most specific.
-	 */
-	List getMethodElementSignatures();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Get the method of this name and these parameters. It will look up the supertype 
-	 * hierarchy.
-	 */
-	Method getMethodExtended(String methodName, List parameterTypes);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return all methods, including those from supertypes.
-	 */
-	List getMethodsExtended();
-
-	/**
-	 * Return all methods, including those from supertypes excluding particular classes and methods.
-	 * @param excludedClasses - A list of JavaClass instances to be ignored.
-	 * @param excludedMethods - A list of Method instances to be ignored.
-	 */
-	List getMethodsExtendedWithFilters(List excludedClasses, List excludedMethods) ;
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return a List of Methods that begins with @aMethodNamePrefix and is not
-	 * included in the @excludedNames list. If @aMethodNamePrefix is null, all methods 
-	 * will be returned.
-
-	 */
-	List getOnlySpecificMethods(String aMethodNamePrefix, List excludedNames);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return a method matching the name, and non-return parameters with fully
-	 * qualified types matching all the types in the list, if it exists.  It will not
-	 * look up the supertype hierarchy.
-	 */
-	Method getPublicMethod(String methodName, List parameterTypes);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return all methods, it will not go up the supertype hierarchy.
-	 */
-	List getPublicMethods();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return all public methods, including those from supertypes.
-	 */
-	List getPublicMethodsExtended();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Returns a filtered list on the methods of this class, having a name equal to
-	 * that of the parameter.
-	 */
-	List getPublicMethodsNamed(String name);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	JavaClass getSupertype();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Test whether the receiver implements the passed interface (or one of its
-	 * supertypes).
-	 */
-	boolean implementsInterface(JavaClass interfaceType);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return a string showing our details.
-	 */
-	String infoString();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Tests whether this class inherits from the passed in class.
-	 */
-	boolean inheritsFrom(JavaClass javaClass);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Does this type exist.
-	 */
-	boolean isExistingType();
-
-	/**
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Is this an interface.
-	 * <!-- end-model-doc -->
-	 * @model kind="operation"
-	 * @generated
-	 */
-  boolean isInterface();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Set the supertype.
-	 */
-	void setSupertype(JavaClass javaclass) throws InheritanceCycleException;
-
-	/**
-	 * Return true if the passed JavaClass can be set as the supertype
-	 * of this JavaClass.  This method will test to see if aJavaClass will
-	 * create a cycle in the inheritance structure.  Return true if no
-	 * inheritance cycle will be created.
-	 */
-	public boolean isValidSupertype(JavaClass aJavaClass) ;
-
-	/**
-	 * Get the EStructuralFeatures that represent the BeanInfo properties for
-	 * just this Java class, not including inherited. It will return any EStructuralFeature
-	 * that was specified as being at this class either through the XMI override document or
-	 * through the BeanInfo. Structural features through the XMI may not be bean properties,
-	 * but they are part of the features available at this class only. 
-	 * 
-	 * This is a combination of getEAttributes() and getEReferences().
-	 * 
-	 * To retrieve only the Bean Properties, then use Beaninfo 
-	 * Utilities.getPropertiesIterator(javaclass.getProperties()) and this will iterate over
-	 * the Bean PropertyDecorators, and filter out the non-bean features.
-	 * 
-	 * @return The list of properties (as EStructuralFeature's) for this java class. This list is
-	 * not modifiable.
-	 */
-	EList getProperties();
-	
-	/**
-	 * Get all of the EStructuralFeatures that represent the BeanInfo properties for
-	 * just this Java class, including inherited. It will return any EStructuralFeature
-	 * that was specified through the XMI override document or
-	 * through the BeanInfo. Structural features through the XMI may not be bean properties,
-	 * but they are part of the features available.
-	 * 
-	 * The is like getEAllStructuralFeatures() except that if BeanInfo hides any bean properties
-	 * from the super class, this list will also hide them, while getEAllStructuralFeatures
-	 * will not.
-	 * 
-	 * To retrieve only the Bean Properties, then use Beaninfo 
-	 * Utilities.getPropertiesIterator(javaclass.getAllProperties()) and this will iterate over
-	 * the Bean PropertyDecorators, and filter out the non-bean features.
-	 * 
-	 * @return The list of all properties, including inherited, (as EStructuralFeature's) for this class. This list is
-	 * not modifiable.
-	 */
-	EList getAllProperties();
-	
-	
-	/**
-	 * Return the reflection type, if it exists, for this class. If running within Eclipse this
-	 * will be an {@link org.eclipse.jdt.core.IType}, or running outside of Eclipse it will be a {@link java.lang.Class}.
-	 * 
-	 * @return IType if in Eclipse, Class if outside Eclipse, or <code>null</code> if type not found.
-	 * 
-	 * @since 1.1.0
-	 */
-	Object getReflectionType();
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaDataType.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaDataType.java
deleted file mode 100644
index 735b858..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaDataType.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: JavaDataType.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EClass;
-
-/**
- * <!-- begin-user-doc -->
- * @extends JavaHelpers
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jem.java.JavaRefPackage#getJavaDataType()
- * @model
- * @generated
- */
-public interface JavaDataType extends EClass, JavaHelpers{
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return the default string representing the default value of the primitive.
-	 */
-	String getDefaultValueString();
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaEvent.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaEvent.java
deleted file mode 100644
index c260421..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaEvent.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: JavaEvent.java,v $
- *  $Revision: 1.4 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Java Event</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jem.java.JavaRefPackage#getJavaEvent()
- * @model abstract="true"
- * @generated
- */
-public interface JavaEvent extends EStructuralFeature{
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaHelpers.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaHelpers.java
deleted file mode 100644
index 31cefaf..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaHelpers.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: JavaHelpers.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-
-/**
- * Insert the type's description here.
- * Creation date: (6/27/2000 4:42:04 PM)
- * @author: Administrator
- */
-public interface JavaHelpers extends EClass {
-	static final String BOOLEAN_NAME = "java.lang.Boolean"; //$NON-NLS-1$
-	static final String CHARACTER_NAME = "java.lang.Character"; //$NON-NLS-1$
-	static final String BYTE_NAME = "java.lang.Byte"; //$NON-NLS-1$
-	static final String DOUBLE_NAME = "java.lang.Double"; //$NON-NLS-1$
-	static final String FLOAT_NAME = "java.lang.Float"; //$NON-NLS-1$
-	static final String INTEGER_NAME = "java.lang.Integer"; //$NON-NLS-1$
-	static final String LONG_NAME = "java.lang.Long"; //$NON-NLS-1$
-	static final String SHORT_NAME = "java.lang.Short"; //$NON-NLS-1$
-	static final String PRIM_BOOLEAN_NAME = "boolean"; //$NON-NLS-1$
-	static final String PRIM_CHARACTER_NAME = "char"; //$NON-NLS-1$
-	static final String PRIM_BYTE_NAME = "byte"; //$NON-NLS-1$
-	static final String PRIM_DOUBLE_NAME = "double"; //$NON-NLS-1$
-	static final String PRIM_FLOAT_NAME = "float"; //$NON-NLS-1$
-	static final String PRIM_INTEGER_NAME = "int"; //$NON-NLS-1$
-	static final String PRIM_LONG_NAME = "long"; //$NON-NLS-1$
-	static final String PRIM_SHORT_NAME = "short"; //$NON-NLS-1$
-	
-	static final int PRIM_NOT_ID = 0;
-	static final int PRIM_BOOLEAN_ID = 1;
-	static final int PRIM_CHARACTER_ID = 2;
-	static final int PRIM_BYTE_ID = 3;
-	static final int PRIM_DOUBLE_ID = 4;
-	static final int PRIM_FLOAT_ID = 5;
-	static final int PRIM_INTEGER_ID = 6;
-	static final int PRIM_LONG_ID = 7;
-	static final int PRIM_SHORT_ID = 8;
-	
-	/**
-	 * Get the qualified name (with using '.' for inner classes). Will return the name if primitive too (e.g. "boolean")
-	 * Note: This should of been get the simple name and not the qualifed name, but it is too late and has been established
-	 * as the API. Use <code>getSimpleName()</code> instead if you want the name not qualified.
-	 * @return the qualified name of the type.
-	 * @see JavaHelpers#getSimpleName()
-	 * @since 1.0.0
-	 */
-	public String getJavaName();
-	/**
-	 * Get the simple name. This is the name of the primitive, or if a class, the name without the package. And if it is an
-	 * inner class, it will use '.' instead of '$'. If you want the simple name for reflection (i.e. with '$') use <code>getName()</code>.
-	 * @return the simple name (no package) of the type.
-	 * 
-	 * @since 1.0.0
-	 */
-	public String getSimpleName();
-
-	/**
-	 * Get the primitive type that this helper wrappers or is (e.g. "java.lang.Integer" and "int" types return "int" type). If not a primitive
-	 * or a wrapper for a primitive, then return null.
-	 * @return
-	 * 
-	 * @since 1.0.0
-	 */
-	public JavaDataType getPrimitive();
-	
-	/**
-	 * Get the primitive id that this helper wrappers or is (e.g. "java.lang.Integer" and "int" will return {@link JavaHelpers#PRIM_INTEGER_ID}). If
-	 * not a wrapper for a primitive then return {@link JavaHelpers#PRIM_NOT_ID}.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public int getPrimitiveID();
-	/**
-	 * To be used by people that need to get the qualified name. This would use '.' for inner classes
-	 * and include the package name.
-	 * @return the qualified name, including package.
-	 * 
-	 * @since 1.0.0
-	 */	
-	public String getQualifiedName();
-	public JavaClass getWrapper();
-	public boolean isArray();
-	/**
-	 * Can an object of the passed in class be assigned to an
-	 * object of this class? In other words is this class a
-	 * supertype of the passed in class, or is it superinterface
-	 * of it? Or in the case of primitives, are they the same. 
-	 * @param aClass
-	 * @return <code>true</code> if assignable from the given class.
-	 * 
-	 * @since 1.0.0
-	 */
-	public boolean isAssignableFrom(EClassifier aClass);
-	public boolean isPrimitive();
-
-	/**
-	 * To be used by people that need to get the qualified name used for reflection. This would use '$' instead of '.' for inner classes
-	 * and include the package name.
-	 * Typically bean info would need to use something like this.
-	 * @return the qualified name, use '$' for inner classes
-	 * 
-	 * @since 1.0.0
-	 */
-	public String getQualifiedNameForReflection() ;	
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaPackage.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaPackage.java
deleted file mode 100644
index 56f71ec..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaPackage.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: JavaPackage.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EPackage;
-
-public interface JavaPackage extends EPackage{
-	
-	public static final String PACKAGE_ID = "*package";	// The id (the part that goes after the '#' for a java package.) //$NON-NLS-1$
-														// There will only be one package per java resource so it
-														// can be unique. No java types, methods, fields ids can
-														// start with an asterick so will be unique.
-														
-	public static final String PRIMITIVE_PACKAGE_NAME = "_-javaprim"; //$NON-NLS-1$
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of JavaClasses references
-	 */
-	EList getJavaClasses();
-
-	public String getPackageName() ;
-
-} //JavaPackage
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaParameter.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaParameter.java
deleted file mode 100644
index 99e7a03..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaParameter.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: JavaParameter.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:24 $ 
- */
-
-import org.eclipse.emf.ecore.EParameter;
-
-/**
- * @generated
- */
-public interface JavaParameter extends EParameter {
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsFinal attribute
-	 */
-	boolean isFinal();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.JavaParameter#isFinal <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Final</em>' attribute.
-	 * @see #isFinal()
-	 * @generated
-	 */
-	void setFinal(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the ParameterKind attribute
-	 */
-	JavaParameterKind getParameterKind();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.JavaParameter#getParameterKind <em>Parameter Kind</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Parameter Kind</em>' attribute.
-	 * @see org.eclipse.jem.java.JavaParameterKind
-	 * @see #getParameterKind()
-	 * @generated
-	 */
-	void setParameterKind(JavaParameterKind value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Is this parameter type an array type.
-	 */
-	boolean isArray();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Is this a return parameter.
-	 */
-	boolean isReturn();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	JavaHelpers getJavaType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	String getQualifiedName();
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaParameterKind.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaParameterKind.java
deleted file mode 100644
index 1634737..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaParameterKind.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: JavaParameterKind.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.emf.common.util.AbstractEnumerator;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Java Parameter Kind</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * IN=0
- * OUT=1
- * INOUT=2
- * RETURN=3
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.java.JavaRefPackage#getJavaParameterKind()
- * @model
- * @generated
- */
-public final class JavaParameterKind extends AbstractEnumerator
-{
-	/**
-	 * The '<em><b>IN</b></em>' literal value.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @see #IN_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int IN = 0;
-	/**
-	 * The '<em><b>OUT</b></em>' literal value.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @see #OUT_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int OUT = 1;
-	/**
-	 * The '<em><b>INOUT</b></em>' literal value.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @see #INOUT_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int INOUT = 2;
-	/**
-	 * The '<em><b>RETURN</b></em>' literal value.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @see #RETURN_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-	public static final int RETURN = 3;
-	/**
-	 * The '<em><b>IN</b></em>' literal object.
-	 * <!-- begin-user-doc --> 
-   * <p>
-   * If the meaning of '<em><b>IN</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc --> 
-	 * @see #IN
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaParameterKind IN_LITERAL = new JavaParameterKind(IN, "IN");
-
-	/**
-	 * The '<em><b>OUT</b></em>' literal object.
-	 * <!-- begin-user-doc --> 
-   * <p>
-   * If the meaning of '<em><b>OUT</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc --> 
-	 * @see #OUT
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaParameterKind OUT_LITERAL = new JavaParameterKind(OUT, "OUT");
-
-	/**
-	 * The '<em><b>INOUT</b></em>' literal object.
-	 * <!-- begin-user-doc --> 
-   * <p>
-   * If the meaning of '<em><b>INOUT</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc --> 
-	 * @see #INOUT
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaParameterKind INOUT_LITERAL = new JavaParameterKind(INOUT, "INOUT");
-
-	/**
-	 * The '<em><b>RETURN</b></em>' literal object.
-	 * <!-- begin-user-doc --> 
-   * <p>
-   * If the meaning of '<em><b>RETURN</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc --> 
-	 * @see #RETURN
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaParameterKind RETURN_LITERAL = new JavaParameterKind(RETURN, "RETURN");
-
-	/**
-	 * An array of all the '<em><b>Java Parameter Kind</b></em>' enumerators.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @generated
-	 */
-  private static final JavaParameterKind[] VALUES_ARRAY =
-		new JavaParameterKind[] {
-			IN_LITERAL,
-			OUT_LITERAL,
-			INOUT_LITERAL,
-			RETURN_LITERAL,
-		};
-
-	/**
-	 * A public read-only list of all the '<em><b>Java Parameter Kind</b></em>' enumerators.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @generated
-	 */
-  public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
-
-	/**
-	 * Returns the '<em><b>Java Parameter Kind</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @generated
-	 */
-  public static JavaParameterKind get(String name) {
-		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
-			JavaParameterKind result = VALUES_ARRAY[i];
-			if (result.toString().equals(name)) {
-				return result;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the '<em><b>Java Parameter Kind</b></em>' literal with the specified value.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @generated
-	 */
-  public static JavaParameterKind get(int value) {
-		switch (value) {
-			case IN: return IN_LITERAL;
-			case OUT: return OUT_LITERAL;
-			case INOUT: return INOUT_LITERAL;
-			case RETURN: return RETURN_LITERAL;
-		}
-		return null;	
-	}
-
-	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc --> 
-   * <!-- end-user-doc --> 
-	 * @generated
-	 */
-  private JavaParameterKind(int value, String name) {
-		super(value, name);
-	}
-
-} //JavaParameterKind
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaRefFactory.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaRefFactory.java
deleted file mode 100644
index 73d8c04..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaRefFactory.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: JavaRefFactory.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/14 23:30:35 $ 
- */
-
-import org.eclipse.emf.ecore.EFactory;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-/**
- * @generated
- */
-public interface JavaRefFactory extends EFactory{
-
-	/**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	JavaRefFactory eINSTANCE = new org.eclipse.jem.java.internal.impl.JavaRefFactoryImpl();
-
-
-	/**
-	 * Create a proxy reference to the class name.
-	 * @param targetName Classname to create a proxy reference too.
-	 * @return A proxy reference
-	 * 
-	 * @since 1.0.0
-	 */
-	public JavaClass createClassRef(String targetName);
-	
-	/**
-	 * reflect - reflect a java type (class or primitive) for a given qualified name.
-	 * <p>If the package or type does not exist, one will be created through
-	 * the reflection mechanism.
-	 * <p>Lookup the JavaClass in the context of the passed object, handling some error cases.
-	 * @param aQualifiedName Fully qualified name of class or primitive (e.g. <code>java.lang.Object</code> or <code>int</code>
-	 * @param relatedObject EObject that it will be related too (it will look through the resource set's project of the EObject)
-	 * @return The type. <code>null</code> if name is not of correct format, relatedObject is not contained by a resource set, or resource set is not associated with a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public JavaHelpers reflectType(String aQualifiedName, EObject relatedObject);
-	
-	
-	/**
-	 * reflect - reflect a java type (class or primitive) for a given qualified name.
-	 * <p>If the package or class does not exist, one will be created through
-	 * the reflection mechanism.
-	 * @param aQualifiedName Fully qualified name of class or primitive (e.g. <code>java.lang.Object</code> or <code>int</code>
-	 * @param set Resource set to use. Its project will be used to find the type.
-	 * @return The type. <code>null</code> if name is not of correct format, or resource set is not associated with a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public JavaHelpers reflectType(String aQualifiedName, ResourceSet set);	
-	
-	
-	/**
-	 * reflect - reflect a type for a given package name and class name.
-	 * <p>If the package or class does not exist, one will be created through
-	 * the reflection mechanism.
-	 * @param aPackageName Package name
-	 * @param aTypeName Type name 
-	 * @param set Resource set to use. Its project will be used to find the type.
-	 * @return The type. <code>null</code> if name is not of correct format, or resource set is not associated with a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public JavaHelpers reflectType(String aPackageName, String aTypeName, ResourceSet set);
-	
-	/**
-	 * reflect - reflect a Java package for a given package name.
-	 * <p>If the package does not exist, one will be created through
-	 * the reflection mechanism.
-	 * @param packageName Name of package
-	 * @param set Resource set to use. Its project will be used to find the package.
-	 * @return The package. <code>null</code> if name is not of correct format, or resource set is not associated with a project.
-	 * 
-	 * @since 1.0.0
-	 */
-	public JavaPackage reflectPackage(String packageName, ResourceSet set);
-	
-	/**
-	 * @return ArrayType value with an array of the component type
-	 */
-	public ArrayType createArrayType(JavaHelpers componentType);
-	/**
-	 * @return ArrayType value with an array of the specified dimensions and final component type.
-	 */
-	public ArrayType createArrayType(JavaHelpers finalComponentType, int dimensions);
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Method value
-	 */
-	Method createMethod();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaClass value
-	 */
-	JavaClass createJavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Field value
-	 */
-	Field createField();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Block value
-	 */
-	Block createBlock();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Comment value
-	 */
-	Comment createComment();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Statement value
-	 */
-	Statement createStatement();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Initializer value
-	 */
-	Initializer createInitializer();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaParameter value
-	 */
-	JavaParameter createJavaParameter();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return ArrayType value
-	 */
-	ArrayType createArrayType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaDataType value
-	 */
-	JavaDataType createJavaDataType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaPackage value
-	 */
-	JavaPackage createJavaPackage();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	JavaRefPackage getJavaRefPackage();
-
-}
-
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaRefPackage.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaRefPackage.java
deleted file mode 100644
index 106ba96..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaRefPackage.java
+++ /dev/null
@@ -1,1972 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: JavaRefPackage.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/14 23:30:35 $ 
- */
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EcorePackage;
-
-
-/**
- * @lastgen interface JavaRefPackage extends EPackage {}
- */
-public interface JavaRefPackage extends EPackage{
-	/**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNAME = "java";
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS = 0;
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EANNOTATIONS = EcorePackage.ECLASS__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__NAME = EcorePackage.ECLASS__NAME;
-	/**
-	 * The feature id for the '<em><b>Instance Class Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__INSTANCE_CLASS_NAME = EcorePackage.ECLASS__INSTANCE_CLASS_NAME;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__INSTANCE_CLASS = EcorePackage.ECLASS__INSTANCE_CLASS;
-	/**
-	 * The feature id for the '<em><b>Default Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__DEFAULT_VALUE = EcorePackage.ECLASS__DEFAULT_VALUE;
-
-	/**
-	 * The feature id for the '<em><b>EPackage</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EPACKAGE = EcorePackage.ECLASS__EPACKAGE;
-
-	/**
-	 * The feature id for the '<em><b>Abstract</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__ABSTRACT = EcorePackage.ECLASS__ABSTRACT;
-
-	/**
-	 * The feature id for the '<em><b>Interface</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__INTERFACE = EcorePackage.ECLASS__INTERFACE;
-
-	/**
-	 * The feature id for the '<em><b>ESuper Types</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__ESUPER_TYPES = EcorePackage.ECLASS__ESUPER_TYPES;
-
-	/**
-	 * The feature id for the '<em><b>EOperations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EOPERATIONS = EcorePackage.ECLASS__EOPERATIONS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Attributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EALL_ATTRIBUTES = EcorePackage.ECLASS__EALL_ATTRIBUTES;
-
-	/**
-	 * The feature id for the '<em><b>EAll References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EALL_REFERENCES = EcorePackage.ECLASS__EALL_REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>EReferences</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EREFERENCES = EcorePackage.ECLASS__EREFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>EAttributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EATTRIBUTES = EcorePackage.ECLASS__EATTRIBUTES;
-
-	/**
-	 * The feature id for the '<em><b>EAll Containments</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EALL_CONTAINMENTS = EcorePackage.ECLASS__EALL_CONTAINMENTS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Operations</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EALL_OPERATIONS = EcorePackage.ECLASS__EALL_OPERATIONS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Structural Features</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EALL_STRUCTURAL_FEATURES = EcorePackage.ECLASS__EALL_STRUCTURAL_FEATURES;
-
-	/**
-	 * The feature id for the '<em><b>EAll Super Types</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__EALL_SUPER_TYPES = EcorePackage.ECLASS__EALL_SUPER_TYPES;
-
-	/**
-	 * The feature id for the '<em><b>EID Attribute</b></em>' reference.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-  int JAVA_CLASS__EID_ATTRIBUTE = EcorePackage.ECLASS__EID_ATTRIBUTE;
-
-	/**
-	 * The feature id for the '<em><b>EStructural Features</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__ESTRUCTURAL_FEATURES = EcorePackage.ECLASS__ESTRUCTURAL_FEATURES;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__KIND = EcorePackage.ECLASS_FEATURE_COUNT + 0;
-	/**
-	 * The feature id for the '<em><b>Public</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__PUBLIC = EcorePackage.ECLASS_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Final</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS__FINAL = EcorePackage.ECLASS_FEATURE_COUNT + 2;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__IMPLEMENTS_INTERFACES = EcorePackage.ECLASS_FEATURE_COUNT + 3;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__CLASS_IMPORT = EcorePackage.ECLASS_FEATURE_COUNT + 4;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__PACKAGE_IMPORTS = EcorePackage.ECLASS_FEATURE_COUNT + 5;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__FIELDS = EcorePackage.ECLASS_FEATURE_COUNT + 6;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__METHODS = EcorePackage.ECLASS_FEATURE_COUNT + 7;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__INITIALIZERS = EcorePackage.ECLASS_FEATURE_COUNT + 8;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__DECLARED_CLASSES = EcorePackage.ECLASS_FEATURE_COUNT + 9;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__DECLARING_CLASS = EcorePackage.ECLASS_FEATURE_COUNT + 10;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__JAVA_PACKAGE = EcorePackage.ECLASS_FEATURE_COUNT + 11;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__EVENTS = EcorePackage.ECLASS_FEATURE_COUNT + 12;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_CLASS__ALL_EVENTS = EcorePackage.ECLASS_FEATURE_COUNT + 13;
-	/**
-	 * The number of structural features of the the '<em>Java Class</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_CLASS_FEATURE_COUNT = EcorePackage.ECLASS_FEATURE_COUNT + 14;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int FIELD = 4;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD = 3;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PARAMETER = 2;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE = 10;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_DATA_TYPE = 9;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_EVENT = 11;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PACKAGE = 8;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int BLOCK = 5;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int COMMENT = 6;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int STATEMENT = 7;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int INITIALIZER = 1;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int INITIALIZER__IS_STATIC = 0;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int INITIALIZER__JAVA_CLASS = 1;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int INITIALIZER__SOURCE = 2;
-
-	/**
-	 * The number of structural features of the the '<em>Initializer</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int INITIALIZER_FEATURE_COUNT = 3;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__EANNOTATIONS = EcorePackage.EPARAMETER__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PARAMETER__NAME = EcorePackage.EPARAMETER__NAME;
-	/**
-	 * The feature id for the '<em><b>Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__ORDERED = EcorePackage.EPARAMETER__ORDERED;
-
-	/**
-	 * The feature id for the '<em><b>Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__UNIQUE = EcorePackage.EPARAMETER__UNIQUE;
-
-	/**
-	 * The feature id for the '<em><b>Lower Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__LOWER_BOUND = EcorePackage.EPARAMETER__LOWER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Upper Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__UPPER_BOUND = EcorePackage.EPARAMETER__UPPER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__MANY = EcorePackage.EPARAMETER__MANY;
-
-	/**
-	 * The feature id for the '<em><b>Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__REQUIRED = EcorePackage.EPARAMETER__REQUIRED;
-
-	/**
-	 * The feature id for the '<em><b>EType</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__ETYPE = EcorePackage.EPARAMETER__ETYPE;
-
-	/**
-	 * The feature id for the '<em><b>EOperation</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__EOPERATION = EcorePackage.EPARAMETER__EOPERATION;
-
-	/**
-	 * The feature id for the '<em><b>Final</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER__FINAL = EcorePackage.EPARAMETER_FEATURE_COUNT + 0;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PARAMETER__PARAMETER_KIND = EcorePackage.EPARAMETER_FEATURE_COUNT + 1;
-	/**
-	 * The number of structural features of the the '<em>Java Parameter</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PARAMETER_FEATURE_COUNT = EcorePackage.EPARAMETER_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__EANNOTATIONS = EcorePackage.EOPERATION__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD__NAME = EcorePackage.EOPERATION__NAME;
-	/**
-	 * The feature id for the '<em><b>Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__ORDERED = EcorePackage.EOPERATION__ORDERED;
-
-	/**
-	 * The feature id for the '<em><b>Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__UNIQUE = EcorePackage.EOPERATION__UNIQUE;
-
-	/**
-	 * The feature id for the '<em><b>Lower Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__LOWER_BOUND = EcorePackage.EOPERATION__LOWER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Upper Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__UPPER_BOUND = EcorePackage.EOPERATION__UPPER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__MANY = EcorePackage.EOPERATION__MANY;
-
-	/**
-	 * The feature id for the '<em><b>Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__REQUIRED = EcorePackage.EOPERATION__REQUIRED;
-
-	/**
-	 * The feature id for the '<em><b>EType</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__ETYPE = EcorePackage.EOPERATION__ETYPE;
-
-	/**
-	 * The feature id for the '<em><b>EContaining Class</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__ECONTAINING_CLASS = EcorePackage.EOPERATION__ECONTAINING_CLASS;
-
-	/**
-	 * The feature id for the '<em><b>EParameters</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__EPARAMETERS = EcorePackage.EOPERATION__EPARAMETERS;
-
-	/**
-	 * The feature id for the '<em><b>EExceptions</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__EEXCEPTIONS = EcorePackage.EOPERATION__EEXCEPTIONS;
-
-	/**
-	 * The feature id for the '<em><b>Abstract</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__ABSTRACT = EcorePackage.EOPERATION_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Native</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__NATIVE = EcorePackage.EOPERATION_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>Synchronized</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__SYNCHRONIZED = EcorePackage.EOPERATION_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>Final</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__FINAL = EcorePackage.EOPERATION_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Constructor</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__CONSTRUCTOR = EcorePackage.EOPERATION_FEATURE_COUNT + 4;
-
-	/**
-	 * The feature id for the '<em><b>Static</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD__STATIC = EcorePackage.EOPERATION_FEATURE_COUNT + 5;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD__JAVA_VISIBILITY = EcorePackage.EOPERATION_FEATURE_COUNT + 6;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD__PARAMETERS = EcorePackage.EOPERATION_FEATURE_COUNT + 7;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD__JAVA_EXCEPTIONS = EcorePackage.EOPERATION_FEATURE_COUNT + 8;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD__JAVA_CLASS = EcorePackage.EOPERATION_FEATURE_COUNT + 9;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int METHOD__SOURCE = EcorePackage.EOPERATION_FEATURE_COUNT + 10;
-	/**
-	 * The number of structural features of the the '<em>Method</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int METHOD_FEATURE_COUNT = EcorePackage.EOPERATION_FEATURE_COUNT + 11;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__EANNOTATIONS = EcorePackage.ETYPED_ELEMENT__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int FIELD__NAME = EcorePackage.ETYPED_ELEMENT__NAME;
-	/**
-	 * The feature id for the '<em><b>Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__ORDERED = EcorePackage.ETYPED_ELEMENT__ORDERED;
-
-	/**
-	 * The feature id for the '<em><b>Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__UNIQUE = EcorePackage.ETYPED_ELEMENT__UNIQUE;
-
-	/**
-	 * The feature id for the '<em><b>Lower Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__LOWER_BOUND = EcorePackage.ETYPED_ELEMENT__LOWER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Upper Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__UPPER_BOUND = EcorePackage.ETYPED_ELEMENT__UPPER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__MANY = EcorePackage.ETYPED_ELEMENT__MANY;
-
-	/**
-	 * The feature id for the '<em><b>Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__REQUIRED = EcorePackage.ETYPED_ELEMENT__REQUIRED;
-
-	/**
-	 * The feature id for the '<em><b>EType</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__ETYPE = EcorePackage.ETYPED_ELEMENT__ETYPE;
-
-	/**
-	 * The feature id for the '<em><b>Final</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__FINAL = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>Static</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__STATIC = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 1;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int FIELD__JAVA_VISIBILITY = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 2;
-	/**
-	 * The feature id for the '<em><b>Transient</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__TRANSIENT = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 3;
-
-	/**
-	 * The feature id for the '<em><b>Volatile</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD__VOLATILE = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 4;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int FIELD__JAVA_CLASS = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 5;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int FIELD__INITIALIZER = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 6;
-	/**
-	 * The number of structural features of the the '<em>Field</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FIELD_FEATURE_COUNT = EcorePackage.ETYPED_ELEMENT_FEATURE_COUNT + 7;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int BLOCK__SOURCE = 0;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int BLOCK__NAME = 1;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int BLOCK__CONTENTS = 2;
-
-	/**
-	 * The number of structural features of the the '<em>Block</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BLOCK_FEATURE_COUNT = 3;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int COMMENT__SOURCE = BLOCK__SOURCE;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int COMMENT__NAME = BLOCK__NAME;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int COMMENT__CONTENTS = BLOCK__CONTENTS;
-
-	/**
-	 * The number of structural features of the the '<em>Comment</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMMENT_FEATURE_COUNT = BLOCK_FEATURE_COUNT + 0;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int STATEMENT__SOURCE = BLOCK__SOURCE;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int STATEMENT__NAME = BLOCK__NAME;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int STATEMENT__CONTENTS = BLOCK__CONTENTS;
-
-	/**
-	 * The number of structural features of the the '<em>Statement</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int STATEMENT_FEATURE_COUNT = BLOCK_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE__EANNOTATIONS = EcorePackage.EPACKAGE__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PACKAGE__NAME = EcorePackage.EPACKAGE__NAME;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PACKAGE__NS_URI = EcorePackage.EPACKAGE__NS_URI;
-	/**
-	 * The feature id for the '<em><b>Ns Prefix</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE__NS_PREFIX = EcorePackage.EPACKAGE__NS_PREFIX;
-
-	/**
-	 * The feature id for the '<em><b>EFactory Instance</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE__EFACTORY_INSTANCE = EcorePackage.EPACKAGE__EFACTORY_INSTANCE;
-
-	/**
-	 * The feature id for the '<em><b>EClassifiers</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE__ECLASSIFIERS = EcorePackage.EPACKAGE__ECLASSIFIERS;
-
-	/**
-	 * The feature id for the '<em><b>ESubpackages</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE__ESUBPACKAGES = EcorePackage.EPACKAGE__ESUBPACKAGES;
-
-	/**
-	 * The feature id for the '<em><b>ESuper Package</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE__ESUPER_PACKAGE = EcorePackage.EPACKAGE__ESUPER_PACKAGE;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PACKAGE__JAVA_CLASSES = EcorePackage.EPACKAGE_FEATURE_COUNT + 0;
-	/**
-	 * The number of structural features of the the '<em>Java Package</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_PACKAGE_FEATURE_COUNT = EcorePackage.EPACKAGE_FEATURE_COUNT + 1;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EANNOTATIONS = EcorePackage.ECLASS__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_DATA_TYPE__NAME = EcorePackage.ECLASS__NAME;
-	/**
-	 * The feature id for the '<em><b>Instance Class Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__INSTANCE_CLASS_NAME = EcorePackage.ECLASS__INSTANCE_CLASS_NAME;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_DATA_TYPE__INSTANCE_CLASS = EcorePackage.ECLASS__INSTANCE_CLASS;
-	/**
-	 * The feature id for the '<em><b>Default Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__DEFAULT_VALUE = EcorePackage.ECLASS__DEFAULT_VALUE;
-
-	/**
-	 * The feature id for the '<em><b>EPackage</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EPACKAGE = EcorePackage.ECLASS__EPACKAGE;
-
-	/**
-	 * The feature id for the '<em><b>Abstract</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__ABSTRACT = EcorePackage.ECLASS__ABSTRACT;
-
-	/**
-	 * The feature id for the '<em><b>Interface</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__INTERFACE = EcorePackage.ECLASS__INTERFACE;
-
-	/**
-	 * The feature id for the '<em><b>ESuper Types</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__ESUPER_TYPES = EcorePackage.ECLASS__ESUPER_TYPES;
-
-	/**
-	 * The feature id for the '<em><b>EOperations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EOPERATIONS = EcorePackage.ECLASS__EOPERATIONS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Attributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EALL_ATTRIBUTES = EcorePackage.ECLASS__EALL_ATTRIBUTES;
-
-	/**
-	 * The feature id for the '<em><b>EAll References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EALL_REFERENCES = EcorePackage.ECLASS__EALL_REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>EReferences</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EREFERENCES = EcorePackage.ECLASS__EREFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>EAttributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EATTRIBUTES = EcorePackage.ECLASS__EATTRIBUTES;
-
-	/**
-	 * The feature id for the '<em><b>EAll Containments</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EALL_CONTAINMENTS = EcorePackage.ECLASS__EALL_CONTAINMENTS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Operations</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EALL_OPERATIONS = EcorePackage.ECLASS__EALL_OPERATIONS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Structural Features</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EALL_STRUCTURAL_FEATURES = EcorePackage.ECLASS__EALL_STRUCTURAL_FEATURES;
-
-	/**
-	 * The feature id for the '<em><b>EAll Super Types</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EALL_SUPER_TYPES = EcorePackage.ECLASS__EALL_SUPER_TYPES;
-
-	/**
-	 * The feature id for the '<em><b>EID Attribute</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__EID_ATTRIBUTE = EcorePackage.ECLASS__EID_ATTRIBUTE;
-
-	/**
-	 * The feature id for the '<em><b>EStructural Features</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES = EcorePackage.ECLASS__ESTRUCTURAL_FEATURES;
-
-	/**
-	 * The number of structural features of the the '<em>Java Data Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_DATA_TYPE_FEATURE_COUNT = EcorePackage.ECLASS_FEATURE_COUNT + 0;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EANNOTATIONS = JAVA_CLASS__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__NAME = JAVA_CLASS__NAME;
-	/**
-	 * The feature id for the '<em><b>Instance Class Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__INSTANCE_CLASS_NAME = JAVA_CLASS__INSTANCE_CLASS_NAME;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__INSTANCE_CLASS = JAVA_CLASS__INSTANCE_CLASS;
-	/**
-	 * The feature id for the '<em><b>Default Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__DEFAULT_VALUE = JAVA_CLASS__DEFAULT_VALUE;
-
-	/**
-	 * The feature id for the '<em><b>EPackage</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EPACKAGE = JAVA_CLASS__EPACKAGE;
-
-	/**
-	 * The feature id for the '<em><b>Abstract</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__ABSTRACT = JAVA_CLASS__ABSTRACT;
-
-	/**
-	 * The feature id for the '<em><b>Interface</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__INTERFACE = JAVA_CLASS__INTERFACE;
-
-	/**
-	 * The feature id for the '<em><b>ESuper Types</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__ESUPER_TYPES = JAVA_CLASS__ESUPER_TYPES;
-
-	/**
-	 * The feature id for the '<em><b>EOperations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EOPERATIONS = JAVA_CLASS__EOPERATIONS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Attributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EALL_ATTRIBUTES = JAVA_CLASS__EALL_ATTRIBUTES;
-
-	/**
-	 * The feature id for the '<em><b>EAll References</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EALL_REFERENCES = JAVA_CLASS__EALL_REFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>EReferences</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EREFERENCES = JAVA_CLASS__EREFERENCES;
-
-	/**
-	 * The feature id for the '<em><b>EAttributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EATTRIBUTES = JAVA_CLASS__EATTRIBUTES;
-
-	/**
-	 * The feature id for the '<em><b>EAll Containments</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EALL_CONTAINMENTS = JAVA_CLASS__EALL_CONTAINMENTS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Operations</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EALL_OPERATIONS = JAVA_CLASS__EALL_OPERATIONS;
-
-	/**
-	 * The feature id for the '<em><b>EAll Structural Features</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EALL_STRUCTURAL_FEATURES = JAVA_CLASS__EALL_STRUCTURAL_FEATURES;
-
-	/**
-	 * The feature id for the '<em><b>EAll Super Types</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__EALL_SUPER_TYPES = JAVA_CLASS__EALL_SUPER_TYPES;
-
-	/**
-	 * The feature id for the '<em><b>EID Attribute</b></em>' reference.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-  int ARRAY_TYPE__EID_ATTRIBUTE = JAVA_CLASS__EID_ATTRIBUTE;
-
-	/**
-	 * The feature id for the '<em><b>EStructural Features</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__ESTRUCTURAL_FEATURES = JAVA_CLASS__ESTRUCTURAL_FEATURES;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__KIND = JAVA_CLASS__KIND;
-	/**
-	 * The feature id for the '<em><b>Public</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__PUBLIC = JAVA_CLASS__PUBLIC;
-
-	/**
-	 * The feature id for the '<em><b>Final</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE__FINAL = JAVA_CLASS__FINAL;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__IMPLEMENTS_INTERFACES = JAVA_CLASS__IMPLEMENTS_INTERFACES;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__CLASS_IMPORT = JAVA_CLASS__CLASS_IMPORT;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__PACKAGE_IMPORTS = JAVA_CLASS__PACKAGE_IMPORTS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__FIELDS = JAVA_CLASS__FIELDS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__METHODS = JAVA_CLASS__METHODS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__INITIALIZERS = JAVA_CLASS__INITIALIZERS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__DECLARED_CLASSES = JAVA_CLASS__DECLARED_CLASSES;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__DECLARING_CLASS = JAVA_CLASS__DECLARING_CLASS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__JAVA_PACKAGE = JAVA_CLASS__JAVA_PACKAGE;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__EVENTS = JAVA_CLASS__EVENTS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__ALL_EVENTS = JAVA_CLASS__ALL_EVENTS;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__ARRAY_DIMENSIONS = JAVA_CLASS_FEATURE_COUNT + 0;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int ARRAY_TYPE__COMPONENT_TYPE = JAVA_CLASS_FEATURE_COUNT + 1;
-	/**
-	 * The number of structural features of the the '<em>Array Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ARRAY_TYPE_FEATURE_COUNT = JAVA_CLASS_FEATURE_COUNT + 2;
-
-	/**
-	 * The feature id for the '<em><b>EAnnotations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__EANNOTATIONS = EcorePackage.ESTRUCTURAL_FEATURE__EANNOTATIONS;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_EVENT__NAME = EcorePackage.ESTRUCTURAL_FEATURE__NAME;
-	/**
-	 * The feature id for the '<em><b>Ordered</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__ORDERED = EcorePackage.ESTRUCTURAL_FEATURE__ORDERED;
-
-	/**
-	 * The feature id for the '<em><b>Unique</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__UNIQUE = EcorePackage.ESTRUCTURAL_FEATURE__UNIQUE;
-
-	/**
-	 * The feature id for the '<em><b>Lower Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__LOWER_BOUND = EcorePackage.ESTRUCTURAL_FEATURE__LOWER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Upper Bound</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__UPPER_BOUND = EcorePackage.ESTRUCTURAL_FEATURE__UPPER_BOUND;
-
-	/**
-	 * The feature id for the '<em><b>Many</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__MANY = EcorePackage.ESTRUCTURAL_FEATURE__MANY;
-
-	/**
-	 * The feature id for the '<em><b>Required</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__REQUIRED = EcorePackage.ESTRUCTURAL_FEATURE__REQUIRED;
-
-	/**
-	 * The feature id for the '<em><b>EType</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__ETYPE = EcorePackage.ESTRUCTURAL_FEATURE__ETYPE;
-
-	/**
-	 * The feature id for the '<em><b>Changeable</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__CHANGEABLE = EcorePackage.ESTRUCTURAL_FEATURE__CHANGEABLE;
-
-	/**
-	 * The feature id for the '<em><b>Volatile</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__VOLATILE = EcorePackage.ESTRUCTURAL_FEATURE__VOLATILE;
-
-	/**
-	 * The feature id for the '<em><b>Transient</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__TRANSIENT = EcorePackage.ESTRUCTURAL_FEATURE__TRANSIENT;
-
-	/**
-	 * The feature id for the '<em><b>Default Value Literal</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__DEFAULT_VALUE_LITERAL = EcorePackage.ESTRUCTURAL_FEATURE__DEFAULT_VALUE_LITERAL;
-
-	/**
-	 * The feature id for the '<em><b>Default Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__DEFAULT_VALUE = EcorePackage.ESTRUCTURAL_FEATURE__DEFAULT_VALUE;
-
-	/**
-	 * The feature id for the '<em><b>Unsettable</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__UNSETTABLE = EcorePackage.ESTRUCTURAL_FEATURE__UNSETTABLE;
-
-	/**
-	 * The feature id for the '<em><b>Derived</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__DERIVED = EcorePackage.ESTRUCTURAL_FEATURE__DERIVED;
-
-	/**
-	 * The feature id for the '<em><b>EContaining Class</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT__ECONTAINING_CLASS = EcorePackage.ESTRUCTURAL_FEATURE__ECONTAINING_CLASS;
-
-	/**
-	 * The number of structural features of the the '<em>Java Event</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int JAVA_EVENT_FEATURE_COUNT = EcorePackage.ESTRUCTURAL_FEATURE_FEATURE_COUNT + 0;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_VISIBILITY_KIND = 13;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int JAVA_PARAMETER_KIND = 14;
-	/**
-	 * The meta object id for the '<em>JType Java Helpers</em>' data type.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jem.java.JavaHelpers
-	 * @see org.eclipse.jem.java.internal.impl.JavaRefPackageImpl#getJTypeJavaHelpers()
-	 * @generated
-	 */
-	int JTYPE_JAVA_HELPERS = 15;
-
-	/**
-	 * The meta object id for the '<em>JType List</em>' data type.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see java.util.List
-	 * @see org.eclipse.jem.java.internal.impl.JavaRefPackageImpl#getJTypeList()
-	 * @generated
-	 */
-	int JTYPE_LIST = 16;
-
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	int TYPE_KIND = 12;
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	String eNS_URI = "java.xmi";
-	/**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_PREFIX = "org.eclipse.jem.java";
-
-	/**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	JavaRefPackage eINSTANCE = org.eclipse.jem.java.internal.impl.JavaRefPackageImpl.init();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaClass object
-	 */
-	EClass getJavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getJavaClass_Kind();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.JavaClass#isPublic <em>Public</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Public</em>'.
-	 * @see org.eclipse.jem.java.JavaClass#isPublic()
-	 * @see #getJavaClass()
-	 * @generated
-	 */
-	EAttribute getJavaClass_Public();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.JavaClass#isFinal <em>Final</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Final</em>'.
-	 * @see org.eclipse.jem.java.JavaClass#isFinal()
-	 * @see #getJavaClass()
-	 * @generated
-	 */
-	EAttribute getJavaClass_Final();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_ImplementsInterfaces();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_ClassImport();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_PackageImports();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_Fields();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_Methods();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_Initializers();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_DeclaringClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_DeclaredClasses();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_JavaPackage();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_Events();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaClass_AllEvents();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Field object
-	 */
-	EClass getField();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Field#isFinal <em>Final</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Final</em>'.
-	 * @see org.eclipse.jem.java.Field#isFinal()
-	 * @see #getField()
-	 * @generated
-	 */
-	EAttribute getField_Final();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Field#isStatic <em>Static</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Static</em>'.
-	 * @see org.eclipse.jem.java.Field#isStatic()
-	 * @see #getField()
-	 * @generated
-	 */
-	EAttribute getField_Static();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getField_JavaVisibility();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Field#isTransient <em>Transient</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Transient</em>'.
-	 * @see org.eclipse.jem.java.Field#isTransient()
-	 * @see #getField()
-	 * @generated
-	 */
-	EAttribute getField_Transient();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Field#isVolatile <em>Volatile</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Volatile</em>'.
-	 * @see org.eclipse.jem.java.Field#isVolatile()
-	 * @see #getField()
-	 * @generated
-	 */
-	EAttribute getField_Volatile();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getField_JavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getField_Initializer();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Method object
-	 */
-	EClass getMethod();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Method#isAbstract <em>Abstract</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Abstract</em>'.
-	 * @see org.eclipse.jem.java.Method#isAbstract()
-	 * @see #getMethod()
-	 * @generated
-	 */
-	EAttribute getMethod_Abstract();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Method#isNative <em>Native</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Native</em>'.
-	 * @see org.eclipse.jem.java.Method#isNative()
-	 * @see #getMethod()
-	 * @generated
-	 */
-	EAttribute getMethod_Native();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Method#isSynchronized <em>Synchronized</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Synchronized</em>'.
-	 * @see org.eclipse.jem.java.Method#isSynchronized()
-	 * @see #getMethod()
-	 * @generated
-	 */
-	EAttribute getMethod_Synchronized();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Method#isFinal <em>Final</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Final</em>'.
-	 * @see org.eclipse.jem.java.Method#isFinal()
-	 * @see #getMethod()
-	 * @generated
-	 */
-	EAttribute getMethod_Final();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Method#isConstructor <em>Constructor</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Constructor</em>'.
-	 * @see org.eclipse.jem.java.Method#isConstructor()
-	 * @see #getMethod()
-	 * @generated
-	 */
-	EAttribute getMethod_Constructor();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.Method#isStatic <em>Static</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Static</em>'.
-	 * @see org.eclipse.jem.java.Method#isStatic()
-	 * @see #getMethod()
-	 * @generated
-	 */
-	EAttribute getMethod_Static();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getMethod_JavaVisibility();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getMethod_Parameters();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getMethod_JavaExceptions();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getMethod_JavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getMethod_Source();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaParameter object
-	 */
-	EClass getJavaParameter();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jem.java.JavaParameter#isFinal <em>Final</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Final</em>'.
-	 * @see org.eclipse.jem.java.JavaParameter#isFinal()
-	 * @see #getJavaParameter()
-	 * @generated
-	 */
-	EAttribute getJavaParameter_Final();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getJavaParameter_ParameterKind();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return ArrayType object
-	 */
-	EClass getArrayType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getArrayType_ArrayDimensions();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getArrayType_ComponentType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaDataType object
-	 */
-	EClass getJavaDataType();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaEvent object
-	 */
-	EClass getJavaEvent();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaPackage object
-	 */
-	EClass getJavaPackage();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getJavaPackage_JavaClasses();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Block object
-	 */
-	EClass getBlock();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getBlock_Source();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getBlock_Name();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getBlock_Contents();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Comment object
-	 */
-	EClass getComment();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Statement object
-	 */
-	EClass getStatement();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return Initializer object
-	 */
-	EClass getInitializer();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EAttribute getInitializer_IsStatic();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getInitializer_JavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	EReference getInitializer_Source();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaVisibilityKind object
-	 */
-	EEnum getJavaVisibilityKind();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JavaParameterKind object
-	 */
-	EEnum getJavaParameterKind();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return TypeKind object
-	 */
-	EEnum getTypeKind();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JTypeList object
-	 */
-	EDataType getJTypeList();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return JTypeJavaHelpers object
-	 */
-	EDataType getJTypeJavaHelpers();
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	JavaRefFactory getJavaRefFactory();
-
-} //JavaRefPackage
-
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaURL.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaURL.java
deleted file mode 100644
index 9994d3f..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaURL.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: JavaURL.java,v $
- *  $Revision: 1.6 $  $Date: 2005/09/14 23:30:35 $ 
- */
-
-
-public class JavaURL extends org.eclipse.jem.java.internal.impl.URL {
-	public static final String JAVA_PROTOCOL_URI_PREFIX = "java:/"; //$NON-NLS-1$
-	/**
-	 * JavaURL constructor comment.
-	 * @param urlString java.lang.String
-	 */
-	public JavaURL(String urlString) {
-		super(urlString);
-	}
-	/**
-	 * JavaURL constructor comment.
-	 * @param nameSpaceName java.lang.String
-	 * @param iD java.lang.String
-	 */
-	public JavaURL(String nameSpaceName, String iD) {
-		super(null, null);
-		initializeNamespaceString(nameSpaceName);
-		this.ID = iD;
-	}
-	public String getClassName() {
-		return ID;
-	}
-	/**
-	 * This method was created in VisualAge.
-	 * @return java.lang.String
-	 */
-	public String getFullString() {
-		StringBuffer buf = new StringBuffer();
-		if (namespaceName != null) {
-			buf.append(namespaceName);
-			if (ID != null)
-				buf.append("#"); //$NON-NLS-1$
-		}
-		if (ID != null)
-			buf.append(ID);
-		return buf.toString();
-	}
-	public String getPackageName() {
-		String internalName = namespaceName.substring(JAVA_PROTOCOL_URI_PREFIX.length(), namespaceName.length());
-		return JavaPackage.PRIMITIVE_PACKAGE_NAME.equals(internalName) ? "" : internalName; //$NON-NLS-1$
-	}
-	/* If we don't have a # sign to delimit the start of the java package us the inherited behavior
-	 */
-	public void initializeFromString(String url) {
-		if (url.indexOf("#") != -1) //$NON-NLS-1$
-			super.initializeFromString(url);
-		else {
-			int endOfPackageName = url.lastIndexOf('.');
-			if (endOfPackageName == -1)
-				initializeNamespaceString(null);
-			else
-				initializeNamespaceString(url.substring(0, endOfPackageName));
-			ID = url.substring(endOfPackageName + 1);
-		}
-
-	}
-	/* 
-	 */
-	public void initializeNamespaceString(String aNamespaceName) {
-		if (aNamespaceName == null)
-			namespaceName = JAVA_PROTOCOL_URI_PREFIX;
-		else
-			namespaceName = JAVA_PROTOCOL_URI_PREFIX + aNamespaceName;
-	}
-	public static boolean isJavaURL(String aUrlString) {
-		if (aUrlString == null)
-			return false;
-		return aUrlString.startsWith(JAVA_PROTOCOL_URI_PREFIX);
-	}
-
-	public String toString() {
-		return "URL(" + getFullString() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaVisibilityKind.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaVisibilityKind.java
deleted file mode 100644
index 4ce813d..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/JavaVisibilityKind.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: JavaVisibilityKind.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.emf.common.util.AbstractEnumerator;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Java Visibility Kind</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * PACKAGE=1
- * PUBLIC=2
- * PRIVATE=3
- * PROTECTED=4
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.java.JavaRefPackage#getJavaVisibilityKind()
- * @model
- * @generated
- */
-public final class JavaVisibilityKind extends AbstractEnumerator
-{
-	/**
-	 * The '<em><b>PUBLIC</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #PUBLIC_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int PUBLIC = 0;
-
-	/**
-	 * The '<em><b>PRIVATE</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #PRIVATE_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int PRIVATE = 1;
-
-	/**
-	 * The '<em><b>PROTECTED</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #PROTECTED_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int PROTECTED = 2;
-
-	/**
-	 * The '<em><b>PACKAGE</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #PACKAGE_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int PACKAGE = 3;
-
-	/**
-	 * The '<em><b>PUBLIC</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>PUBLIC</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #PUBLIC
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaVisibilityKind PUBLIC_LITERAL = new JavaVisibilityKind(PUBLIC, "PUBLIC");
-
-	/**
-	 * The '<em><b>PRIVATE</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>PRIVATE</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #PRIVATE
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaVisibilityKind PRIVATE_LITERAL = new JavaVisibilityKind(PRIVATE, "PRIVATE");
-
-	/**
-	 * The '<em><b>PROTECTED</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>PROTECTED</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #PROTECTED
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaVisibilityKind PROTECTED_LITERAL = new JavaVisibilityKind(PROTECTED, "PROTECTED");
-
-	/**
-	 * The '<em><b>PACKAGE</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>PACKAGE</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #PACKAGE
-	 * @generated
-	 * @ordered
-	 */
-  public static final JavaVisibilityKind PACKAGE_LITERAL = new JavaVisibilityKind(PACKAGE, "PACKAGE");
-
-	/**
-	 * An array of all the '<em><b>Java Visibility Kind</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  private static final JavaVisibilityKind[] VALUES_ARRAY =
-		new JavaVisibilityKind[] {
-			PUBLIC_LITERAL,
-			PRIVATE_LITERAL,
-			PROTECTED_LITERAL,
-			PACKAGE_LITERAL,
-		};
-
-	/**
-	 * A public read-only list of all the '<em><b>Java Visibility Kind</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
-
-	/**
-	 * Returns the '<em><b>Java Visibility Kind</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  public static JavaVisibilityKind get(String name) {
-		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
-			JavaVisibilityKind result = VALUES_ARRAY[i];
-			if (result.toString().equals(name)) {
-				return result;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the '<em><b>Java Visibility Kind</b></em>' literal with the specified value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  public static JavaVisibilityKind get(int value) {
-		switch (value) {
-			case PUBLIC: return PUBLIC_LITERAL;
-			case PRIVATE: return PRIVATE_LITERAL;
-			case PROTECTED: return PROTECTED_LITERAL;
-			case PACKAGE: return PACKAGE_LITERAL;
-		}
-		return null;	
-	}
-
-	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  private JavaVisibilityKind(int value, String name) {
-		super(value, name);
-	}
-
-} //JavaVisibilityKind
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Method.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Method.java
deleted file mode 100644
index 3e5369e..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Method.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-
-/*
- *  $RCSfile: Method.java,v $
- *  $Revision: 1.7 $  $Date: 2005/09/15 13:42:04 $ 
- */
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EOperation;
-
-/**
- * @generated
- */
-public interface Method extends EOperation{
-
-	public static final String GENERATED_COMMENT_TAG = "@generated";
-	/**
-	 * Lists all the parameters, excluding the return type
-	 */ 
-	public JavaParameter[] listParametersWithoutReturn();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsAbstract attribute
-	 */
-	boolean isAbstract();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#isAbstract <em>Abstract</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Abstract</em>' attribute.
-	 * @see #isAbstract()
-	 * @generated
-	 */
-	void setAbstract(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsNative attribute
-	 */
-	boolean isNative();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#isNative <em>Native</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Native</em>' attribute.
-	 * @see #isNative()
-	 * @generated
-	 */
-	void setNative(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsSynchronized attribute
-	 */
-	boolean isSynchronized();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#isSynchronized <em>Synchronized</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Synchronized</em>' attribute.
-	 * @see #isSynchronized()
-	 * @generated
-	 */
-	void setSynchronized(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsFinal attribute
-	 */
-	boolean isFinal();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#isFinal <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Final</em>' attribute.
-	 * @see #isFinal()
-	 * @generated
-	 */
-	void setFinal(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsConstructor attribute
-	 */
-	boolean isConstructor();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#isConstructor <em>Constructor</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Constructor</em>' attribute.
-	 * @see #isConstructor()
-	 * @generated
-	 */
-	void setConstructor(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the IsStatic attribute
-	 */
-	boolean isStatic();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#isStatic <em>Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Static</em>' attribute.
-	 * @see #isStatic()
-	 * @generated
-	 */
-	void setStatic(boolean value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The value of the JavaVisibility attribute
-	 */
-	JavaVisibilityKind getJavaVisibility();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#getJavaVisibility <em>Java Visibility</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Java Visibility</em>' attribute.
-	 * @see org.eclipse.jem.java.JavaVisibilityKind
-	 * @see #getJavaVisibility()
-	 * @generated
-	 */
-	void setJavaVisibility(JavaVisibilityKind value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of Parameters references
-	 */
-	EList getParameters();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The list of JavaExceptions references
-	 */
-	EList getJavaExceptions();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The JavaClass reference
-	 */
-	JavaClass getJavaClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#getJavaClass <em>Java Class</em>}' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Java Class</em>' container reference.
-	 * @see #getJavaClass()
-	 * @generated
-	 */
-	void setJavaClass(JavaClass value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * @return The Source reference
-	 */
-	Block getSource();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jem.java.Method#getSource <em>Source</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Source</em>' reference.
-	 * @see #getSource()
-	 * @generated
-	 */
-	void setSource(Block value);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return the java class that this method is defined in.
-	 */
-	JavaClass getContainingJavaClass();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return a String with the the method name and its parameters. e.g. <code>
-	 * setFirstName(java.lang.String) <//code> .
-	 *  
-	 */
-	String getMethodElementSignature();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Return a Parameter with the passed name, or null.
-	 */
-	JavaParameter getParameter(String parameterName);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Get the return type.
-	 */
-	JavaHelpers getReturnType();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Set the return type
-	 * <!-- end-model-doc -->
-	 * @model typeDataType="org.eclipse.jem.java.JTypeJavaHelpers"
-	 * @generated
-	 */
-	void setReturnType(JavaHelpers type);
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Replicate the functionality of java.lang.reflect.Method.toString().
-	 * 
-	 * Returns a string describing this Method.  The string is formatted as the method 
-	 * access modifiers, if any, followed by the method return type, followed by a
-	 * space, followed by the class declaring the method, followed by a period,
-	 * followed by the method name, followed by a parenthesized, comma-separated list
-	 * of the method's formal parameter types. If the method throws checked
-	 * exceptions, the parameter list is followed by a space, followed by the word
-	 * throws followed by a comma-separated list of the thrown exception types.
-	 * 
-	 * For example:
-	 * 
-	 *     public boolean java.lang.Object.equals(java.lang.Object)
-	 * 
-	 * The access modifiers are placed in canonical order as specified by "The Java
-	 * Language Specification".  This is public, <tt>protected<//tt> or
-	 * <tt>private<//tt> first, and then other modifiers in the following order:
-	 * <tt>abstract<//tt>, <tt>static<//tt>, <tt>final<//tt>, <tt>synchronized<//tt>
-	 * <tt>native<//tt>.
-
-	 */
-	String getSignature();
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 * Returns true if the method is system generated.
-	 * This is usually determined by the @generated tag in the comment.
-	 */
-	boolean isGenerated();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * Set the isGenerated flag.
-	 * <!-- end-model-doc -->
-	 * @model
-	 * @generated
-	 */
-	void setIsGenerated(boolean generated);
-
-    /**
-	 * @generated This field/method will be replaced during code generation 
-	 * Is this a void return type method.
-	 */
-	boolean isVoid();
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Statement.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Statement.java
deleted file mode 100644
index 1aa557e..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/Statement.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: Statement.java,v $
- *  $Revision: 1.5 $  $Date: 2005/08/24 20:20:24 $ 
- */
-package org.eclipse.jem.java;
-
-/**
- * @generated
- */
-public interface Statement extends Block {
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/TypeKind.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/TypeKind.java
deleted file mode 100644
index e2a5769..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/TypeKind.java
+++ /dev/null
@@ -1,200 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java;
-/*
- *  $RCSfile: TypeKind.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.emf.common.util.AbstractEnumerator;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Type Kind</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * UNDEFINED=1 CLASS=2 INTERFACE=3 EXCEPTION=4
- * <!-- end-model-doc -->
- * @see org.eclipse.jem.java.JavaRefPackage#getTypeKind()
- * @model
- * @generated
- */
-public final class TypeKind extends AbstractEnumerator
-{
-	/**
-	 * The '<em><b>UNDEFINED</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #UNDEFINED_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int UNDEFINED = 0;
-
-	/**
-	 * The '<em><b>CLASS</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #CLASS_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int CLASS = 1;
-
-	/**
-	 * The '<em><b>INTERFACE</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #INTERFACE_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int INTERFACE = 2;
-
-	/**
-	 * The '<em><b>EXCEPTION</b></em>' literal value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @see #EXCEPTION_LITERAL
-	 * @model
-	 * @generated
-	 * @ordered
-	 */
-  public static final int EXCEPTION = 3;
-
-	/**
-	 * The '<em><b>UNDEFINED</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>UNDEFINED</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #UNDEFINED
-	 * @generated
-	 * @ordered
-	 */
-  public static final TypeKind UNDEFINED_LITERAL = new TypeKind(UNDEFINED, "UNDEFINED");
-
-	/**
-	 * The '<em><b>CLASS</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>CLASS</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #CLASS
-	 * @generated
-	 * @ordered
-	 */
-  public static final TypeKind CLASS_LITERAL = new TypeKind(CLASS, "CLASS");
-
-	/**
-	 * The '<em><b>INTERFACE</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>INTERFACE</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #INTERFACE
-	 * @generated
-	 * @ordered
-	 */
-  public static final TypeKind INTERFACE_LITERAL = new TypeKind(INTERFACE, "INTERFACE");
-
-	/**
-	 * The '<em><b>EXCEPTION</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-   * <p>
-   * If the meaning of '<em><b>EXCEPTION</b></em>' literal object isn't clear,
-   * there really should be more of a description here...
-   * </p>
-   * <!-- end-user-doc -->
-	 * @see #EXCEPTION
-	 * @generated
-	 * @ordered
-	 */
-  public static final TypeKind EXCEPTION_LITERAL = new TypeKind(EXCEPTION, "EXCEPTION");
-
-	/**
-	 * An array of all the '<em><b>Type Kind</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  private static final TypeKind[] VALUES_ARRAY =
-		new TypeKind[] {
-			UNDEFINED_LITERAL,
-			CLASS_LITERAL,
-			INTERFACE_LITERAL,
-			EXCEPTION_LITERAL,
-		};
-
-	/**
-	 * A public read-only list of all the '<em><b>Type Kind</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
-
-	/**
-	 * Returns the '<em><b>Type Kind</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  public static TypeKind get(String name) {
-		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
-			TypeKind result = VALUES_ARRAY[i];
-			if (result.toString().equals(name)) {
-				return result;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the '<em><b>Type Kind</b></em>' literal with the specified value.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  public static TypeKind get(int value) {
-		switch (value) {
-			case UNDEFINED: return UNDEFINED_LITERAL;
-			case CLASS: return CLASS_LITERAL;
-			case INTERFACE: return INTERFACE_LITERAL;
-			case EXCEPTION: return EXCEPTION_LITERAL;
-		}
-		return null;	
-	}
-
-	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
-	 * @generated
-	 */
-  private TypeKind(int value, String name) {
-		super(value, name);
-	}
-
-} //TypeKind
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/IJavaReflectionKey.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/IJavaReflectionKey.java
deleted file mode 100644
index 4605d58..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/IJavaReflectionKey.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IJavaReflectionKey.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-package org.eclipse.jem.java.adapters;
-
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.jem.java.*;
-
-public interface IJavaReflectionKey {
-
-	/* Constants for the primitive type names
-	 * These are the values which are used to refer to a primitive type,
-	 * i.e. new JavaURL("int")  or new URL("java://#int")
-	 * These types are cached by pre-loading documents for the primitives,
-	 * in "java://", and for the java.lang (Object and String) classes
-	 */
-	static final public String N_VOID = "void";	 //$NON-NLS-1$
-	static final public String N_INT = "int";//$NON-NLS-1$
-	static final public String N_BOOLEAN = "boolean";//$NON-NLS-1$
-	static final public String N_CHAR = "char";//$NON-NLS-1$
-	static final public String N_BYTE = "byte";//$NON-NLS-1$
-	static final public String N_LONG = "long";//$NON-NLS-1$
-	static final public String N_FLOAT = "float";//$NON-NLS-1$
-	static final public String N_DOUBLE = "double";//$NON-NLS-1$
-	static final public String N_SHORT = "short";//$NON-NLS-1$
-
-	/* 
-	 * Create an ArrayType instance in the current document
-	 * Handles the push and pop of the current document.
-	 */
-	public abstract ArrayType createArrayType();
-
-	/* 
-	 * Create a JavaClass instance in the current document
-	 * Handles the push and pop of the current document.
-	 */
-	public abstract JavaClass createJavaClass();
-
-	/* 
-	 * Create a Field instance in the current document
-	 * Handles the push and pop of the current document.
-	 */
-	public abstract Field createJavaField();
-
-	/* 
-	 * Create a Method instance in the current document
-	 * Handles the push and pop of the current document.
-	 */
-	public abstract Method createJavaMethod();
-
-	/* 
-	 * Create a JavaParameter instance in the current document
-	 */
-	public abstract JavaParameter createJavaParameter();
-
-	//FB/**
-	//FB * Override to try to introspect objects
-	//FB * that aren't found using the default mechanism.
-	//FB */
-	//FBpublic Object get(Object key) {
-	//FB 	Object javaObject = super.get(key);
-	//FB 	if (javaObject == null) {
-	//FB 		javaObject = getObjectFromExtensions((String) key);
-	//FB 		if (javaObject == null)
-	//FB 			javaObject = getJavaObject((String) key);
-	//FB 	}
-	//FB	return javaObject;
-	//FB}
-
-	//FB ADDED
-	public abstract Object get(String key);
-
-	//FB END
-
-	/*
-	 * Instantiate the named class.
-	 * If we make it to this point, the class has not yet been instantiated or reflected.
-	 */
-	public abstract EClassifier getArrayType(String typeName);
-
-	/*
-	 * Instantiate the named class.
-	 * If we make it to this point, teh class has not yet been instantiated or reflected.
-	 */
-	public abstract EClassifier getJavaClass(String typeName);
-
-	/**
-	 * This allows for the retrieval of attributes/methods with the following notation:
-	 * field: java:/com.ibm.foo#Test.foo
-	 * method: java:/com.ibm.foo#Test.foofoo(
-	 * parameter: java:/com.ibm.foo#Test.foofoo(-arg0
-	 * 
-	 */
-	public abstract EObject getJavaObject(String keyValue);
-
-	/**
-	 * Insert the method's description here.
-	 * Creation date: (10/4/2000 9:52:28 AM)
-	 * @return org.eclipse.emf.ecore.EClassifier
-	 * @param typeName java.lang.String
-	 */
-	public abstract EClassifier getJavaType(String typeName);
-
-	/**
-	 * Get the object from the key but don't do any 
-	 * tries at creation of the key if not found.
-	 * The Key must be an ID for it to be found.
-	 */
-	public abstract Object primGet(String key);
-
-	/**
-	 * Return true if the passed type represents a Java Array type
-	 */
-	public abstract boolean isArray(String typeName);
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/IJavaReflectionKeyExtension.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/IJavaReflectionKeyExtension.java
deleted file mode 100644
index ba6d35b..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/IJavaReflectionKeyExtension.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: IJavaReflectionKeyExtension.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-package org.eclipse.jem.java.adapters;
-
-/**
- * Extension interface to add an additional reflection key in to handle
- * other types of key's not specifically handled.
- * 
- * @since 1.0.0
- */
-public interface IJavaReflectionKeyExtension {
-
-	/**
-	 * Get the object from the given id.
-	 * @param id
-	 * @param reflectionKey
-	 * @return the object (it should add the id with object to the resource's id table before returning it) or <code>null</code> if not one it handles.
-	 * 
-	 * @since 1.0.0
-	 */
-	public Object getObject(String id, IJavaReflectionKey reflectionKey);
-	
-}
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/JavaXMIFactory.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/JavaXMIFactory.java
deleted file mode 100644
index 78df6fd..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/adapters/JavaXMIFactory.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaXMIFactory.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-package org.eclipse.jem.java.adapters;
-
-import org.eclipse.jem.internal.java.adapters.JavaXMIFactoryImpl;
- 
-
-/**
- * Factory for Java XMI Resources.
- * @since 1.2.0
- */
-public interface JavaXMIFactory {
-
-	/**
-	 * Scheme used in URI's for jem elements.
-	 * @since 1.2.0
-	 */
-	public static final String SCHEME = "java"; //$NON-NLS-1$
-	public static final JavaXMIFactory INSTANCE = new JavaXMIFactoryImpl();
-
-	/**
-	 * Register the reflection key extension.
-	 * @param extension
-	 * 
-	 * @since 1.2.0
-	 */
-	public void registerReflectionKeyExtension(IJavaReflectionKeyExtension extension);
-	
-	/**
-	 * Deregister the reflection key extension.
-	 * @param extension
-	 * 
-	 * @since 1.2.0
-	 */
-	public void deregisterReflectionKeyExtension(IJavaReflectionKeyExtension extension);
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/ArrayTypeImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/ArrayTypeImpl.java
deleted file mode 100644
index 8de14f6..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/ArrayTypeImpl.java
+++ /dev/null
@@ -1,688 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: ArrayTypeImpl.java,v $
- *  $Revision: 1.2 $  $Date: 2005/09/15 20:28:04 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.ArrayType;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaHelpers;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.TypeKind;
-
-/**
- * Describes a Java Array type
- *    For multi-dimensional arrays, it is unlikely that the component type will be
- *    specified directly.  This would require instantiating a chain of component types
- *    such as String[][][][]->String[][][]->String[][]->String[]->String.
- * 
- *   The component type relationship will be computed if the finalComponentType
- *   and array dimensions is specified.
- *  
- *   For this reason, the preferred way to create is through the JavaRefFactory factory method:
- *        createArrayType(JavaClass finalComponentType, int dimensions)
- */
-public class ArrayTypeImpl extends JavaClassImpl implements ArrayType, JavaClass{
-
-	/**
-	 * The default value of the '{@link #getArrayDimensions() <em>Array Dimensions</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getArrayDimensions()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int ARRAY_DIMENSIONS_EDEFAULT = 0;
-
-	
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected int arrayDimensions = ARRAY_DIMENSIONS_EDEFAULT;
-	/**
-	 * The cached value of the '{@link #getComponentType() <em>Component Type</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getComponentType()
-	 * @generated
-	 * @ordered
-	 */
-	protected EClassifier componentType = null;
-	
-	protected JavaHelpers finalComponentType = null;
-
-	protected ArrayTypeImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getArrayType();
-	}
-
-	/**
-	 * Compute the component type for this array type from our type name.
-	 * The component type of this array type is essentially: new ArrayTypeImpl(finalComponentType, arrayDimensions-1)
-	 * unless our array dimension is 1, in which case it is only our final component type.
-	 *
-	 * In order to ensure a unique instance, we will resolve this type using reflection.
-	 * "java.lang.String[][]" component type is "java.lang.String[]"
-	 *
-	 */
-	public JavaHelpers computeComponentType() {
-		String componentName = getQualifiedNameForReflection();
-		// Strip the last [] form my name to get my component type's name
-		componentName = componentName.substring(0, componentName.length() - 2);
-		return JavaRefFactory.eINSTANCE.reflectType(componentName, this);
-	}
-	/**
-	 * Override to perform some lazy initialization
-	 */
-	public EClassifier getComponentType() {
-		// If we do not have a component type set, but we have a name (which contains our component type name)
-		// we can compute the component type.
-		if ((this.getComponentTypeGen() == null) && (this.getName() != null)) {
-			componentType = computeComponentType();
-		}
-		return getComponentTypeGen();
-	}
-	/**
-	 * Get the component type of this array. 
-	 * 
-	 * If this is a multi-dimensional array, the component type will be the nested array type.
-	 */
-	public JavaHelpers getComponentTypeAsHelper() {
-		return (JavaHelpers) getComponentType();
-	}
-	/**
-	 * Get the final component type for this Array Type.
-	 * 
-	 * In order to ensure a unique instance, we will resolve this type using reflection. It turns out to be most efficient to just do this by trimming the name.
-	 */
-	public JavaHelpers getFinalComponentType() {
-		if (finalComponentType == null) {
-			String componentName = getQualifiedNameForReflection();
-			// Strip all the [] from my name to get my FINAL component type's name
-			componentName = componentName.substring(0, componentName.indexOf("["));
-			finalComponentType = JavaRefFactory.eINSTANCE.reflectType(componentName, this);
-		}
-		return finalComponentType;
-	}
-	/**
-	 * (JavaHelpers)isArray - ArrayTypes are arrays
-	 * Override from JavaClass.
-	 */    
-	public boolean isArray() {
-		return true;
-	}
-	/**
-	 * Is this an array of java primitives
-	 */
-	public boolean isPrimitiveArray() {
-		return getFinalComponentType().isPrimitive();
-	}
-	/**
-	 * Set the component type.
-	 */
-	public void setComponentType(JavaHelpers helperComponentType) {
-		setComponentType((EClassifier) helperComponentType);		
-	}
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public int getArrayDimensions() {
-		return arrayDimensions;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void setArrayDimensions(int newArrayDimensions) {
-		int oldArrayDimensions = arrayDimensions;
-		arrayDimensions = newArrayDimensions;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.ARRAY_TYPE__ARRAY_DIMENSIONS, oldArrayDimensions, arrayDimensions));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.ARRAY_TYPE__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.ARRAY_TYPE__INSTANCE_CLASS_NAME:
-				return INSTANCE_CLASS_NAME_EDEFAULT == null ? instanceClassName != null : !INSTANCE_CLASS_NAME_EDEFAULT.equals(instanceClassName);
-			case JavaRefPackage.ARRAY_TYPE__INSTANCE_CLASS:
-				return INSTANCE_CLASS_EDEFAULT == null ? getInstanceClass() != null : !INSTANCE_CLASS_EDEFAULT.equals(getInstanceClass());
-			case JavaRefPackage.ARRAY_TYPE__DEFAULT_VALUE:
-				return DEFAULT_VALUE_EDEFAULT == null ? getDefaultValue() != null : !DEFAULT_VALUE_EDEFAULT.equals(getDefaultValue());
-			case JavaRefPackage.ARRAY_TYPE__EPACKAGE:
-				return getEPackage() != null;
-			case JavaRefPackage.ARRAY_TYPE__ABSTRACT:
-				return ((eFlags & ABSTRACT_EFLAG) != 0) != ABSTRACT_EDEFAULT;
-			case JavaRefPackage.ARRAY_TYPE__INTERFACE:
-				return ((eFlags & INTERFACE_EFLAG) != 0) != INTERFACE_EDEFAULT;
-			case JavaRefPackage.ARRAY_TYPE__ESUPER_TYPES:
-				return eSuperTypes != null && !eSuperTypes.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EOPERATIONS:
-				return eOperations != null && !eOperations.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EALL_ATTRIBUTES:
-				return !getEAllAttributes().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EALL_REFERENCES:
-				return !getEAllReferences().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EREFERENCES:
-				return !getEReferences().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EATTRIBUTES:
-				return !getEAttributes().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EALL_CONTAINMENTS:
-				return !getEAllContainments().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EALL_OPERATIONS:
-				return !getEAllOperations().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EALL_STRUCTURAL_FEATURES:
-				return !getEAllStructuralFeatures().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EALL_SUPER_TYPES:
-				return !getEAllSuperTypes().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__EID_ATTRIBUTE:
-				return getEIDAttribute() != null;
-			case JavaRefPackage.ARRAY_TYPE__ESTRUCTURAL_FEATURES:
-				return eStructuralFeatures != null && !eStructuralFeatures.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__KIND:
-				return kind != KIND_EDEFAULT;
-			case JavaRefPackage.ARRAY_TYPE__PUBLIC:
-				return ((eFlags & PUBLIC_EFLAG) != 0) != PUBLIC_EDEFAULT;
-			case JavaRefPackage.ARRAY_TYPE__FINAL:
-				return ((eFlags & FINAL_EFLAG) != 0) != FINAL_EDEFAULT;
-			case JavaRefPackage.ARRAY_TYPE__IMPLEMENTS_INTERFACES:
-				return implementsInterfaces != null && !implementsInterfaces.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__CLASS_IMPORT:
-				return classImport != null && !classImport.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__PACKAGE_IMPORTS:
-				return packageImports != null && !packageImports.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__FIELDS:
-				return fields != null && !fields.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__METHODS:
-				return methods != null && !methods.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__INITIALIZERS:
-				return initializers != null && !initializers.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__DECLARED_CLASSES:
-				return declaredClasses != null && !declaredClasses.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__DECLARING_CLASS:
-				return declaringClass != null;
-			case JavaRefPackage.ARRAY_TYPE__JAVA_PACKAGE:
-				return basicGetJavaPackage() != null;
-			case JavaRefPackage.ARRAY_TYPE__EVENTS:
-				return events != null && !events.isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__ALL_EVENTS:
-				return !getAllEvents().isEmpty();
-			case JavaRefPackage.ARRAY_TYPE__ARRAY_DIMENSIONS:
-				return arrayDimensions != ARRAY_DIMENSIONS_EDEFAULT;
-			case JavaRefPackage.ARRAY_TYPE__COMPONENT_TYPE:
-				return componentType != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.ARRAY_TYPE__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__INSTANCE_CLASS_NAME:
-				setInstanceClassName((String)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ABSTRACT:
-				setAbstract(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.ARRAY_TYPE__INTERFACE:
-				setInterface(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ESUPER_TYPES:
-				getESuperTypes().clear();
-				getESuperTypes().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__EOPERATIONS:
-				getEOperations().clear();
-				getEOperations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ESTRUCTURAL_FEATURES:
-				getEStructuralFeatures().clear();
-				getEStructuralFeatures().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__KIND:
-				setKind((TypeKind)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__PUBLIC:
-				setPublic(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.ARRAY_TYPE__FINAL:
-				setFinal(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.ARRAY_TYPE__IMPLEMENTS_INTERFACES:
-				getImplementsInterfaces().clear();
-				getImplementsInterfaces().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__CLASS_IMPORT:
-				getClassImport().clear();
-				getClassImport().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__PACKAGE_IMPORTS:
-				getPackageImports().clear();
-				getPackageImports().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__FIELDS:
-				getFields().clear();
-				getFields().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__METHODS:
-				getMethods().clear();
-				getMethods().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__INITIALIZERS:
-				getInitializers().clear();
-				getInitializers().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__DECLARED_CLASSES:
-				getDeclaredClasses().clear();
-				getDeclaredClasses().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__DECLARING_CLASS:
-				setDeclaringClass((JavaClass)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__EVENTS:
-				getEvents().clear();
-				getEvents().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ALL_EVENTS:
-				getAllEvents().clear();
-				getAllEvents().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ARRAY_DIMENSIONS:
-				setArrayDimensions(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.ARRAY_TYPE__COMPONENT_TYPE:
-				setComponentType((EClassifier)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.ARRAY_TYPE__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__INSTANCE_CLASS_NAME:
-				setInstanceClassName(INSTANCE_CLASS_NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ABSTRACT:
-				setAbstract(ABSTRACT_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__INTERFACE:
-				setInterface(INTERFACE_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ESUPER_TYPES:
-				getESuperTypes().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__EOPERATIONS:
-				getEOperations().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ESTRUCTURAL_FEATURES:
-				getEStructuralFeatures().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__KIND:
-				setKind(KIND_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__PUBLIC:
-				setPublic(PUBLIC_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__FINAL:
-				setFinal(FINAL_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__IMPLEMENTS_INTERFACES:
-				getImplementsInterfaces().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__CLASS_IMPORT:
-				getClassImport().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__PACKAGE_IMPORTS:
-				getPackageImports().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__FIELDS:
-				getFields().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__METHODS:
-				getMethods().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__INITIALIZERS:
-				getInitializers().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__DECLARED_CLASSES:
-				getDeclaredClasses().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__DECLARING_CLASS:
-				setDeclaringClass((JavaClass)null);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__EVENTS:
-				getEvents().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ALL_EVENTS:
-				getAllEvents().clear();
-				return;
-			case JavaRefPackage.ARRAY_TYPE__ARRAY_DIMENSIONS:
-				setArrayDimensions(ARRAY_DIMENSIONS_EDEFAULT);
-				return;
-			case JavaRefPackage.ARRAY_TYPE__COMPONENT_TYPE:
-				setComponentType((EClassifier)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (arrayDimensions: ");
-		result.append(arrayDimensions);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public EClassifier getComponentTypeGen() {
-		if (componentType != null && componentType.eIsProxy()) {
-			EClassifier oldComponentType = componentType;
-			componentType = (EClassifier)eResolveProxy((InternalEObject)componentType);
-			if (componentType != oldComponentType) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, JavaRefPackage.ARRAY_TYPE__COMPONENT_TYPE, oldComponentType, componentType));
-			}
-		}
-		return componentType;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClassifier basicGetComponentType() {
-		return componentType;
-	}
-
-	public void setComponentType(EClassifier newComponentType) {
-		finalComponentType = null;
-		setComponentTypeGen(newComponentType);
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentTypeGen(EClassifier newComponentType) {
-		EClassifier oldComponentType = componentType;
-		componentType = newComponentType;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.ARRAY_TYPE__COMPONENT_TYPE, oldComponentType, componentType));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.ARRAY_TYPE__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__EPACKAGE:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.ARRAY_TYPE__EPACKAGE, msgs);
-				case JavaRefPackage.ARRAY_TYPE__EOPERATIONS:
-					return ((InternalEList)getEOperations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__ESTRUCTURAL_FEATURES:
-					return ((InternalEList)getEStructuralFeatures()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__FIELDS:
-					return ((InternalEList)getFields()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__METHODS:
-					return ((InternalEList)getMethods()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__INITIALIZERS:
-					return ((InternalEList)getInitializers()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__DECLARED_CLASSES:
-					return ((InternalEList)getDeclaredClasses()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__DECLARING_CLASS:
-					if (declaringClass != null)
-						msgs = ((InternalEObject)declaringClass).eInverseRemove(this, JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES, JavaClass.class, msgs);
-					return basicSetDeclaringClass((JavaClass)otherEnd, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.ARRAY_TYPE__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__EPACKAGE:
-					return eBasicSetContainer(null, JavaRefPackage.ARRAY_TYPE__EPACKAGE, msgs);
-				case JavaRefPackage.ARRAY_TYPE__EOPERATIONS:
-					return ((InternalEList)getEOperations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__ESTRUCTURAL_FEATURES:
-					return ((InternalEList)getEStructuralFeatures()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__FIELDS:
-					return ((InternalEList)getFields()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__METHODS:
-					return ((InternalEList)getMethods()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__INITIALIZERS:
-					return ((InternalEList)getInitializers()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__DECLARED_CLASSES:
-					return ((InternalEList)getDeclaredClasses()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.ARRAY_TYPE__DECLARING_CLASS:
-					return basicSetDeclaringClass(null, msgs);
-				case JavaRefPackage.ARRAY_TYPE__EVENTS:
-					return ((InternalEList)getEvents()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.ARRAY_TYPE__EPACKAGE:
-					return eContainer.eInverseRemove(this, EcorePackage.EPACKAGE__ECLASSIFIERS, EPackage.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.ARRAY_TYPE__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.ARRAY_TYPE__NAME:
-				return getName();
-			case JavaRefPackage.ARRAY_TYPE__INSTANCE_CLASS_NAME:
-				return getInstanceClassName();
-			case JavaRefPackage.ARRAY_TYPE__INSTANCE_CLASS:
-				return getInstanceClass();
-			case JavaRefPackage.ARRAY_TYPE__DEFAULT_VALUE:
-				return getDefaultValue();
-			case JavaRefPackage.ARRAY_TYPE__EPACKAGE:
-				return getEPackage();
-			case JavaRefPackage.ARRAY_TYPE__ABSTRACT:
-				return isAbstract() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.ARRAY_TYPE__INTERFACE:
-				return isInterface() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.ARRAY_TYPE__ESUPER_TYPES:
-				return getESuperTypes();
-			case JavaRefPackage.ARRAY_TYPE__EOPERATIONS:
-				return getEOperations();
-			case JavaRefPackage.ARRAY_TYPE__EALL_ATTRIBUTES:
-				return getEAllAttributes();
-			case JavaRefPackage.ARRAY_TYPE__EALL_REFERENCES:
-				return getEAllReferences();
-			case JavaRefPackage.ARRAY_TYPE__EREFERENCES:
-				return getEReferences();
-			case JavaRefPackage.ARRAY_TYPE__EATTRIBUTES:
-				return getEAttributes();
-			case JavaRefPackage.ARRAY_TYPE__EALL_CONTAINMENTS:
-				return getEAllContainments();
-			case JavaRefPackage.ARRAY_TYPE__EALL_OPERATIONS:
-				return getEAllOperations();
-			case JavaRefPackage.ARRAY_TYPE__EALL_STRUCTURAL_FEATURES:
-				return getEAllStructuralFeatures();
-			case JavaRefPackage.ARRAY_TYPE__EALL_SUPER_TYPES:
-				return getEAllSuperTypes();
-			case JavaRefPackage.ARRAY_TYPE__EID_ATTRIBUTE:
-				return getEIDAttribute();
-			case JavaRefPackage.ARRAY_TYPE__ESTRUCTURAL_FEATURES:
-				return getEStructuralFeatures();
-			case JavaRefPackage.ARRAY_TYPE__KIND:
-				return getKind();
-			case JavaRefPackage.ARRAY_TYPE__PUBLIC:
-				return isPublic() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.ARRAY_TYPE__FINAL:
-				return isFinal() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.ARRAY_TYPE__IMPLEMENTS_INTERFACES:
-				return getImplementsInterfaces();
-			case JavaRefPackage.ARRAY_TYPE__CLASS_IMPORT:
-				return getClassImport();
-			case JavaRefPackage.ARRAY_TYPE__PACKAGE_IMPORTS:
-				return getPackageImports();
-			case JavaRefPackage.ARRAY_TYPE__FIELDS:
-				return getFields();
-			case JavaRefPackage.ARRAY_TYPE__METHODS:
-				return getMethods();
-			case JavaRefPackage.ARRAY_TYPE__INITIALIZERS:
-				return getInitializers();
-			case JavaRefPackage.ARRAY_TYPE__DECLARED_CLASSES:
-				return getDeclaredClasses();
-			case JavaRefPackage.ARRAY_TYPE__DECLARING_CLASS:
-				if (resolve) return getDeclaringClass();
-				return basicGetDeclaringClass();
-			case JavaRefPackage.ARRAY_TYPE__JAVA_PACKAGE:
-				if (resolve) return getJavaPackage();
-				return basicGetJavaPackage();
-			case JavaRefPackage.ARRAY_TYPE__EVENTS:
-				return getEvents();
-			case JavaRefPackage.ARRAY_TYPE__ALL_EVENTS:
-				return getAllEvents();
-			case JavaRefPackage.ARRAY_TYPE__ARRAY_DIMENSIONS:
-				return new Integer(getArrayDimensions());
-			case JavaRefPackage.ARRAY_TYPE__COMPONENT_TYPE:
-				if (resolve) return getComponentType();
-				return basicGetComponentType();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaClass#getKind()
-	 */
-	public TypeKind getKind() {
-		// Override to always return the class if final type is valid.
-		JavaHelpers ft = getFinalComponentType();
-		if (!ft.isPrimitive()) {
-			TypeKind ftKind = ((JavaClass) ft).getKind(); 
-			return  ftKind != TypeKind.UNDEFINED_LITERAL ? TypeKind.CLASS_LITERAL : TypeKind.UNDEFINED_LITERAL;
-		} else
-			return TypeKind.CLASS_LITERAL;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaClass#isPublic()
-	 */
-	public boolean isPublic() {
-		// Override to return the kind of the final component, because that determines it.
-		JavaHelpers ft = getFinalComponentType();
-		if (!ft.isPrimitive()) {
-			return ((JavaClass) ft).isPublic();
-		} else
-			return true;
-	}
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/BlockImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/BlockImpl.java
deleted file mode 100644
index 6eff12e..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/BlockImpl.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-
-/*
- *  $RCSfile: BlockImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.Block;
-import org.eclipse.jem.java.JavaRefPackage;
-
-/**
- * @generated
- */
-public class BlockImpl extends EObjectImpl implements Block{
-
-	/**
-	 * The default value of the '{@link #getSource() <em>Source</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSource()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String SOURCE_EDEFAULT = null;
-
-	
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected String source = SOURCE_EDEFAULT;
-	/**
-	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String NAME_EDEFAULT = null;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected String name = NAME_EDEFAULT;
-	/**
-	 * The cached value of the '{@link #getContents() <em>Contents</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getContents()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList contents = null;
-
-	protected BlockImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getBlock();
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public String getSource() {
-		return source;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void setSource(String newSource) {
-		String oldSource = source;
-		source = newSource;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.BLOCK__SOURCE, oldSource, source));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public String getName() {
-		return name;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void setName(String newName) {
-		String oldName = name;
-		name = newName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.BLOCK__NAME, oldName, name));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public EList getContents() {
-		if (contents == null) {
-			contents = new EObjectContainmentEList(Block.class, this, JavaRefPackage.BLOCK__CONTENTS);
-		}
-		return contents;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.BLOCK__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.BLOCK__SOURCE:
-				return getSource();
-			case JavaRefPackage.BLOCK__NAME:
-				return getName();
-			case JavaRefPackage.BLOCK__CONTENTS:
-				return getContents();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.BLOCK__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case JavaRefPackage.BLOCK__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.BLOCK__CONTENTS:
-				return contents != null && !contents.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.BLOCK__SOURCE:
-				setSource((String)newValue);
-				return;
-			case JavaRefPackage.BLOCK__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.BLOCK__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.BLOCK__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case JavaRefPackage.BLOCK__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.BLOCK__CONTENTS:
-				getContents().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (source: ");
-		result.append(source);
-		result.append(", name: ");
-		result.append(name);
-		result.append(')');
-		return result.toString();
-	}
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/CommentImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/CommentImpl.java
deleted file mode 100644
index cd18ea3..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/CommentImpl.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-
-/*
- *  $RCSfile: CommentImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.Comment;
-import org.eclipse.jem.java.JavaRefPackage;
-/**
- * @generated
- */
-public class CommentImpl extends BlockImpl implements Comment{
-
-	
-	protected CommentImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getComment();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.COMMENT__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.COMMENT__SOURCE:
-				return getSource();
-			case JavaRefPackage.COMMENT__NAME:
-				return getName();
-			case JavaRefPackage.COMMENT__CONTENTS:
-				return getContents();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.COMMENT__SOURCE:
-				setSource((String)newValue);
-				return;
-			case JavaRefPackage.COMMENT__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.COMMENT__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.COMMENT__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case JavaRefPackage.COMMENT__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.COMMENT__CONTENTS:
-				getContents().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.COMMENT__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case JavaRefPackage.COMMENT__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.COMMENT__CONTENTS:
-				return contents != null && !contents.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/FieldImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/FieldImpl.java
deleted file mode 100644
index a9a7b49..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/FieldImpl.java
+++ /dev/null
@@ -1,739 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: FieldImpl.java,v $
- *  $Revision: 1.2 $  $Date: 2005/09/15 20:28:03 $ 
- */
-package org.eclipse.jem.java.internal.impl;
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.BasicEList;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.ETypedElementImpl;
-
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.Block;
-import org.eclipse.jem.java.Field;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaHelpers;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.JavaURL;
-import org.eclipse.jem.java.JavaVisibilityKind;
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-
-/**
- * @generated
- */
-public class FieldImpl extends ETypedElementImpl implements Field {
-
-	/**
-	 * The default value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean FINAL_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int FINAL_EFLAG = 1 << 10;
-
-	/**
-	 * The default value of the '{@link #isStatic() <em>Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isStatic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean STATIC_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isStatic() <em>Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isStatic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int STATIC_EFLAG = 1 << 11;
-
-	/**
-	 * The default value of the '{@link #getJavaVisibility() <em>Java Visibility</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getJavaVisibility()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final JavaVisibilityKind JAVA_VISIBILITY_EDEFAULT = JavaVisibilityKind.PUBLIC_LITERAL;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected JavaVisibilityKind javaVisibility = JAVA_VISIBILITY_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #isTransient() <em>Transient</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isTransient()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean TRANSIENT_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isTransient() <em>Transient</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isTransient()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int TRANSIENT_EFLAG = 1 << 12;
-
-	/**
-	 * The default value of the '{@link #isVolatile() <em>Volatile</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isVolatile()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean VOLATILE_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isVolatile() <em>Volatile</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isVolatile()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int VOLATILE_EFLAG = 1 << 13;
-
-	/**
-	 * The cached value of the '{@link #getInitializer() <em>Initializer</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInitializer()
-	 * @generated
-	 * @ordered
-	 */
-	protected Block initializer = null;
-
-	protected FieldImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getField();
-	}
-
-	/**
-	 * createFieldRef - return a JavaURL reference to the named field in the named Java class in the form "package.class_field"
-	 */
-	public static Field createFieldRef(String className, String fieldName) {
-		Field ref = JavaRefFactoryImpl.getActiveFactory().createField();
-		JavaURL javaurl = new JavaURL(className + "/" + fieldName);
-		((InternalEObject) ref).eSetProxyURI(URI.createURI(javaurl.getFullString()));
-		return ref;
-	}
-
-	/**
-	 * Get the class that this field is within.
-	 */
-	public JavaClass getContainingJavaClass() {
-		return this.getJavaClass();
-	}
-
-	/**
-	 * Overrides to perform lazy initializations/reflection.
-	 */
-	public EClassifier getEType() {
-		reflectValues();
-		return super.getEType();
-	}
-
-	public Block getInitializer() {
-		reflectValues();
-		return getInitializerGen();
-	}
-
-	public boolean isFinal() {
-		reflectValues();
-		return isFinalGen();
-	}
-
-	public boolean isStatic() {
-		reflectValues();
-		return isStaticGen();
-	}
-
-	public boolean isTransient() {
-		reflectValues();
-		return isTransientGen();
-	}
-	
-	public boolean isVolatile() {
-		reflectValues();
-		return isVolatileGen();
-	}	
-
-	public JavaHelpers getJavaType() {
-		return (JavaHelpers) getEType();
-	}
-
-	public JavaVisibilityKind getJavaVisibility() {
-		reflectValues();
-		return getJavaVisibilityGen();
-	}
-
-	protected synchronized ReadAdaptor getReadAdapter() {
-		return (ReadAdaptor) EcoreUtil.getRegisteredAdapter(this, ReadAdaptor.TYPE_KEY);
-	}
-
-	protected boolean hasReflected = false;
-
-	protected void reflectValues() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if (!hasReflected) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = readAdaptor.reflectValuesIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				if (setReflected)
-					hasReflected = setReflected;
-			}
-		}
-	}
-
-	/*
-	 * Used by reflection adapter to clear the reflection. This not intended to be used by others.
-	 */
-	public synchronized void setReflected(boolean reflected) {
-		hasReflected = reflected;
-	}
-
-	/**
-	 * Is this field an array type.
-	 */
-	public boolean isArray() {
-		return getJavaType().isArray();
-	}
-
-	/**
-	 * Overridden to prevent the reflection of the class.
-	 */
-	public EList eContents() {
-		EList results = new BasicEList();
-		//FB
-		//FB EList containments = eClass().getEAllContainments();
-		//FB if (containments != null) {
-		//FB Iterator i = containments.iterator();
-		//FB while (i.hasNext()) {
-		//FB EStructuralFeature sf = (EStructuralFeature) i.next();
-		//FB //Change from super to primRefValue
-		//FB Object value = primRefValue(sf);
-		//FB //EndChange
-		//FB if (value != null)
-		//FB if (sf.isMany())
-		//FB results.addAll((Collection) value);
-		//FB else
-		//FB results.add(value);
-		//FB }
-		//FB }
-		if (getInitializerGen() != null)
-			results.add(getInitializerGen()); //FB
-		return results;
-	}
-
-	public String toString() {
-		return getClass().getName() + " " + "(" + getName() + ")";
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaVisibilityKind getJavaVisibilityGen() {
-		return javaVisibility;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public boolean isFinalGen() {
-		return (eFlags & FINAL_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFinal(boolean newFinal) {
-		boolean oldFinal = (eFlags & FINAL_EFLAG) != 0;
-		if (newFinal) eFlags |= FINAL_EFLAG; else eFlags &= ~FINAL_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__FINAL, oldFinal, newFinal));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public boolean isStaticGen() {
-		return (eFlags & STATIC_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setStatic(boolean newStatic) {
-		boolean oldStatic = (eFlags & STATIC_EFLAG) != 0;
-		if (newStatic) eFlags |= STATIC_EFLAG; else eFlags &= ~STATIC_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__STATIC, oldStatic, newStatic));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setJavaVisibility(JavaVisibilityKind newJavaVisibility) {
-		JavaVisibilityKind oldJavaVisibility = javaVisibility;
-		javaVisibility = newJavaVisibility == null ? JAVA_VISIBILITY_EDEFAULT : newJavaVisibility;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__JAVA_VISIBILITY, oldJavaVisibility, javaVisibility));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isTransientGen() {
-		return (eFlags & TRANSIENT_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTransient(boolean newTransient) {
-		boolean oldTransient = (eFlags & TRANSIENT_EFLAG) != 0;
-		if (newTransient) eFlags |= TRANSIENT_EFLAG; else eFlags &= ~TRANSIENT_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__TRANSIENT, oldTransient, newTransient));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isVolatileGen() {
-		return (eFlags & VOLATILE_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setVolatile(boolean newVolatile) {
-		boolean oldVolatile = (eFlags & VOLATILE_EFLAG) != 0;
-		if (newVolatile) eFlags |= VOLATILE_EFLAG; else eFlags &= ~VOLATILE_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__VOLATILE, oldVolatile, newVolatile));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public JavaClass getJavaClass() {
-		if (eContainerFeatureID != JavaRefPackage.FIELD__JAVA_CLASS) return null;
-		return (JavaClass)eContainer;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setJavaClass(JavaClass newJavaClass) {
-		if (newJavaClass != eContainer || (eContainerFeatureID != JavaRefPackage.FIELD__JAVA_CLASS && newJavaClass != null)) {
-			if (EcoreUtil.isAncestor(this, newJavaClass))
-				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
-			NotificationChain msgs = null;
-			if (eContainer != null)
-				msgs = eBasicRemoveFromContainer(msgs);
-			if (newJavaClass != null)
-				msgs = ((InternalEObject)newJavaClass).eInverseAdd(this, JavaRefPackage.JAVA_CLASS__FIELDS, JavaClass.class, msgs);
-			msgs = eBasicSetContainer((InternalEObject)newJavaClass, JavaRefPackage.FIELD__JAVA_CLASS, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__JAVA_CLASS, newJavaClass, newJavaClass));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.FIELD__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.FIELD__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.FIELD__ORDERED:
-				return ((eFlags & ORDERED_EFLAG) != 0) != ORDERED_EDEFAULT;
-			case JavaRefPackage.FIELD__UNIQUE:
-				return ((eFlags & UNIQUE_EFLAG) != 0) != UNIQUE_EDEFAULT;
-			case JavaRefPackage.FIELD__LOWER_BOUND:
-				return lowerBound != LOWER_BOUND_EDEFAULT;
-			case JavaRefPackage.FIELD__UPPER_BOUND:
-				return upperBound != UPPER_BOUND_EDEFAULT;
-			case JavaRefPackage.FIELD__MANY:
-				return isMany() != MANY_EDEFAULT;
-			case JavaRefPackage.FIELD__REQUIRED:
-				return isRequired() != REQUIRED_EDEFAULT;
-			case JavaRefPackage.FIELD__ETYPE:
-				return eType != null;
-			case JavaRefPackage.FIELD__FINAL:
-				return ((eFlags & FINAL_EFLAG) != 0) != FINAL_EDEFAULT;
-			case JavaRefPackage.FIELD__STATIC:
-				return ((eFlags & STATIC_EFLAG) != 0) != STATIC_EDEFAULT;
-			case JavaRefPackage.FIELD__JAVA_VISIBILITY:
-				return javaVisibility != JAVA_VISIBILITY_EDEFAULT;
-			case JavaRefPackage.FIELD__TRANSIENT:
-				return ((eFlags & TRANSIENT_EFLAG) != 0) != TRANSIENT_EDEFAULT;
-			case JavaRefPackage.FIELD__VOLATILE:
-				return ((eFlags & VOLATILE_EFLAG) != 0) != VOLATILE_EDEFAULT;
-			case JavaRefPackage.FIELD__JAVA_CLASS:
-				return getJavaClass() != null;
-			case JavaRefPackage.FIELD__INITIALIZER:
-				return initializer != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.FIELD__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.FIELD__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.FIELD__ORDERED:
-				setOrdered(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.FIELD__UNIQUE:
-				setUnique(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.FIELD__LOWER_BOUND:
-				setLowerBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.FIELD__UPPER_BOUND:
-				setUpperBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.FIELD__ETYPE:
-				setEType((EClassifier)newValue);
-				return;
-			case JavaRefPackage.FIELD__FINAL:
-				setFinal(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.FIELD__STATIC:
-				setStatic(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.FIELD__JAVA_VISIBILITY:
-				setJavaVisibility((JavaVisibilityKind)newValue);
-				return;
-			case JavaRefPackage.FIELD__TRANSIENT:
-				setTransient(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.FIELD__VOLATILE:
-				setVolatile(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.FIELD__JAVA_CLASS:
-				setJavaClass((JavaClass)newValue);
-				return;
-			case JavaRefPackage.FIELD__INITIALIZER:
-				setInitializer((Block)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.FIELD__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.FIELD__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__ORDERED:
-				setOrdered(ORDERED_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__UNIQUE:
-				setUnique(UNIQUE_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__LOWER_BOUND:
-				setLowerBound(LOWER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__UPPER_BOUND:
-				setUpperBound(UPPER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__ETYPE:
-				setEType((EClassifier)null);
-				return;
-			case JavaRefPackage.FIELD__FINAL:
-				setFinal(FINAL_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__STATIC:
-				setStatic(STATIC_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__JAVA_VISIBILITY:
-				setJavaVisibility(JAVA_VISIBILITY_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__TRANSIENT:
-				setTransient(TRANSIENT_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__VOLATILE:
-				setVolatile(VOLATILE_EDEFAULT);
-				return;
-			case JavaRefPackage.FIELD__JAVA_CLASS:
-				setJavaClass((JavaClass)null);
-				return;
-			case JavaRefPackage.FIELD__INITIALIZER:
-				setInitializer((Block)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public Block getInitializerGen() {
-		return initializer;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetInitializer(Block newInitializer, NotificationChain msgs) {
-		Block oldInitializer = initializer;
-		initializer = newInitializer;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__INITIALIZER, oldInitializer, newInitializer);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setInitializer(Block newInitializer) {
-		if (newInitializer != initializer) {
-			NotificationChain msgs = null;
-			if (initializer != null)
-				msgs = ((InternalEObject)initializer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - JavaRefPackage.FIELD__INITIALIZER, null, msgs);
-			if (newInitializer != null)
-				msgs = ((InternalEObject)newInitializer).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - JavaRefPackage.FIELD__INITIALIZER, null, msgs);
-			msgs = basicSetInitializer(newInitializer, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.FIELD__INITIALIZER, newInitializer, newInitializer));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.FIELD__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.FIELD__JAVA_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.FIELD__JAVA_CLASS, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.FIELD__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.FIELD__JAVA_CLASS:
-					return eBasicSetContainer(null, JavaRefPackage.FIELD__JAVA_CLASS, msgs);
-				case JavaRefPackage.FIELD__INITIALIZER:
-					return basicSetInitializer(null, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.FIELD__JAVA_CLASS:
-					return eContainer.eInverseRemove(this, JavaRefPackage.JAVA_CLASS__FIELDS, JavaClass.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.FIELD__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.FIELD__NAME:
-				return getName();
-			case JavaRefPackage.FIELD__ORDERED:
-				return isOrdered() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__UNIQUE:
-				return isUnique() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__LOWER_BOUND:
-				return new Integer(getLowerBound());
-			case JavaRefPackage.FIELD__UPPER_BOUND:
-				return new Integer(getUpperBound());
-			case JavaRefPackage.FIELD__MANY:
-				return isMany() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__REQUIRED:
-				return isRequired() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__ETYPE:
-				if (resolve) return getEType();
-				return basicGetEType();
-			case JavaRefPackage.FIELD__FINAL:
-				return isFinal() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__STATIC:
-				return isStatic() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__JAVA_VISIBILITY:
-				return getJavaVisibility();
-			case JavaRefPackage.FIELD__TRANSIENT:
-				return isTransient() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__VOLATILE:
-				return isVolatile() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.FIELD__JAVA_CLASS:
-				return getJavaClass();
-			case JavaRefPackage.FIELD__INITIALIZER:
-				return getInitializer();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toStringGen() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (final: ");
-		result.append((eFlags & FINAL_EFLAG) != 0);
-		result.append(", static: ");
-		result.append((eFlags & STATIC_EFLAG) != 0);
-		result.append(", javaVisibility: ");
-		result.append(javaVisibility);
-		result.append(", transient: ");
-		result.append((eFlags & TRANSIENT_EFLAG) != 0);
-		result.append(", volatile: ");
-		result.append((eFlags & VOLATILE_EFLAG) != 0);
-		result.append(')');
-		return result.toString();
-	}
-
-}
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/InitializerImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/InitializerImpl.java
deleted file mode 100644
index a72550b..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/InitializerImpl.java
+++ /dev/null
@@ -1,297 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: InitializerImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.java.Block;
-import org.eclipse.jem.java.Initializer;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaRefPackage;
-/**
- * @generated
- */
-public class InitializerImpl extends EObjectImpl implements Initializer{
-
-	/**
-	 * The default value of the '{@link #getIsStatic() <em>Is Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIsStatic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final Boolean IS_STATIC_EDEFAULT = null;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected Boolean isStatic = IS_STATIC_EDEFAULT;
-	/**
-	 * The cached value of the '{@link #getSource() <em>Source</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSource()
-	 * @generated
-	 * @ordered
-	 */
-	protected Block source = null;
-
-	protected InitializerImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getInitializer();
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public Boolean getIsStatic() {
-		return isStatic;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void setIsStatic(Boolean newIsStatic) {
-		Boolean oldIsStatic = isStatic;
-		isStatic = newIsStatic;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.INITIALIZER__IS_STATIC, oldIsStatic, isStatic));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public JavaClass getJavaClass() {
-		if (eContainerFeatureID != JavaRefPackage.INITIALIZER__JAVA_CLASS) return null;
-		return (JavaClass)eContainer;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setJavaClass(JavaClass newJavaClass) {
-		if (newJavaClass != eContainer || (eContainerFeatureID != JavaRefPackage.INITIALIZER__JAVA_CLASS && newJavaClass != null)) {
-			if (EcoreUtil.isAncestor(this, newJavaClass))
-				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
-			NotificationChain msgs = null;
-			if (eContainer != null)
-				msgs = eBasicRemoveFromContainer(msgs);
-			if (newJavaClass != null)
-				msgs = ((InternalEObject)newJavaClass).eInverseAdd(this, JavaRefPackage.JAVA_CLASS__INITIALIZERS, JavaClass.class, msgs);
-			msgs = eBasicSetContainer((InternalEObject)newJavaClass, JavaRefPackage.INITIALIZER__JAVA_CLASS, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.INITIALIZER__JAVA_CLASS, newJavaClass, newJavaClass));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public Block getSource() {
-		if (source != null && source.eIsProxy()) {
-			Block oldSource = source;
-			source = (Block)eResolveProxy((InternalEObject)source);
-			if (source != oldSource) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, JavaRefPackage.INITIALIZER__SOURCE, oldSource, source));
-			}
-		}
-		return source;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Block basicGetSource() {
-		return source;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSource(Block newSource) {
-		Block oldSource = source;
-		source = newSource;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.INITIALIZER__SOURCE, oldSource, source));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.INITIALIZER__JAVA_CLASS, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-					return eBasicSetContainer(null, JavaRefPackage.INITIALIZER__JAVA_CLASS, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-					return eContainer.eInverseRemove(this, JavaRefPackage.JAVA_CLASS__INITIALIZERS, JavaClass.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.INITIALIZER__IS_STATIC:
-				return getIsStatic();
-			case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-				return getJavaClass();
-			case JavaRefPackage.INITIALIZER__SOURCE:
-				if (resolve) return getSource();
-				return basicGetSource();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.INITIALIZER__IS_STATIC:
-				return IS_STATIC_EDEFAULT == null ? isStatic != null : !IS_STATIC_EDEFAULT.equals(isStatic);
-			case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-				return getJavaClass() != null;
-			case JavaRefPackage.INITIALIZER__SOURCE:
-				return source != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.INITIALIZER__IS_STATIC:
-				setIsStatic((Boolean)newValue);
-				return;
-			case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-				setJavaClass((JavaClass)newValue);
-				return;
-			case JavaRefPackage.INITIALIZER__SOURCE:
-				setSource((Block)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.INITIALIZER__IS_STATIC:
-				setIsStatic(IS_STATIC_EDEFAULT);
-				return;
-			case JavaRefPackage.INITIALIZER__JAVA_CLASS:
-				setJavaClass((JavaClass)null);
-				return;
-			case JavaRefPackage.INITIALIZER__SOURCE:
-				setSource((Block)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (isStatic: ");
-		result.append(isStatic);
-		result.append(')');
-		return result.toString();
-	}
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaClassImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaClassImpl.java
deleted file mode 100644
index 1065f97..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaClassImpl.java
+++ /dev/null
@@ -1,1959 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: JavaClassImpl.java,v $
- *  $Revision: 1.2 $  $Date: 2005/09/15 20:28:03 $ 
- */
-package org.eclipse.jem.java.internal.impl;
-
-import java.util.Collection;
-import java.util.List;
-
-import java.util.*;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.ECollections;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.EClassImpl;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.Field;
-import org.eclipse.jem.java.Initializer;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaEvent;
-import org.eclipse.jem.java.JavaPackage;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.Method;
-import org.eclipse.jem.java.TypeKind;
-
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.*;
-
-import org.eclipse.jem.internal.java.adapters.*;
-import org.eclipse.jem.internal.java.beaninfo.IIntrospectionAdapter;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationInstance;
-import org.eclipse.jem.java.*;
-
-/**
- * <!-- begin-user-doc -->
- * 
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getKind <em>Kind</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#isPublic <em>Public</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#isFinal <em>Final</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getImplementsInterfaces <em>Implements Interfaces</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getClassImport <em>Class Import</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getPackageImports <em>Package Imports</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getFields <em>Fields</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getMethods <em>Methods</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getInitializers <em>Initializers</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getDeclaredClasses <em>Declared Classes</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getDeclaringClass <em>Declaring Class</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getJavaPackage <em>Java Package</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getEvents <em>Events</em>}</li>
- *   <li>{@link org.eclipse.jem.java.internal.impl.JavaClassImpl#getAllEvents <em>All Events</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class JavaClassImpl extends EClassImpl implements JavaClass {
-
-	/**
-	 * The default value of the '{@link #getKind() <em>Kind</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getKind()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final TypeKind KIND_EDEFAULT = TypeKind.UNDEFINED_LITERAL;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected TypeKind kind = KIND_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #isPublic() <em>Public</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isPublic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean PUBLIC_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isPublic() <em>Public</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isPublic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int PUBLIC_EFLAG = 1 << 10;
-
-	/**
-	 * The default value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean FINAL_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int FINAL_EFLAG = 1 << 11;
-
-	/**
-	 * The cached value of the '{@link #getImplementsInterfaces() <em>Implements Interfaces</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getImplementsInterfaces()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList implementsInterfaces = null;
-
-	/**
-	 * The cached value of the '{@link #getClassImport() <em>Class Import</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getClassImport()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList classImport = null;
-
-	/**
-	 * The cached value of the '{@link #getPackageImports() <em>Package Imports</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPackageImports()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList packageImports = null;
-
-	/**
-	 * The cached value of the '{@link #getFields() <em>Fields</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFields()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList fields = null;
-
-	/**
-	 * The cached value of the '{@link #getMethods() <em>Methods</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMethods()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList methods = null;
-
-	/**
-	 * The cached value of the '{@link #getInitializers() <em>Initializers</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getInitializers()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList initializers = null;
-
-	/**
-	 * The cached value of the '{@link #getDeclaredClasses() <em>Declared Classes</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDeclaredClasses()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList declaredClasses = null;
-
-	/**
-	 * The cached value of the '{@link #getDeclaringClass() <em>Declaring Class</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDeclaringClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected JavaClass declaringClass = null;
-
-	/**
-	 * The cached value of the '{@link #getEvents() <em>Events</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getEvents()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList events = null;
-
-	protected JavaClassImpl() {
-		super();
-	}
-	
-	public EList getEAnnotationsInternal() {
-		return super.getEAnnotations();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getJavaClass();
-	}
-
-	/**
-	 * Protected helper methods.
-	 */
-	protected void collectFieldsExtended(List fields) {
-		fields.addAll(getFields());
-		Iterator it;
-		it = getExtendedLookupIterator();
-		while (it.hasNext())
-			((JavaClassImpl) it.next()).collectFieldsExtended(fields);
-	}
-
-	protected void collectMethodsExtended(Map methods, boolean onlyPublic, List excludedClasses, List excludedMethods) {
-		Iterator it1, it2;
-		it2 = getExtendedLookupIterator();
-		JavaClassImpl javaClass;
-		while (it2.hasNext()) {
-			javaClass = (JavaClassImpl) it2.next();
-			if (!excludedClasses.contains(javaClass))
-				javaClass.collectMethodsExtended(methods, onlyPublic, excludedClasses, excludedMethods);
-		}
-		it1 = onlyPublic ? getPublicMethods().iterator() : getMethods().iterator();
-		Method nextMethod;
-		while (it1.hasNext()) {
-			nextMethod = (Method) it1.next();
-			if (!excludedMethods.contains(nextMethod))
-				methods.put(nextMethod.getMethodElementSignature(), nextMethod);
-		}
-	}
-
-	/**
-	 * createClassRef - return a JavaURL reference to the named Java class
-	 * 
-	 * @deprecated @see org.eclipse.jem.java.JavaRefFactory#createClassRef(java.lang.String)
-	 */
-	public static JavaClass createClassRef(String targetName) {
-		return JavaRefFactory.eINSTANCE.createClassRef(targetName);
-	}
-
-	/**
-	 * Get the method of this name and these parameters. It will look up the supertype hierarchy.
-	 */
-	protected Method findClassMethodExtended(String methodName, List parameterTypes) {
-		Method method = getMethod(methodName, parameterTypes);
-		if (method != null)
-			return method;
-		else {
-			JavaClassImpl mySuper;
-			mySuper = (JavaClassImpl) getSupertype();
-			if (mySuper != null)
-				return mySuper.findClassMethodExtended(methodName, parameterTypes);
-		}
-		return null;
-	}
-
-	/**
-	 * Get the method of this name and these parameters. It will look up the supertype hierarchy.
-	 */
-	protected Method findInterfaceMethodExtended(String methodName, List parameterTypes) {
-		Method method = getMethod(methodName, parameterTypes);
-		if (method != null)
-			return method;
-		else {
-			JavaClassImpl superInterface;
-			List list = getImplementsInterfaces();
-			for (int i = 0; i < list.size(); i++) {
-				superInterface = (JavaClassImpl) list.get(i);
-				method = superInterface.findInterfaceMethodExtended(methodName, parameterTypes);
-				if (method != null)
-					return method;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * 
-	 * @return
-	 * @deprecated If anyone is referencing this, please use getEAllSuperTypes() instead. This was placed here and misspelled by mistake.
-	 */
-	public EList getAllSupertypes() {
-		getESuperTypes(); //Force reflection, if needed, before getting all supertypes.
-		return super.getEAllSuperTypes();
-	}
-
-	/**
-	 * Overrides to perform reflection if necessary
-	 */
-	public EList getClassImport() {
-		reflectBase();
-		return getClassImportGen();
-	}
-
-	public EList getEAllOperations() {
-		IIntrospectionAdapter ia = getIntrospectionAdapter();
-		if (ia == null)
-			return super.getEAllOperations(); // No introspection, do normal.
-		if (eAllOperations == null)
-			eAllOperations = ia.getEAllOperations();
-		return eAllOperations;
-	}
-	
-	/**
-	 * This is not meant to be used by others. It is here so that BeanInfo adapter can access
-	 * un-introspected all operations.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public EList primGetEAllOperations() {
-		return super.getEAllOperations();
-	}
-
-	public EList getEOperations() {
-		IIntrospectionAdapter adapter = getIntrospectionAdapter();
-		if (adapter != null)
-			return adapter.getEOperations();
-		return super.getEOperations();
-	}
-
-	/**
-	 * This method is not meant to be used by others. It is here so that BeanInfo adapters can go to
-	 * the non-introspected operations.
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public EList getEOperationsInternal() {
-		// An internal method for returning actual wo fluffing up.
-		return super.getEOperations();
-	}
-
-	public EList getEAnnotations() {
-		IIntrospectionAdapter adapter = getIntrospectionAdapter();
-		if (adapter != null)
-			adapter.introspectIfNecessary(); // To cause introspection so the appropriate decorator is added.
-		return super.getEAnnotations();
-	}
-
-	public EList getEStructuralFeatures() {
-		IIntrospectionAdapter adapter = getIntrospectionAdapter();
-		if (adapter != null)
-			return adapter.getEStructuralFeatures();
-		return super.getEStructuralFeatures();
-	}
-
-	public EList getEStructuralFeaturesInternal() {
-		// An internal method for returning actual wo fluffing up.
-		return super.getEStructuralFeatures();
-	}
-
-	/**
-	 * Return an Iterator on the implemntsInferface List if this is an interface class or on the super List if it is a class.
-	 */
-	protected Iterator getExtendedLookupIterator() {
-		if (isInterface())
-			return getImplementsInterfaces().iterator();
-		else
-			return getESuperTypes().iterator();
-	}
-
-	/**
-	 * Return an Field with the passed name, or null.
-	 */
-	public Field getField(String fieldName) {
-		java.util.List fields = getFields();
-		Field field;
-		for (int i = 0; i < fields.size(); i++) {
-			field = (Field) fields.get(i);
-			if (field.getName().equals(fieldName))
-				return field;
-		}
-		return null;
-	}
-
-	/**
-	 * Return an Field with the passed name from this JavaClass or any supertypes.
-	 * 
-	 * Return null if a Field named fieldName is not found.
-	 */
-	public Field getFieldExtended(String fieldName) {
-		Field field = getFieldNamed(fieldName);
-		if (field != null)
-			return field;
-		Iterator it = getExtendedLookupIterator();
-		while (it.hasNext()) {
-			Field result = ((JavaClass) it.next()).getFieldExtended(fieldName);
-			if (result != null)
-				return result;
-		}
-		return null;
-	}
-
-	/**
-	 * Return an Field with the passed name, or null.
-	 */
-	public Field getFieldNamed(String fieldName) {
-		return getField(fieldName);
-	}
-
-	public EList getFields() {
-		reflectFields();
-		return getFieldsGen();
-	}
-
-	/**
-	 * Return all fields, including those from supertypes.
-	 */
-	public List getFieldsExtended() {
-		List fields = new ArrayList();
-		collectFieldsExtended(fields);
-		return fields;
-	}
-
-	public EList getImplementsInterfaces() {
-		reflectBase();
-		return getImplementsInterfacesGen();
-	}
-
-	/**
-	 * Return an IntrospectionAdaptor which can introspect our Java properties
-	 */
-	protected synchronized IIntrospectionAdapter getIntrospectionAdapter() {
-		// Need to sync this because we are now in multi-thread env.
-		return (IIntrospectionAdapter) EcoreUtil.getRegisteredAdapter(this, IIntrospectionAdapter.ADAPTER_KEY);
-	}
-
-	public String getJavaName() {
-		return getQualifiedName();
-	}
-
-	/*
-	 *  (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaHelpers#getSimpleName()
-	 */
-	public String getSimpleName() {
-		return primGetName().replace('$', '.');
-	}
-	/**
-	 * getJavaPackage. This is a derived relationship, so we must implement it here to get the EPackage that this object is contained in.
-	 */
-	public JavaPackage getJavaPackage() {
-		return (JavaPackage) getEPackage();
-	}
-
-	/**
-	 * Get the method of this name and these parameters. It will not look up the supertype hierarchy.
-	 */
-	public Method getMethod(String methodName, List parameterTypes) {
-		return getMethod(methodName, parameterTypes, getMethods());
-	}
-
-	protected Method getMethod(String name, List parameterTypes, List methodList) {
-		boolean found = false;
-		Method method;
-		for (int i = 0; i < methodList.size(); i++) {
-			method = (Method) methodList.get(i);
-			JavaParameter[] params;
-			if (method.getName().equals(name)) {
-				params = method.listParametersWithoutReturn();
-				if (params.length == parameterTypes.size()) {
-					found = true; //Maybe; we need more info
-					for (int j = 0; j < params.length; j++) {
-						//if any one of the parameters doesn't match then flip back to false
-						JavaHelpers jh = (JavaHelpers) params[j].getEType();
-						if (!jh.getQualifiedName().equals(parameterTypes.get(j))) {
-							found = false;
-							break;
-						} // end if params equal
-					} // end compare all params
-					if (found) //short circuit out of this loop and return the winner
-						return method;
-				} // end compare lengths
-			} // end compare names
-		} // end loop through all methodList
-		return null;
-	}
-
-	/**
-	 * Return a List of Strings that represent MethodElement signatures from most general to most specific.
-	 */
-	public List getMethodElementSignatures() {
-		List methods, signatures, sameNames;
-		methods = getMethodsExtended();
-		sameNames = new ArrayList();
-		signatures = new ArrayList(methods.size() + 1);
-		signatures.add(DEFAULT_METHOD_NAME);
-		Iterator it = methods.iterator();
-		Method aMethod;
-		String methodName;
-		while (it.hasNext()) {
-			aMethod = (Method) it.next();
-			methodName = aMethod.getName();
-			if (sameNames.contains(methodName)) {
-				if (!signatures.contains(methodName))
-					signatures.add(methodName);
-			} else
-				sameNames.add(methodName);
-			signatures.add(aMethod.getMethodElementSignature());
-		}
-		Collections.sort(signatures);
-		return signatures;
-	}
-
-	/**
-	 * Get the method of this name and these parameters. It will look up the supertype hierarchy.
-	 */
-	public Method getMethodExtended(String methodName, List parameterTypes) {
-		if (isInterface())
-			return findInterfaceMethodExtended(methodName, parameterTypes);
-		else
-			return findClassMethodExtended(methodName, parameterTypes);
-	}
-
-	public EList getMethods() {
-		reflectMethods();
-		return getMethodsGen();
-	}
-
-	/**
-	 * Return all methods, including those from supertypes.
-	 */
-	public List getMethodsExtended() {
-		Map methods = new HashMap();
-		collectMethodsExtended(methods, false, Collections.EMPTY_LIST, Collections.EMPTY_LIST);
-		return new ArrayList(methods.values());
-	}
-
-	/*
-	 * @see getMethodsExtendedWithFilters(List, List) on JavaClass.
-	 */
-	public List getMethodsExtendedWithFilters(List excludedClasses, List excludedMethods) {
-		Map methods = new HashMap();
-		collectMethodsExtended(methods, false, excludedClasses, excludedMethods);
-		return new ArrayList(methods.values());
-	}
-
-	public String getName() {
-		String result = this.primGetName();
-		if (result == null && eIsProxy()) {
-			JavaURL url = new JavaURL(eProxyURI().toString());
-			result = url.getClassName();
-		}
-		return result;
-	}
-
-	/**
-	 * Return a List of Methods that begins with @aMethodNamePrefix and is not included in the @excludedNames list. If @aMethodNamePrefix is null, all methods will be returned.
-	 
-	 */
-	public List getOnlySpecificMethods(String aMethodNamePrefix, List excludedNames) {
-		List methods, specific;
-		methods = getMethodsExtended();
-		specific = new ArrayList(methods.size());
-		Iterator it = methods.iterator();
-		Method aMethod;
-		String methodName;
-		while (it.hasNext()) {
-			aMethod = (Method) it.next();
-			methodName = aMethod.getName();
-			if (aMethodNamePrefix != null && methodName.startsWith(aMethodNamePrefix) && excludedNames != null && !excludedNames.contains(methodName))
-				specific.add(aMethod);
-		}
-		return specific;
-	}
-
-	public EList getPackageImports() {
-		reflectBase();
-		return getPackageImportsGen();
-	}
-
-	/**
-	 * getPrimitive method comment.
-	 */
-	public JavaDataType getPrimitive() {
-		String primitiveName = getPrimitiveName();
-		if (primitiveName != null) {
-			Resource res = eResource();
-			return (JavaDataType) JavaClassImpl.reflect(primitiveName, res.getResourceSet());
-		}
-		return null;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaHelpers#getPrimitiveID()
-	 */
-	public int getPrimitiveID() {
-		String myName = getQualifiedName();
-		if (myName.equals(INTEGER_NAME))
-			return PRIM_INTEGER_ID;
-		if (myName.equals(BOOLEAN_NAME))
-			return PRIM_BOOLEAN_ID;
-		if (myName.equals(BYTE_NAME))
-			return PRIM_BYTE_ID;
-		if (myName.equals(SHORT_NAME))
-			return PRIM_SHORT_ID;
-		if (myName.equals(LONG_NAME))
-			return PRIM_LONG_ID;
-		if (myName.equals(FLOAT_NAME))
-			return PRIM_FLOAT_ID;
-		if (myName.equals(DOUBLE_NAME))
-			return PRIM_DOUBLE_ID;
-		if (myName.equals(CHARACTER_NAME))
-			return PRIM_CHARACTER_ID;
-		return PRIM_NOT_ID;
-	}
-
-	/**
-	 * Return the primitive name for this type if one exists.
-	 */
-	protected String getPrimitiveName() {
-		String myName = getQualifiedName();
-		if (myName.equals(INTEGER_NAME))
-			return PRIM_INTEGER_NAME;
-		if (myName.equals(BOOLEAN_NAME))
-			return PRIM_BOOLEAN_NAME;
-		if (myName.equals(BYTE_NAME))
-			return PRIM_BYTE_NAME;
-		if (myName.equals(SHORT_NAME))
-			return PRIM_SHORT_NAME;
-		if (myName.equals(LONG_NAME))
-			return PRIM_LONG_NAME;
-		if (myName.equals(FLOAT_NAME))
-			return PRIM_FLOAT_NAME;
-		if (myName.equals(DOUBLE_NAME))
-			return PRIM_DOUBLE_NAME;
-		if (myName.equals(CHARACTER_NAME))
-			return PRIM_CHARACTER_NAME;
-		return null;
-	}
-
-	/**
-	 * Return a method matching the name, and non-return parameters with fully qualified types matching all the types in the list, if it exists. It
-	 * will not look up the supertype hierarchy.
-	 */
-	public Method getPublicMethod(String methodName, List parameterTypes) {
-		return getMethod(methodName, parameterTypes, getPublicMethods());
-	}
-
-	/**
-	 * Return a method matching the name, and non-return parameters with fully qualified types matching all the types in the list, if it exists. It
-	 * will not look up the supertype hierarchy.
-	 */
-	public Method getPublicMethodExtended(String methodName, List parameterTypes) {
-		return getMethod(methodName, parameterTypes, getPublicMethodsExtended());
-	}
-
-	/**
-	 * Return all methods, it will not go up the supertype hierarchy.
-	 */
-	public List getPublicMethods() {
-		List publicMethods = new ArrayList();
-		List theMethods = getMethods();
-		for (int i = 0; i < theMethods.size(); i++) {
-			Method m = (Method) theMethods.get(i);
-			if (JavaVisibilityKind.PUBLIC_LITERAL == m.getJavaVisibility())
-				publicMethods.add(m);
-		}
-		return publicMethods;
-	}
-
-	/**
-	 * Return all public methods, including those from supertypes.
-	 */
-	public List getPublicMethodsExtended() {
-		Map methods = new HashMap();
-		collectMethodsExtended(methods, true, Collections.EMPTY_LIST, Collections.EMPTY_LIST);
-		return new ArrayList(methods.values());
-	}
-
-	/**
-	 * Returns a filtered list on the methods of this class, having a name equal to that of the parameter.
-	 */
-	public List getPublicMethodsExtendedNamed(String name) {
-		List publicMethods = new ArrayList();
-		List theMethods = getPublicMethodsExtended();
-		for (int i = 0; i < theMethods.size(); i++) {
-			Method m = (Method) theMethods.get(i);
-			if (m.getName().equals(name))
-				publicMethods.add(m);
-		}
-		return publicMethods;
-	}
-
-	/**
-	 * Returns a filtered list on the methods of this class, having a name equal to that of the parameter.
-	 */
-	public List getPublicMethodsNamed(String name) {
-		List publicMethods = new ArrayList();
-		List theMethods = getPublicMethods();
-		for (int i = 0; i < theMethods.size(); i++) {
-			Method m = (Method) theMethods.get(i);
-			if (m.getName().equals(name))
-				publicMethods.add(m);
-		}
-		return publicMethods;
-	}
-
-	public String getQualifiedName() {
-		String result = null;
-		if (eIsProxy()) {
-			JavaURL url = new JavaURL(eProxyURI().toString());
-			String internalName = url.getPackageName();
-			if (internalName != null && internalName.length() > 0)
-				result = internalName + "." + url.getClassName();
-			else
-				result = url.getClassName();
-		} else {
-			result = primGetQualifiedName();
-		}
-		if (result != null)
-			result = result.replace('$', '.');
-		return result;
-	}
-
-	/**
-	 * To be used by people that need to get the qualified name used for reflection. Typically bean info would need to use something like this.
-	 */
-	public String getQualifiedNameForReflection() {
-		return primGetQualifiedName();
-	}
-
-	/**
-	 * Return a ReadAdaptor which can reflect our Java properties
-	 */
-	protected synchronized ReadAdaptor getReadAdapter() {
-		// Need to sync because now in a multi-thread env.
-		return (ReadAdaptor) EcoreUtil.getRegisteredAdapter(this, ReadAdaptor.TYPE_KEY);
-	}
-
-	private static final int NOT_REFLECTED = 0x0, REFLECTED_BASE = 0x1, REFLECTED_METHODS = 0x2, REFLECTED_FIELDS = 0x4;
-
-	protected int reflectionStatus = NOT_REFLECTED;
-
-	protected void reflectBase() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if ((reflectionStatus & REFLECTED_BASE) == 0) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = readAdaptor.reflectValuesIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				if (setReflected)
-					reflectionStatus |= REFLECTED_BASE;
-			}
-		}
-	}
-
-	protected void reflectFields() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if ((reflectionStatus & REFLECTED_FIELDS) == 0) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = ((IJavaClassAdaptor) readAdaptor).reflectFieldsIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				if (setReflected)
-					reflectionStatus |= (REFLECTED_FIELDS | REFLECTED_BASE); // We can be certain base will be done by reflect fields if not already
-																			 // done.
-			}
-		}
-	}
-
-	protected void reflectMethods() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if ((reflectionStatus & REFLECTED_METHODS) == 0) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = ((IJavaClassAdaptor) readAdaptor).reflectMethodsIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				if (setReflected)
-					reflectionStatus |= (REFLECTED_METHODS | REFLECTED_BASE); // We can be certain base will be done by reflect fields if not already
-																			  // done.
-			}
-		}
-	}
-
-	public JavaClass getSupertype() {
-		// If this is an interface, there is no supertype. However, the eSuperTypes IS filled in with any interface that this extends. 
-		if (isInterface())
-			return null;
-		List list = getESuperTypes();
-		return (!list.isEmpty()) ? (JavaClass) list.get(0) : null;
-	}
-
-	public JavaClass getWrapper() {
-		return this;
-	}
-
-	/**
-	 * Test whether the receiver implements the passed interface (or one of its supertypes).
-	 */
-	public boolean implementsInterface(JavaClass interfaceType) {
-		if (this == interfaceType)
-			return true;
-		EList implemented = getImplementsInterfaces();
-		JavaClass anInterface;
-		for (int i = 0; i < implemented.size(); i++) {
-			anInterface = (JavaClass) implemented.get(i);
-			if (anInterface.implementsInterface(interfaceType))
-				return true;
-		}
-		if (getSupertype() != null)
-			return getSupertype().implementsInterface(interfaceType);
-		else
-			return false;
-	}
-
-	/**
-	 * Return a string showing our details.
-	 */
-	public String infoString() {
-		StringBuffer out = new StringBuffer();
-		// trip class reflection
-		//FB this.eGet(JavaRefPackage.eINSTANCE.getJavaClass_Public());
-		reflectBase(); //FB
-		out.append("Java class: " + getQualifiedName() + "\n");
-		out.append("  superclass: " + this.getSupertype() + "\n");
-		EList fields = getFields();
-		Field field;
-		if (fields.size() > 0) {
-			out.append("  Fields:\n");
-			for (int i = 0; i < fields.size(); i++) {
-				field = (Field) fields.get(i);
-				out.append("    " + ((JavaHelpers) field.getEType()).getJavaName() + " " + field.getName() + "\n");
-			}
-		}
-		EList methods = getMethods();
-		Method method;
-		if (methods.size() > 0) {
-			out.append("  Methods:\n");
-			for (int i = 0; i < methods.size(); i++) {
-				method = (Method) methods.get(i);
-				// trip method reflection
-				method.isStatic();
-				if (method.getReturnType() != null)
-					out.append("    " + method.getReturnType().getJavaName() + " ");
-				else
-					out.append("    void ");
-				out.append(method.getName() + "(");
-				EList parms = method.getParameters();
-				JavaParameter parm;
-				if (parms.size() > 0) {
-					for (int ii = 0; ii < parms.size(); ii++) {
-						parm = (JavaParameter) parms.get(ii);
-						//FB if (!parm.isReturn()) {
-						out.append(((JavaHelpers) parm.getEType()).getJavaName() + " " + parm.getName());
-						if (ii < parms.size() - 1)
-							out.append(", ");
-						//FB }
-					}
-				}
-				out.append(")\n");
-			}
-		}
-		return out.toString();
-	}
-
-	/**
-	 * Tests whether this class inherits from the passed in class.
-	 */
-	public boolean inheritsFrom(JavaClass javaClass) {
-		if (this == javaClass)
-			return true;
-		else if (getSupertype() != null)
-			return getSupertype().inheritsFrom(javaClass);
-		else
-			return false;
-	}
-
-	public boolean isArray() {
-		return false;
-	}
-
-	/**
-	 * Can an object of the passed in class be assigned to an object of this class. In other words is this class a supertype of the passed in class,
-	 * or is it superinterface of it.
-	 */
-	public boolean isAssignableFrom(EClassifier aClass) {
-		if (aClass instanceof JavaClass) {
-			JavaClass theClass = (JavaClass) aClass;
-			// If either this class or aClass kind is unknown then it isn't assignableFrom.
-			if (getKind() == TypeKind.UNDEFINED_LITERAL || theClass.getKind() == TypeKind.UNDEFINED_LITERAL)
-				return false;
-			// If the "aClass" is not a JavaClass (i.e. it is either a JavaDatatype or
-			// some other kind of MOF classifier), then it cannot be
-			// assigned to something of this class.
-			if (getKind() != TypeKind.INTERFACE_LITERAL)
-				if (theClass.getKind() != TypeKind.INTERFACE_LITERAL)
-					return theClass.inheritsFrom(this);
-				else {
-					// aClass is an interface, so it is assignable only if
-					// "this" is "java.lang.Object".
-					return getQualifiedName().equals("java.lang.Object");
-				}
-			else
-				return theClass.implementsInterface(this);
-		}
-		return false;
-	}
-
-	/**
-	 * Does this type exist.
-	 */
-	public boolean isExistingType() {
-		// TODO: Temporary, inefficient implementation
-		return ((JavaReflectionAdaptor) getReadAdapter()).hasReflectionSource();
-	}
-
-	/**
-	 * See if this is valid object of this type.
-	 */
-	public boolean isInstance(Object o) {
-		return o instanceof IInstantiationInstance ? isAssignableFrom(((IInstantiationInstance) o).getJavaType()) : false;
-	}
-
-	/**
-	 * Is this an interface.
-	 */
-	public boolean isInterface() {
-		return getKind() == TypeKind.INTERFACE_LITERAL;
-	}
-
-	public boolean isNested() {
-		return getDeclaringClass() != null;
-	}
-
-	public boolean isPrimitive() {
-		return false;
-	}
-
-	/**
-	 * Return an array listing our fields, including inherited fields. The field relationship is derived from contents. This implementation depends on
-	 * the assumption that supertypes above JavaClass will hold Attributes rather than Fields.
-	 */
-	public Field[] listFieldExtended() {
-		List fields = getFieldsExtended();
-		Field[] result = new Field[fields.size()];
-		fields.toArray(result);
-		return result;
-	}
-
-	/**
-	 * Return an array listing our Methods, including inherited methods. The method relationship is derived from contents. This implementation depends
-	 * on the assumption that supertypes above JavaClass will hold Operations rather than Methods.
-	 */
-	public Method[] listMethodExtended() {
-		java.util.List methods = getMethodsExtended();
-		Method[] result = new Method[methods.size()];
-		methods.toArray(result);
-		return result;
-	}
-
-	/**
-	 * This is required for internal reflection do not use.
-	 */
-	public String primGetName() {
-		return super.getName();
-	}
-
-	/**
-	 * This is required for internal reflection do not use.
-	 */
-	public String primGetQualifiedName() {
-		String result = "";
-		JavaPackage pack = getJavaPackage();
-		if (pack != null && pack.getPackageName().length() != 0)
-			result = pack.getPackageName() + "." + this.primGetName();
-		else
-			result = this.getName();
-		return result;
-	}
-
-	/**
-	 * reflect - reflect a JavaClass for a given qualified name. If the package or class does not exist, one will be created through the reflection
-	 * mechanism. Lookup the JavaClass in the context of the passed object, handling some error cases.
-	 * 
-	 * @deprecated @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, org.eclipse.emf.ecore.EObject)
-	 *  
-	 */
-	public static JavaHelpers reflect(String aQualifiedName, EObject relatedObject) {
-		return JavaRefFactory.eINSTANCE.reflectType(aQualifiedName, relatedObject);
-	}
-
-	/**
-	 * reflect - reflect a JavaClass for a given qualified name. If the package or class does not exist, one will be created through the reflection
-	 * mechanism.
-	 * 
-	 * @deprecated @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet)
-	 */
-	public static JavaHelpers reflect(String aQualifiedName, ResourceSet set) {
-		return JavaRefFactory.eINSTANCE.reflectType(aQualifiedName, set);
-	}
-
-	/**
-	 * reflect - reflect a JavaClass for a given package name or class name. If the package or class does not exist, one will be created through the
-	 * reflection mechanism.
-	 * 
-	 * @deprecated @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, java.lang.String,
-	 *             org.eclipse.emf.ecore.resource.ResourceSet)
-	 */
-	public static JavaHelpers reflect(String aPackageName, String aClassName, ResourceSet set) {
-		return JavaRefFactory.eINSTANCE.reflectType(aPackageName, aClassName, set);
-	}
-
-	public void setSupertype(JavaClass aJavaClass) throws InheritanceCycleException {
-		validateSupertype(aJavaClass);
-		List s = super.getESuperTypes();
-		s.clear();
-		if (aJavaClass != null)
-			s.add(aJavaClass);
-	}
-
-	/**
-	 * Check to make sure that the passed JavaClass is a valid super class (i.e., it does not create any cycles in the inheritance.
-	 * 
-	 * @param aJavaClass
-	 */
-	protected void validateSupertype(JavaClass aJavaClass) throws InheritanceCycleException {
-		if (!isValidSupertype(aJavaClass))
-			throw new InheritanceCycleException(this, aJavaClass);
-	}
-
-	public boolean isValidSupertype(JavaClass aJavaClass) {
-		if (aJavaClass != null) {
-			if (this.equals(aJavaClass))
-				return false;
-			return extendedIsValidSupertype(getSubtypes(), aJavaClass);
-		}
-		return true;
-	}
-
-	/**
-	 * @param subtypes
-	 * @param aJavaClass
-	 */
-	private boolean extendedIsValidSupertype(List subtypes, JavaClass aJavaClass) {
-		if (!basicIsValidSupertype(subtypes, aJavaClass))
-			return false;
-		JavaClass subtype;
-		for (int i = 0; i < subtypes.size(); i++) {
-			subtype = (JavaClass) subtypes.get(i);
-			if (!subtype.isValidSupertype(aJavaClass))
-				return false;
-		}
-		return true;
-	}
-
-	private boolean basicIsValidSupertype(List subtypes, JavaClass aJavaClass) {
-		JavaClass subtype;
-		for (int i = 0; i < subtypes.size(); i++) {
-			subtype = (JavaClass) subtypes.get(i);
-			if (subtype.equals(aJavaClass))
-				return false;
-		}
-		return true;
-	}
-
-	protected List getSubtypes() {
-		return getESuperAdapter().getSubclasses();
-	}
-
-	public String toString() {
-		return getClass().getName() + "(" + getQualifiedName() + ")";
-	}
-
-	public TypeKind getKind() {
-		reflectBase();
-		return getKindGen();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setKind(TypeKind newKind) {
-		TypeKind oldKind = kind;
-		kind = newKind == null ? KIND_EDEFAULT : newKind;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_CLASS__KIND, oldKind, kind));
-	}
-
-	public boolean isPublic() {
-		reflectBase();
-		return isPublicGen();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPublic(boolean newPublic) {
-		boolean oldPublic = (eFlags & PUBLIC_EFLAG) != 0;
-		if (newPublic) eFlags |= PUBLIC_EFLAG; else eFlags &= ~PUBLIC_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_CLASS__PUBLIC, oldPublic, newPublic));
-	}
-
-	public boolean isFinal() {
-		reflectBase();
-		return isFinalGen();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFinal(boolean newFinal) {
-		boolean oldFinal = (eFlags & FINAL_EFLAG) != 0;
-		if (newFinal) eFlags |= FINAL_EFLAG; else eFlags &= ~FINAL_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_CLASS__FINAL, oldFinal, newFinal));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public TypeKind getKindGen() {
-		return kind;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isPublicGen() {
-		return (eFlags & PUBLIC_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isFinalGen() {
-		return (eFlags & FINAL_EFLAG) != 0;
-	}
-
-	public EList getInitializers() {
-		if (initializers == null) {
-			initializers = new EObjectContainmentWithInverseEList(Initializer.class, this, JavaRefPackage.JAVA_CLASS__INITIALIZERS,
-					JavaRefPackage.INITIALIZER__JAVA_CLASS);
-		}
-		return initializers;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDeclaringClass(JavaClass newDeclaringClass) {
-		if (newDeclaringClass != declaringClass) {
-			NotificationChain msgs = null;
-			if (declaringClass != null)
-				msgs = ((InternalEObject)declaringClass).eInverseRemove(this, JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES, JavaClass.class, msgs);
-			if (newDeclaringClass != null)
-				msgs = ((InternalEObject)newDeclaringClass).eInverseAdd(this, JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES, JavaClass.class, msgs);
-			msgs = basicSetDeclaringClass(newDeclaringClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_CLASS__DECLARING_CLASS, newDeclaringClass, newDeclaringClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass getDeclaringClass() {
-		if (declaringClass != null && declaringClass.eIsProxy()) {
-			JavaClass oldDeclaringClass = declaringClass;
-			declaringClass = (JavaClass)eResolveProxy((InternalEObject)declaringClass);
-			if (declaringClass != oldDeclaringClass) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, JavaRefPackage.JAVA_CLASS__DECLARING_CLASS, oldDeclaringClass, declaringClass));
-			}
-		}
-		return declaringClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaClass basicGetDeclaringClass() {
-		return declaringClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDeclaringClass(JavaClass newDeclaringClass, NotificationChain msgs) {
-		JavaClass oldDeclaringClass = declaringClass;
-		declaringClass = newDeclaringClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_CLASS__DECLARING_CLASS, oldDeclaringClass, newDeclaringClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	public EList getDeclaredClasses() {
-		reflectBase();
-		return getDeclaredClassesGen();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDeclaredClassesGen() {
-		if (declaredClasses == null) {
-			declaredClasses = new EObjectWithInverseResolvingEList(JavaClass.class, this, JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES, JavaRefPackage.JAVA_CLASS__DECLARING_CLASS);
-		}
-		return declaredClasses;
-	}
-
-	public EList getProperties() {
-		return getEStructuralFeatures(); // As of EMF 2.0, local properties are the local features. Used to be a merge of eattributes and ereferences.
-	}
-
-	public EList getEvents() {
-		IIntrospectionAdapter adapter = getIntrospectionAdapter();
-		if (adapter != null)
-			return adapter.getEvents();
-		return getEventsGen();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getEventsGen() {
-		if (events == null) {
-			events = new EObjectContainmentEList(JavaEvent.class, this, JavaRefPackage.JAVA_CLASS__EVENTS);
-		}
-		return events;
-	}
-
-	private EList allEvents;
-
-	public EList getAllEvents() {
-		IIntrospectionAdapter ia = getIntrospectionAdapter();
-		if (ia == null)
-			return ECollections.EMPTY_ELIST; // No introspection, do normal.
-		return allEvents = ia.getAllEvents();
-	}
-
-	public EList getAllEventsGen() {
-		return allEvents;
-	}
-
-	private EList allProperties;
-
-	public EList getAllProperties() {
-		IIntrospectionAdapter ia = getIntrospectionAdapter();
-		if (ia == null)
-			return ECollections.EMPTY_ELIST; // No introspection, do normal.
-		return allProperties = ia.getAllProperties();
-	}
-
-	public EList getAllPropertiesGen() {
-		return allProperties;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_CLASS__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.JAVA_CLASS__INSTANCE_CLASS_NAME:
-				return INSTANCE_CLASS_NAME_EDEFAULT == null ? instanceClassName != null : !INSTANCE_CLASS_NAME_EDEFAULT.equals(instanceClassName);
-			case JavaRefPackage.JAVA_CLASS__INSTANCE_CLASS:
-				return INSTANCE_CLASS_EDEFAULT == null ? getInstanceClass() != null : !INSTANCE_CLASS_EDEFAULT.equals(getInstanceClass());
-			case JavaRefPackage.JAVA_CLASS__DEFAULT_VALUE:
-				return DEFAULT_VALUE_EDEFAULT == null ? getDefaultValue() != null : !DEFAULT_VALUE_EDEFAULT.equals(getDefaultValue());
-			case JavaRefPackage.JAVA_CLASS__EPACKAGE:
-				return getEPackage() != null;
-			case JavaRefPackage.JAVA_CLASS__ABSTRACT:
-				return ((eFlags & ABSTRACT_EFLAG) != 0) != ABSTRACT_EDEFAULT;
-			case JavaRefPackage.JAVA_CLASS__INTERFACE:
-				return ((eFlags & INTERFACE_EFLAG) != 0) != INTERFACE_EDEFAULT;
-			case JavaRefPackage.JAVA_CLASS__ESUPER_TYPES:
-				return eSuperTypes != null && !eSuperTypes.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-				return eOperations != null && !eOperations.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EALL_ATTRIBUTES:
-				return !getEAllAttributes().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EALL_REFERENCES:
-				return !getEAllReferences().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EREFERENCES:
-				return !getEReferences().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EATTRIBUTES:
-				return !getEAttributes().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EALL_CONTAINMENTS:
-				return !getEAllContainments().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EALL_OPERATIONS:
-				return !getEAllOperations().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EALL_STRUCTURAL_FEATURES:
-				return !getEAllStructuralFeatures().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EALL_SUPER_TYPES:
-				return !getEAllSuperTypes().isEmpty();
-			case JavaRefPackage.JAVA_CLASS__EID_ATTRIBUTE:
-				return getEIDAttribute() != null;
-			case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-				return eStructuralFeatures != null && !eStructuralFeatures.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__KIND:
-				return kind != KIND_EDEFAULT;
-			case JavaRefPackage.JAVA_CLASS__PUBLIC:
-				return ((eFlags & PUBLIC_EFLAG) != 0) != PUBLIC_EDEFAULT;
-			case JavaRefPackage.JAVA_CLASS__FINAL:
-				return ((eFlags & FINAL_EFLAG) != 0) != FINAL_EDEFAULT;
-			case JavaRefPackage.JAVA_CLASS__IMPLEMENTS_INTERFACES:
-				return implementsInterfaces != null && !implementsInterfaces.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__CLASS_IMPORT:
-				return classImport != null && !classImport.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__PACKAGE_IMPORTS:
-				return packageImports != null && !packageImports.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__FIELDS:
-				return fields != null && !fields.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__METHODS:
-				return methods != null && !methods.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__INITIALIZERS:
-				return initializers != null && !initializers.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES:
-				return declaredClasses != null && !declaredClasses.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__DECLARING_CLASS:
-				return declaringClass != null;
-			case JavaRefPackage.JAVA_CLASS__JAVA_PACKAGE:
-				return basicGetJavaPackage() != null;
-			case JavaRefPackage.JAVA_CLASS__EVENTS:
-				return events != null && !events.isEmpty();
-			case JavaRefPackage.JAVA_CLASS__ALL_EVENTS:
-				return !getAllEvents().isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_CLASS__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__INSTANCE_CLASS_NAME:
-				setInstanceClassName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__ABSTRACT:
-				setAbstract(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_CLASS__INTERFACE:
-				setInterface(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_CLASS__ESUPER_TYPES:
-				getESuperTypes().clear();
-				getESuperTypes().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-				getEOperations().clear();
-				getEOperations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-				getEStructuralFeatures().clear();
-				getEStructuralFeatures().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__KIND:
-				setKind((TypeKind)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__PUBLIC:
-				setPublic(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_CLASS__FINAL:
-				setFinal(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_CLASS__IMPLEMENTS_INTERFACES:
-				getImplementsInterfaces().clear();
-				getImplementsInterfaces().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__CLASS_IMPORT:
-				getClassImport().clear();
-				getClassImport().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__PACKAGE_IMPORTS:
-				getPackageImports().clear();
-				getPackageImports().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__FIELDS:
-				getFields().clear();
-				getFields().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__METHODS:
-				getMethods().clear();
-				getMethods().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__INITIALIZERS:
-				getInitializers().clear();
-				getInitializers().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES:
-				getDeclaredClasses().clear();
-				getDeclaredClasses().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__DECLARING_CLASS:
-				setDeclaringClass((JavaClass)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__EVENTS:
-				getEvents().clear();
-				getEvents().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_CLASS__ALL_EVENTS:
-				getAllEvents().clear();
-				getAllEvents().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_CLASS__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__INSTANCE_CLASS_NAME:
-				setInstanceClassName(INSTANCE_CLASS_NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__ABSTRACT:
-				setAbstract(ABSTRACT_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__INTERFACE:
-				setInterface(INTERFACE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__ESUPER_TYPES:
-				getESuperTypes().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-				getEOperations().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-				getEStructuralFeatures().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__KIND:
-				setKind(KIND_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__PUBLIC:
-				setPublic(PUBLIC_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__FINAL:
-				setFinal(FINAL_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_CLASS__IMPLEMENTS_INTERFACES:
-				getImplementsInterfaces().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__CLASS_IMPORT:
-				getClassImport().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__PACKAGE_IMPORTS:
-				getPackageImports().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__FIELDS:
-				getFields().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__METHODS:
-				getMethods().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__INITIALIZERS:
-				getInitializers().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES:
-				getDeclaredClasses().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__DECLARING_CLASS:
-				setDeclaringClass((JavaClass)null);
-				return;
-			case JavaRefPackage.JAVA_CLASS__EVENTS:
-				getEvents().clear();
-				return;
-			case JavaRefPackage.JAVA_CLASS__ALL_EVENTS:
-				getAllEvents().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 *  
-	 */
-	public EList getImplementsInterfacesGen() {
-		if (implementsInterfaces == null) {
-			implementsInterfaces = new EObjectResolvingEList(JavaClass.class, this, JavaRefPackage.JAVA_CLASS__IMPLEMENTS_INTERFACES) {
-
-				/**
-				 * Comment for <code>serialVersionUID</code>
-				 * 
-				 * @since 1.1.0
-				 */
-				private static final long serialVersionUID = 1L;
-
-				public Object get(int index) {
-					if (isInterface())
-						getInterfaceSuperTypes().get(index); //force resolution so the ESuperAdapter will be updated correctly
-					return super.get(index);
-				}
-
-				public void clear() {
-					super.clear();
-					if (isInterface())
-						getInterfaceSuperTypes().clear();
-				}
-
-				public Object remove(int index) {
-					Object result = super.remove(index);
-					if (isInterface())
-						getInterfaceSuperTypes().remove(index);
-					return result;
-
-				}
-
-				public boolean removeAll(Collection collection) {
-					boolean result = super.removeAll(collection);
-					if (isInterface())
-						getInterfaceSuperTypes().removeAll(collection);
-					return result;
-				}
-
-				public void add(int index, Object object) {
-					super.add(index, object);
-					if (isInterface())
-						getInterfaceSuperTypes().add(index, object);
-				}
-
-				public boolean add(Object object) {
-					boolean result = super.add(object);
-					if (isInterface())
-						getInterfaceSuperTypes().add(object);
-					return result;
-				}
-
-				public boolean addAll(Collection collection) {
-					boolean result = super.addAll(collection);
-					if (isInterface())
-						getInterfaceSuperTypes().addAll(collection);
-					return result;
-				}
-
-				public boolean addAll(int index, Collection collection) {
-					boolean result = super.addAll(index, collection);
-					if (isInterface())
-						getInterfaceSuperTypes().addAll(index, collection);
-					return result;
-				}
-			};
-		}
-		return implementsInterfaces;
-	}
-
-	private EList getInterfaceSuperTypes() {
-		return super.getESuperTypes();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getClassImportGen() {
-		if (classImport == null) {
-			classImport = new EObjectResolvingEList(JavaClass.class, this, JavaRefPackage.JAVA_CLASS__CLASS_IMPORT);
-		}
-		return classImport;
-	}
-
-	public EList getEAllSuperTypes() {
-		reflectBase();//Force reflection, if needed, before getting all supertypes.
-		return super.getEAllSuperTypes();
-	}
-
-	public EList getESuperTypes() {
-		reflectBase();
-		return super.getESuperTypes();
-	}
-	
-	/**
-	 * This method is not meant to be used by others. It is here so that the reflection
-	 * adapters can reference the unreflected supertypes.
-	 *  
-	 * @return
-	 * 
-	 * @since 1.1.0
-	 */
-	public EList primGetESuperTypes() {
-		return super.getESuperTypes();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getPackageImportsGen() {
-		if (packageImports == null) {
-			packageImports = new EObjectResolvingEList(JavaPackage.class, this, JavaRefPackage.JAVA_CLASS__PACKAGE_IMPORTS);
-		}
-		return packageImports;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFieldsGen() {
-		if (fields == null) {
-			fields = new EObjectContainmentWithInverseEList(Field.class, this, JavaRefPackage.JAVA_CLASS__FIELDS, JavaRefPackage.FIELD__JAVA_CLASS);
-		}
-		return fields;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getMethodsGen() {
-		if (methods == null) {
-			methods = new EObjectContainmentWithInverseEList(Method.class, this, JavaRefPackage.JAVA_CLASS__METHODS, JavaRefPackage.METHOD__JAVA_CLASS);
-		}
-		return methods;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public JavaPackage getJavaPackageGen() {
-		JavaPackage javaPackage = basicGetJavaPackage();
-		return javaPackage == null ? null : (JavaPackage)eResolveProxy((InternalEObject)javaPackage);
-	}
-
-	/*
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 */
-	public JavaPackage basicGetJavaPackage() {
-		return getJavaPackage();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_CLASS__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__EPACKAGE:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.JAVA_CLASS__EPACKAGE, msgs);
-				case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-					return ((InternalEList)getEOperations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-					return ((InternalEList)getEStructuralFeatures()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__FIELDS:
-					return ((InternalEList)getFields()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__METHODS:
-					return ((InternalEList)getMethods()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__INITIALIZERS:
-					return ((InternalEList)getInitializers()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES:
-					return ((InternalEList)getDeclaredClasses()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__DECLARING_CLASS:
-					if (declaringClass != null)
-						msgs = ((InternalEObject)declaringClass).eInverseRemove(this, JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES, JavaClass.class, msgs);
-					return basicSetDeclaringClass((JavaClass)otherEnd, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_CLASS__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__EPACKAGE:
-					return eBasicSetContainer(null, JavaRefPackage.JAVA_CLASS__EPACKAGE, msgs);
-				case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-					return ((InternalEList)getEOperations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-					return ((InternalEList)getEStructuralFeatures()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__FIELDS:
-					return ((InternalEList)getFields()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__METHODS:
-					return ((InternalEList)getMethods()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__INITIALIZERS:
-					return ((InternalEList)getInitializers()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES:
-					return ((InternalEList)getDeclaredClasses()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_CLASS__DECLARING_CLASS:
-					return basicSetDeclaringClass(null, msgs);
-				case JavaRefPackage.JAVA_CLASS__EVENTS:
-					return ((InternalEList)getEvents()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.JAVA_CLASS__EPACKAGE:
-					return eContainer.eInverseRemove(this, EcorePackage.EPACKAGE__ECLASSIFIERS, EPackage.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_CLASS__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.JAVA_CLASS__NAME:
-				return getName();
-			case JavaRefPackage.JAVA_CLASS__INSTANCE_CLASS_NAME:
-				return getInstanceClassName();
-			case JavaRefPackage.JAVA_CLASS__INSTANCE_CLASS:
-				return getInstanceClass();
-			case JavaRefPackage.JAVA_CLASS__DEFAULT_VALUE:
-				return getDefaultValue();
-			case JavaRefPackage.JAVA_CLASS__EPACKAGE:
-				return getEPackage();
-			case JavaRefPackage.JAVA_CLASS__ABSTRACT:
-				return isAbstract() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_CLASS__INTERFACE:
-				return isInterface() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_CLASS__ESUPER_TYPES:
-				return getESuperTypes();
-			case JavaRefPackage.JAVA_CLASS__EOPERATIONS:
-				return getEOperations();
-			case JavaRefPackage.JAVA_CLASS__EALL_ATTRIBUTES:
-				return getEAllAttributes();
-			case JavaRefPackage.JAVA_CLASS__EALL_REFERENCES:
-				return getEAllReferences();
-			case JavaRefPackage.JAVA_CLASS__EREFERENCES:
-				return getEReferences();
-			case JavaRefPackage.JAVA_CLASS__EATTRIBUTES:
-				return getEAttributes();
-			case JavaRefPackage.JAVA_CLASS__EALL_CONTAINMENTS:
-				return getEAllContainments();
-			case JavaRefPackage.JAVA_CLASS__EALL_OPERATIONS:
-				return getEAllOperations();
-			case JavaRefPackage.JAVA_CLASS__EALL_STRUCTURAL_FEATURES:
-				return getEAllStructuralFeatures();
-			case JavaRefPackage.JAVA_CLASS__EALL_SUPER_TYPES:
-				return getEAllSuperTypes();
-			case JavaRefPackage.JAVA_CLASS__EID_ATTRIBUTE:
-				return getEIDAttribute();
-			case JavaRefPackage.JAVA_CLASS__ESTRUCTURAL_FEATURES:
-				return getEStructuralFeatures();
-			case JavaRefPackage.JAVA_CLASS__KIND:
-				return getKind();
-			case JavaRefPackage.JAVA_CLASS__PUBLIC:
-				return isPublic() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_CLASS__FINAL:
-				return isFinal() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_CLASS__IMPLEMENTS_INTERFACES:
-				return getImplementsInterfaces();
-			case JavaRefPackage.JAVA_CLASS__CLASS_IMPORT:
-				return getClassImport();
-			case JavaRefPackage.JAVA_CLASS__PACKAGE_IMPORTS:
-				return getPackageImports();
-			case JavaRefPackage.JAVA_CLASS__FIELDS:
-				return getFields();
-			case JavaRefPackage.JAVA_CLASS__METHODS:
-				return getMethods();
-			case JavaRefPackage.JAVA_CLASS__INITIALIZERS:
-				return getInitializers();
-			case JavaRefPackage.JAVA_CLASS__DECLARED_CLASSES:
-				return getDeclaredClasses();
-			case JavaRefPackage.JAVA_CLASS__DECLARING_CLASS:
-				if (resolve) return getDeclaringClass();
-				return basicGetDeclaringClass();
-			case JavaRefPackage.JAVA_CLASS__JAVA_PACKAGE:
-				if (resolve) return getJavaPackage();
-				return basicGetJavaPackage();
-			case JavaRefPackage.JAVA_CLASS__EVENTS:
-				return getEvents();
-			case JavaRefPackage.JAVA_CLASS__ALL_EVENTS:
-				return getAllEvents();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toStringGen() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (kind: ");
-		result.append(kind);
-		result.append(", public: ");
-		result.append((eFlags & PUBLIC_EFLAG) != 0);
-		result.append(", final: ");
-		result.append((eFlags & FINAL_EFLAG) != 0);
-		result.append(')');
-		return result.toString();
-	}
-
-	/*
-	 * This should never be called with true. It is basically only for reset of reflection, not to set a particular state. But InternalReadAdaptable
-	 * may be used by someone that shouldn't so to be be safe we keep it. TODO Remove InternalReadAdaptable in next version. Need to wait because we
-	 * need time to notify everyone.
-	 * 
-	 * @see org.eclipse.jem.java.adapters.InternalReadAdaptable#setReflected(boolean)
-	 */
-	public synchronized void setReflected(boolean aBoolean) {
-		if (!aBoolean)
-			reflectionStatus = NOT_REFLECTED;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaClass#getReflectionType()
-	 */
-	public Object getReflectionType() {
-		JavaReflectionAdaptor ja = ((JavaReflectionAdaptor) getReadAdapter());
-		return ja != null ? ja.getReflectionSource() : null;
-	}
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaDataTypeImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaDataTypeImpl.java
deleted file mode 100644
index f5e2ede..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaDataTypeImpl.java
+++ /dev/null
@@ -1,426 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: JavaDataTypeImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.EClassImpl;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaDataType;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationInstance;
-/**
- * @generated
- */
-public class JavaDataTypeImpl extends EClassImpl implements JavaDataType{
-
-	
-	static final String FALSE = "false";
-	static final String DOUBLE_ZERO = "0.0";
-	static final String FLOAT_ZERO = "0.0f";
-	static final String CHAR_ZERO = "'0'";
-	static final String ZERO = "0";
-	
-	private int primitive_type = PRIM_NOT_ID;
-	
-	protected JavaDataTypeImpl() {
-		super();
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getJavaDataType();
-	}
-
-	/**
-	 * Return the default string representing the default value of the primitive.
-	 */
-	public String getDefaultValueString() {
-		String typeName = getJavaName();
-		if (typeName.equals(PRIM_BOOLEAN_NAME))
-			return FALSE;
-		if (typeName.equals(PRIM_DOUBLE_NAME))
-			return DOUBLE_ZERO;
-		if (typeName.equals(PRIM_FLOAT_NAME))
-			return FLOAT_ZERO;			
-		if (typeName.equals(PRIM_CHARACTER_NAME))
-			return CHAR_ZERO;
-		return ZERO;
-	}
-	public String getJavaName() {
-		return getName();
-	}
-	public JavaDataType getPrimitive() {
-		return this;
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaHelpers#getPrimitiveID()
-	 */
-	public int getPrimitiveID() {
-		if (primitive_type == PRIM_NOT_ID) {
-			String name = getName();
-			if (name.equals(PRIM_BOOLEAN_NAME))
-				primitive_type = PRIM_BOOLEAN_ID;
-			if (name.equals(PRIM_CHARACTER_NAME))
-				primitive_type = PRIM_CHARACTER_ID;
-			if (name.equals(PRIM_BYTE_NAME))
-				primitive_type = PRIM_BYTE_ID;
-			if (name.equals(PRIM_SHORT_NAME))
-				primitive_type = PRIM_SHORT_ID;
-			if (name.equals(PRIM_INTEGER_NAME))
-				primitive_type = PRIM_INTEGER_ID;
-			if (name.equals(PRIM_LONG_NAME))
-				primitive_type = PRIM_LONG_ID;
-			if (name.equals(PRIM_FLOAT_NAME))
-				primitive_type = PRIM_FLOAT_ID;
-			if (name.equals(PRIM_DOUBLE_NAME))
-				primitive_type = PRIM_DOUBLE_ID;
-		}
-		return primitive_type;
-	}
-	
-	public String getSimpleName() {
-		return getName();
-	}
-	public String getQualifiedName() {
-		return getJavaName();
-	}
-	public JavaClass getWrapper() {
-		String wrapperName = getWrapperQualifiedName();
-		if (wrapperName != null) {
-			return (JavaClass) JavaRefFactory.eINSTANCE.reflectType(wrapperName, this);
-		}
-		return null;
-	}
-	/**
-	 * getWrapper method comment.
-	 */
-	protected String getWrapperQualifiedName() {
-		switch (getPrimitiveID()) {
-			case PRIM_INTEGER_ID:
-				return INTEGER_NAME;
-			case PRIM_CHARACTER_ID:
-				return CHARACTER_NAME;
-			case PRIM_BOOLEAN_ID:
-				return BOOLEAN_NAME;
-			case PRIM_BYTE_ID:
-				return BYTE_NAME;
-			case PRIM_SHORT_ID:
-				return SHORT_NAME;
-			case PRIM_LONG_ID:
-				return LONG_NAME;
-			case PRIM_FLOAT_ID:
-				return FLOAT_NAME;
-			case PRIM_DOUBLE_ID:
-				return DOUBLE_NAME;
-			default:
-				return null;
-		}
-	}
-	/*
-	 * JavaHelpers.isArray() - array types are always JavaClasses, even if their component type is
-	 *		a primitive data type. Return false.
-	 */
-	public boolean isArray() {
-		return false;
-	}
-	/**
-	 * Can an object of the passed in class be assigned to an
-	 * object of this class? In the case of primitives, are they the same.
-	 */
-	public boolean isAssignableFrom(EClassifier aClass) {
-		return this == aClass;
-	}
-	/**
-	 * See if this is valid object of this type.
-	 */
-	public boolean isInstance(Object o) {
-		return o instanceof IInstantiationInstance ? isAssignableFrom(((IInstantiationInstance) o).getJavaType()) : false;
-	}
-	public boolean isPrimitive() {
-		return true;
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_DATA_TYPE__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE, msgs);
-				case JavaRefPackage.JAVA_DATA_TYPE__EOPERATIONS:
-					return ((InternalEList)getEOperations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES:
-					return ((InternalEList)getEStructuralFeatures()).basicAdd(otherEnd, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_DATA_TYPE__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE:
-					return eBasicSetContainer(null, JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE, msgs);
-				case JavaRefPackage.JAVA_DATA_TYPE__EOPERATIONS:
-					return ((InternalEList)getEOperations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES:
-					return ((InternalEList)getEStructuralFeatures()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE:
-					return eContainer.eInverseRemove(this, EcorePackage.EPACKAGE__ECLASSIFIERS, EPackage.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_DATA_TYPE__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.JAVA_DATA_TYPE__NAME:
-				return getName();
-			case JavaRefPackage.JAVA_DATA_TYPE__INSTANCE_CLASS_NAME:
-				return getInstanceClassName();
-			case JavaRefPackage.JAVA_DATA_TYPE__INSTANCE_CLASS:
-				return getInstanceClass();
-			case JavaRefPackage.JAVA_DATA_TYPE__DEFAULT_VALUE:
-				return getDefaultValue();
-			case JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE:
-				return getEPackage();
-			case JavaRefPackage.JAVA_DATA_TYPE__ABSTRACT:
-				return isAbstract() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_DATA_TYPE__INTERFACE:
-				return isInterface() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESUPER_TYPES:
-				return getESuperTypes();
-			case JavaRefPackage.JAVA_DATA_TYPE__EOPERATIONS:
-				return getEOperations();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_ATTRIBUTES:
-				return getEAllAttributes();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_REFERENCES:
-				return getEAllReferences();
-			case JavaRefPackage.JAVA_DATA_TYPE__EREFERENCES:
-				return getEReferences();
-			case JavaRefPackage.JAVA_DATA_TYPE__EATTRIBUTES:
-				return getEAttributes();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_CONTAINMENTS:
-				return getEAllContainments();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_OPERATIONS:
-				return getEAllOperations();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_STRUCTURAL_FEATURES:
-				return getEAllStructuralFeatures();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_SUPER_TYPES:
-				return getEAllSuperTypes();
-			case JavaRefPackage.JAVA_DATA_TYPE__EID_ATTRIBUTE:
-				return getEIDAttribute();
-			case JavaRefPackage.JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES:
-				return getEStructuralFeatures();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_DATA_TYPE__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__INSTANCE_CLASS_NAME:
-				setInstanceClassName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__ABSTRACT:
-				setAbstract(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__INTERFACE:
-				setInterface(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESUPER_TYPES:
-				getESuperTypes().clear();
-				getESuperTypes().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__EOPERATIONS:
-				getEOperations().clear();
-				getEOperations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES:
-				getEStructuralFeatures().clear();
-				getEStructuralFeatures().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_DATA_TYPE__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__INSTANCE_CLASS_NAME:
-				setInstanceClassName(INSTANCE_CLASS_NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__ABSTRACT:
-				setAbstract(ABSTRACT_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__INTERFACE:
-				setInterface(INTERFACE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESUPER_TYPES:
-				getESuperTypes().clear();
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__EOPERATIONS:
-				getEOperations().clear();
-				return;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES:
-				getEStructuralFeatures().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_DATA_TYPE__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.JAVA_DATA_TYPE__INSTANCE_CLASS_NAME:
-				return INSTANCE_CLASS_NAME_EDEFAULT == null ? instanceClassName != null : !INSTANCE_CLASS_NAME_EDEFAULT.equals(instanceClassName);
-			case JavaRefPackage.JAVA_DATA_TYPE__INSTANCE_CLASS:
-				return INSTANCE_CLASS_EDEFAULT == null ? getInstanceClass() != null : !INSTANCE_CLASS_EDEFAULT.equals(getInstanceClass());
-			case JavaRefPackage.JAVA_DATA_TYPE__DEFAULT_VALUE:
-				return DEFAULT_VALUE_EDEFAULT == null ? getDefaultValue() != null : !DEFAULT_VALUE_EDEFAULT.equals(getDefaultValue());
-			case JavaRefPackage.JAVA_DATA_TYPE__EPACKAGE:
-				return getEPackage() != null;
-			case JavaRefPackage.JAVA_DATA_TYPE__ABSTRACT:
-				return ((eFlags & ABSTRACT_EFLAG) != 0) != ABSTRACT_EDEFAULT;
-			case JavaRefPackage.JAVA_DATA_TYPE__INTERFACE:
-				return ((eFlags & INTERFACE_EFLAG) != 0) != INTERFACE_EDEFAULT;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESUPER_TYPES:
-				return eSuperTypes != null && !eSuperTypes.isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EOPERATIONS:
-				return eOperations != null && !eOperations.isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_ATTRIBUTES:
-				return !getEAllAttributes().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_REFERENCES:
-				return !getEAllReferences().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EREFERENCES:
-				return !getEReferences().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EATTRIBUTES:
-				return !getEAttributes().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_CONTAINMENTS:
-				return !getEAllContainments().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_OPERATIONS:
-				return !getEAllOperations().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_STRUCTURAL_FEATURES:
-				return !getEAllStructuralFeatures().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EALL_SUPER_TYPES:
-				return !getEAllSuperTypes().isEmpty();
-			case JavaRefPackage.JAVA_DATA_TYPE__EID_ATTRIBUTE:
-				return getEIDAttribute() != null;
-			case JavaRefPackage.JAVA_DATA_TYPE__ESTRUCTURAL_FEATURES:
-				return eStructuralFeatures != null && !eStructuralFeatures.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaHelpers#getQualifiedNameForReflection()
-	 */
-	public String getQualifiedNameForReflection() {
-		return getJavaName();
-	}
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaEventImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaEventImpl.java
deleted file mode 100644
index 217c1ec..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaEventImpl.java
+++ /dev/null
@@ -1,309 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: JavaEventImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.EStructuralFeatureImpl;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.JavaEvent;
-import org.eclipse.jem.java.JavaRefPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Java Event</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public abstract class JavaEventImpl extends EStructuralFeatureImpl implements JavaEvent {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected JavaEventImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getJavaEvent();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_EVENT__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_EVENT__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS:
-					return eBasicSetContainer(null, JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS:
-					return eContainer.eInverseRemove(this, EcorePackage.ECLASS__ESTRUCTURAL_FEATURES, EClass.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_EVENT__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.JAVA_EVENT__NAME:
-				return getName();
-			case JavaRefPackage.JAVA_EVENT__ORDERED:
-				return isOrdered() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__UNIQUE:
-				return isUnique() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__LOWER_BOUND:
-				return new Integer(getLowerBound());
-			case JavaRefPackage.JAVA_EVENT__UPPER_BOUND:
-				return new Integer(getUpperBound());
-			case JavaRefPackage.JAVA_EVENT__MANY:
-				return isMany() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__REQUIRED:
-				return isRequired() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__ETYPE:
-				if (resolve) return getEType();
-				return basicGetEType();
-			case JavaRefPackage.JAVA_EVENT__CHANGEABLE:
-				return isChangeable() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__VOLATILE:
-				return isVolatile() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__TRANSIENT:
-				return isTransient() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE_LITERAL:
-				return getDefaultValueLiteral();
-			case JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE:
-				return getDefaultValue();
-			case JavaRefPackage.JAVA_EVENT__UNSETTABLE:
-				return isUnsettable() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__DERIVED:
-				return isDerived() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS:
-				return getEContainingClass();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_EVENT__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_EVENT__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_EVENT__ORDERED:
-				setOrdered(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__UNIQUE:
-				setUnique(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__LOWER_BOUND:
-				setLowerBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__UPPER_BOUND:
-				setUpperBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__ETYPE:
-				setEType((EClassifier)newValue);
-				return;
-			case JavaRefPackage.JAVA_EVENT__CHANGEABLE:
-				setChangeable(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__VOLATILE:
-				setVolatile(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__TRANSIENT:
-				setTransient(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE_LITERAL:
-				setDefaultValueLiteral((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_EVENT__UNSETTABLE:
-				setUnsettable(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_EVENT__DERIVED:
-				setDerived(((Boolean)newValue).booleanValue());
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_EVENT__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.JAVA_EVENT__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__ORDERED:
-				setOrdered(ORDERED_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__UNIQUE:
-				setUnique(UNIQUE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__LOWER_BOUND:
-				setLowerBound(LOWER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__UPPER_BOUND:
-				setUpperBound(UPPER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__ETYPE:
-				setEType((EClassifier)null);
-				return;
-			case JavaRefPackage.JAVA_EVENT__CHANGEABLE:
-				setChangeable(CHANGEABLE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__VOLATILE:
-				setVolatile(VOLATILE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__TRANSIENT:
-				setTransient(TRANSIENT_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE_LITERAL:
-				setDefaultValueLiteral(DEFAULT_VALUE_LITERAL_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__UNSETTABLE:
-				setUnsettable(UNSETTABLE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_EVENT__DERIVED:
-				setDerived(DERIVED_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_EVENT__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.JAVA_EVENT__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.JAVA_EVENT__ORDERED:
-				return ((eFlags & ORDERED_EFLAG) != 0) != ORDERED_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__UNIQUE:
-				return ((eFlags & UNIQUE_EFLAG) != 0) != UNIQUE_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__LOWER_BOUND:
-				return lowerBound != LOWER_BOUND_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__UPPER_BOUND:
-				return upperBound != UPPER_BOUND_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__MANY:
-				return isMany() != MANY_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__REQUIRED:
-				return isRequired() != REQUIRED_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__ETYPE:
-				return eType != null;
-			case JavaRefPackage.JAVA_EVENT__CHANGEABLE:
-				return ((eFlags & CHANGEABLE_EFLAG) != 0) != CHANGEABLE_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__VOLATILE:
-				return ((eFlags & VOLATILE_EFLAG) != 0) != VOLATILE_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__TRANSIENT:
-				return ((eFlags & TRANSIENT_EFLAG) != 0) != TRANSIENT_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE_LITERAL:
-				return DEFAULT_VALUE_LITERAL_EDEFAULT == null ? defaultValueLiteral != null : !DEFAULT_VALUE_LITERAL_EDEFAULT.equals(defaultValueLiteral);
-			case JavaRefPackage.JAVA_EVENT__DEFAULT_VALUE:
-				return DEFAULT_VALUE_EDEFAULT == null ? getDefaultValue() != null : !DEFAULT_VALUE_EDEFAULT.equals(getDefaultValue());
-			case JavaRefPackage.JAVA_EVENT__UNSETTABLE:
-				return ((eFlags & UNSETTABLE_EFLAG) != 0) != UNSETTABLE_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__DERIVED:
-				return ((eFlags & DERIVED_EFLAG) != 0) != DERIVED_EDEFAULT;
-			case JavaRefPackage.JAVA_EVENT__ECONTAINING_CLASS:
-				return getEContainingClass() != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaFactoryImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaFactoryImpl.java
deleted file mode 100644
index dbcfdfd..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaFactoryImpl.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: JavaFactoryImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.impl.EFactoryImpl;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-
-import org.eclipse.jem.internal.java.instantiation.IInstantiationHandler;
-import org.eclipse.jem.internal.java.instantiation.IInstantiationHandlerFactoryAdapter;
-
-/**
- * The factory to use JavaRef packages. It will use the
- * IInstantiationHandler, if there is one, to do the
- * factory requests. Else it will let the superclass handle it.
- */
-public class JavaFactoryImpl extends EFactoryImpl {
-	
-	private IInstantiationHandler instantiationHandler;
-	private boolean retrievedHandler;
-
-	/**
-	 * Constructor for JavaFactoryImpl.
-	 */
-	public JavaFactoryImpl() {
-		super();
-	}
-
-	protected IInstantiationHandler getInstantiationHandler() {
-		if (!retrievedHandler) {
-			// Need to retrieve handler lazily because when factory is created it does not yet know what ResourceSet it is in.
-			// Can't know that until the first time we need a handler.
-			ResourceSet rset = getEPackage().eResource().getResourceSet();
-			if (rset != null) {
-				retrievedHandler = true;
-				IInstantiationHandlerFactoryAdapter factory = (IInstantiationHandlerFactoryAdapter) EcoreUtil.getExistingAdapter(rset, IInstantiationHandlerFactoryAdapter.ADAPTER_KEY);
-				if (factory != null)
-					instantiationHandler = factory.getInstantiationHandler(this);
-			}
-		}
-		return instantiationHandler;
-	}
-	
-	/**
-	 * @see org.eclipse.emf.ecore.EFactory#create(EClass)
-	 */
-	public EObject create(EClass eClass) {
-		IInstantiationHandler ia = getInstantiationHandler();
-		if (ia == null || !ia.handlesClass(eClass))
-			return super.create(eClass);
-		else
-			return ia.create(eClass);
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaPackageImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaPackageImpl.java
deleted file mode 100644
index ca4caf5..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaPackageImpl.java
+++ /dev/null
@@ -1,319 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: JavaPackageImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.ECollections;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EFactory;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.JavaPackage;
-import org.eclipse.jem.java.JavaRefPackage;
-
-import org.eclipse.jem.java.*;
-
-public class JavaPackageImpl extends EPackageImpl implements JavaPackage, EPackage {
-		/**
-		 * @generated This field/method will be replaced during code generation.
-		 */
-	protected JavaPackageImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getJavaPackage();
-	}
-
-	/**
-	 * Get the list of classes that this package contains.
-	 * Since this is a derived relationship, we need to implement
-	 * it here. It will get the metaobjects list. These are the
-	 * java classes this package contains.
-	 *
-	 * If this is the primitives package, then it must return
-	 * an empty list because it doesn't contain any classes.
-	 */
-	public EList getJavaClasses() {
-		return !PRIMITIVE_PACKAGE_NAME.equals(getName()) ?
-			ECollections.unmodifiableEList(getEClassifiers()) :
-			ECollections.EMPTY_ELIST;
-	}
-/**
- * Return the name for this package.
- * We do not want to expose the .javaprim package
- * since this is the name of the default package.
- */
-public String getName() {
-	if (isDefault())
-		return "";
-	else
-		return super.getName();
-}
-	public String getPackageName() {
-
-	String internalName = super.getName() ;
-	return JavaPackage.PRIMITIVE_PACKAGE_NAME.equals(internalName) ? "" : internalName ;	
-}
-protected boolean isDefault() {
-	return JavaPackage.PRIMITIVE_PACKAGE_NAME.equals(super.getName());	
-}
-	/**
-	 * Since classes are loaded dynamically and not from a schema, a
-	 * class could be asked for through this method, and if not yet reflected,
-	 * it wouldn't be found. We need to make sure that any class asked for
-	 * in this package is found (i.e. poofed up). Otherwise loading an instance
-	 * document that refers to java class through namespaces won't be found.
-	 */
-	public EClassifier getEClassifier(String className) {			
-		// Try to get the class from the resource that this package is in.
-		// This will create it if not found. This works because the
-		// structure is there is one java package per resource, and
-		// the id of the class is the class name without the package
-		// portion, which is what className above is.
-		Object result = eResource().getEObject(className);
-		return (result instanceof EClassifier) ? (EClassifier) result : null;
-	}
-	
-	/**
-	 * reflect - reflect a Java package for a given package name.
-	 * If the package does not exist, one will be created through
-	 * the reflection mechanism.
-	 * @deprecated
-	 * @see org.eclipse.jem.java.JavaRefFactory#reflectPackage(java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet) 
-	 */
-	public static JavaPackage reflect(String packageName, ResourceSet set) {
-		return JavaRefFactory.eINSTANCE.reflectPackage(packageName, set);
-    }
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_PACKAGE__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__EFACTORY_INSTANCE:
-					if (eFactoryInstance != null)
-						msgs = ((InternalEObject)eFactoryInstance).eInverseRemove(this, EcorePackage.EFACTORY__EPACKAGE, EFactory.class, msgs);
-					return basicSetEFactoryInstance((EFactory)otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__ECLASSIFIERS:
-					return ((InternalEList)getEClassifiers()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__ESUBPACKAGES:
-					return ((InternalEList)getESubpackages()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_PACKAGE__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__EFACTORY_INSTANCE:
-					return basicSetEFactoryInstance(null, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__ECLASSIFIERS:
-					return ((InternalEList)getEClassifiers()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__ESUBPACKAGES:
-					return ((InternalEList)getESubpackages()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE:
-					return eBasicSetContainer(null, JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE:
-					return eContainer.eInverseRemove(this, EcorePackage.EPACKAGE__ESUBPACKAGES, EPackage.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PACKAGE__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.JAVA_PACKAGE__NAME:
-				return getName();
-			case JavaRefPackage.JAVA_PACKAGE__NS_URI:
-				return getNsURI();
-			case JavaRefPackage.JAVA_PACKAGE__NS_PREFIX:
-				return getNsPrefix();
-			case JavaRefPackage.JAVA_PACKAGE__EFACTORY_INSTANCE:
-				return getEFactoryInstance();
-			case JavaRefPackage.JAVA_PACKAGE__ECLASSIFIERS:
-				return getEClassifiers();
-			case JavaRefPackage.JAVA_PACKAGE__ESUBPACKAGES:
-				return getESubpackages();
-			case JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE:
-				return getESuperPackage();
-			case JavaRefPackage.JAVA_PACKAGE__JAVA_CLASSES:
-				return getJavaClasses();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PACKAGE__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__NS_URI:
-				setNsURI((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__NS_PREFIX:
-				setNsPrefix((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__EFACTORY_INSTANCE:
-				setEFactoryInstance((EFactory)newValue);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__ECLASSIFIERS:
-				getEClassifiers().clear();
-				getEClassifiers().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__ESUBPACKAGES:
-				getESubpackages().clear();
-				getESubpackages().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PACKAGE__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__NS_URI:
-				setNsURI(NS_URI_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__NS_PREFIX:
-				setNsPrefix(NS_PREFIX_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__EFACTORY_INSTANCE:
-				setEFactoryInstance((EFactory)null);
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__ECLASSIFIERS:
-				getEClassifiers().clear();
-				return;
-			case JavaRefPackage.JAVA_PACKAGE__ESUBPACKAGES:
-				getESubpackages().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PACKAGE__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.JAVA_PACKAGE__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.JAVA_PACKAGE__NS_URI:
-				return NS_URI_EDEFAULT == null ? nsURI != null : !NS_URI_EDEFAULT.equals(nsURI);
-			case JavaRefPackage.JAVA_PACKAGE__NS_PREFIX:
-				return NS_PREFIX_EDEFAULT == null ? nsPrefix != null : !NS_PREFIX_EDEFAULT.equals(nsPrefix);
-			case JavaRefPackage.JAVA_PACKAGE__EFACTORY_INSTANCE:
-				return eFactoryInstance != null;
-			case JavaRefPackage.JAVA_PACKAGE__ECLASSIFIERS:
-				return eClassifiers != null && !eClassifiers.isEmpty();
-			case JavaRefPackage.JAVA_PACKAGE__ESUBPACKAGES:
-				return eSubpackages != null && !eSubpackages.isEmpty();
-			case JavaRefPackage.JAVA_PACKAGE__ESUPER_PACKAGE:
-				return getESuperPackage() != null;
-			case JavaRefPackage.JAVA_PACKAGE__JAVA_CLASSES:
-				return !getJavaClasses().isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-} //JavaPackageImpl
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaParameterImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaParameterImpl.java
deleted file mode 100644
index 7c3aba3..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaParameterImpl.java
+++ /dev/null
@@ -1,418 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-
-/*
- *  $RCSfile: JavaParameterImpl.java,v $
- *  $Revision: 1.2 $  $Date: 2005/09/15 20:28:04 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EOperation;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EParameterImpl;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-
-import org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter;
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-import org.eclipse.jem.java.JavaHelpers;
-import org.eclipse.jem.java.JavaParameter;
-import org.eclipse.jem.java.JavaParameterKind;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.Method;
-
-/**
- * @generated
- */
-public class JavaParameterImpl extends EParameterImpl implements JavaParameter{
-
-	/**
-	 * The default value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean FINAL_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int FINAL_EFLAG = 1 << 10;
-
-	/**
-	 * The default value of the '{@link #getParameterKind() <em>Parameter Kind</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getParameterKind()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final JavaParameterKind PARAMETER_KIND_EDEFAULT = JavaParameterKind.IN_LITERAL;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected JavaParameterKind parameterKind = PARAMETER_KIND_EDEFAULT;
-	protected JavaParameterImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getJavaParameter();
-	}
-
-	public JavaHelpers getJavaType() {
-		return (JavaHelpers)getEType();
-	}
-  public String getQualifiedName() {
-    return (eContainer() instanceof Method) ? ((Method)eContainer()).getName() + "." + this.getName() : this.getName();
-  }
-	/**
-	 * Is this parameter type an array type.
-	 */
-	public boolean isArray() {
-		return getJavaType().isArray();
-	}
-	/**
-	 * Is this a return parameter.
-	 */
-	public boolean isReturn() {
-		return JavaParameterKind.RETURN == getParameterKind().getValue();
-	}
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public boolean isFinal() {
-		return (eFlags & FINAL_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFinal(boolean newFinal) {
-		boolean oldFinal = (eFlags & FINAL_EFLAG) != 0;
-		if (newFinal) eFlags |= FINAL_EFLAG; else eFlags &= ~FINAL_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_PARAMETER__FINAL, oldFinal, newFinal));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public JavaParameterKind getParameterKind() {
-		return parameterKind;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setParameterKind(JavaParameterKind newParameterKind) {
-		JavaParameterKind oldParameterKind = parameterKind;
-		parameterKind = newParameterKind == null ? PARAMETER_KIND_EDEFAULT : newParameterKind;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.JAVA_PARAMETER__PARAMETER_KIND, oldParameterKind, parameterKind));
-	}
-
-	/*
-	 * This is not meant to be used outside of the reflection adapters.
-	 */
-	public synchronized ReadAdaptor getReadAdapter() {
-		return (ReadAdaptor) EcoreUtil.getRegisteredAdapter(eContainer(), ReadAdaptor.TYPE_KEY);
-	}
-	
-	private static final int  REFLECTED_BASE = 0x1, REFLECTED_PARAM_NAME = 0x2;
-
-	protected int reflectionStatus = REFLECTED_BASE;  // At this time base reflection
-													  // is performed at creation.
-
-	protected void reflectParamName() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if ((reflectionStatus & REFLECTED_PARAM_NAME) == 0) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = ((IJavaMethodAdapter) readAdaptor).reflectParamNamesIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				// Normally we wouldn't need to set this because it would be set during the reflectParamNamesIfNecessary, but
-				// in case there was a problem we mark it still reflected so we don't try again.
-				if (setReflected)
-					reflectionStatus |= (REFLECTED_BASE | REFLECTED_PARAM_NAME); // We can be certain base will be done by reflect generated if not already
-																			  // done.
-			}
-		}
-	}
-	
-	public String getName() {
-		reflectParamName();
-		return super.getName();
-	}
-	
-	public void setName(String name) {
-		super.setName(name);
-		synchronized (this) {
-		   reflectionStatus |= (REFLECTED_PARAM_NAME);
-		}
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PARAMETER__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.JAVA_PARAMETER__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.JAVA_PARAMETER__ORDERED:
-				return ((eFlags & ORDERED_EFLAG) != 0) != ORDERED_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__UNIQUE:
-				return ((eFlags & UNIQUE_EFLAG) != 0) != UNIQUE_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__LOWER_BOUND:
-				return lowerBound != LOWER_BOUND_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__UPPER_BOUND:
-				return upperBound != UPPER_BOUND_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__MANY:
-				return isMany() != MANY_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__REQUIRED:
-				return isRequired() != REQUIRED_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__ETYPE:
-				return eType != null;
-			case JavaRefPackage.JAVA_PARAMETER__EOPERATION:
-				return getEOperation() != null;
-			case JavaRefPackage.JAVA_PARAMETER__FINAL:
-				return ((eFlags & FINAL_EFLAG) != 0) != FINAL_EDEFAULT;
-			case JavaRefPackage.JAVA_PARAMETER__PARAMETER_KIND:
-				return parameterKind != PARAMETER_KIND_EDEFAULT;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PARAMETER__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__ORDERED:
-				setOrdered(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__UNIQUE:
-				setUnique(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__LOWER_BOUND:
-				setLowerBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__UPPER_BOUND:
-				setUpperBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__ETYPE:
-				setEType((EClassifier)newValue);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__FINAL:
-				setFinal(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__PARAMETER_KIND:
-				setParameterKind((JavaParameterKind)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PARAMETER__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__ORDERED:
-				setOrdered(ORDERED_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__UNIQUE:
-				setUnique(UNIQUE_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__LOWER_BOUND:
-				setLowerBound(LOWER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__UPPER_BOUND:
-				setUpperBound(UPPER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__ETYPE:
-				setEType((EClassifier)null);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__FINAL:
-				setFinal(FINAL_EDEFAULT);
-				return;
-			case JavaRefPackage.JAVA_PARAMETER__PARAMETER_KIND:
-				setParameterKind(PARAMETER_KIND_EDEFAULT);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (final: ");
-		result.append((eFlags & FINAL_EFLAG) != 0);
-		result.append(", parameterKind: ");
-		result.append(parameterKind);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_PARAMETER__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PARAMETER__EOPERATION:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.JAVA_PARAMETER__EOPERATION, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.JAVA_PARAMETER__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.JAVA_PARAMETER__EOPERATION:
-					return eBasicSetContainer(null, JavaRefPackage.JAVA_PARAMETER__EOPERATION, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.JAVA_PARAMETER__EOPERATION:
-					return eContainer.eInverseRemove(this, EcorePackage.EOPERATION__EPARAMETERS, EOperation.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.JAVA_PARAMETER__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.JAVA_PARAMETER__NAME:
-				return getName();
-			case JavaRefPackage.JAVA_PARAMETER__ORDERED:
-				return isOrdered() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_PARAMETER__UNIQUE:
-				return isUnique() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_PARAMETER__LOWER_BOUND:
-				return new Integer(getLowerBound());
-			case JavaRefPackage.JAVA_PARAMETER__UPPER_BOUND:
-				return new Integer(getUpperBound());
-			case JavaRefPackage.JAVA_PARAMETER__MANY:
-				return isMany() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_PARAMETER__REQUIRED:
-				return isRequired() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_PARAMETER__ETYPE:
-				if (resolve) return getEType();
-				return basicGetEType();
-			case JavaRefPackage.JAVA_PARAMETER__EOPERATION:
-				return getEOperation();
-			case JavaRefPackage.JAVA_PARAMETER__FINAL:
-				return isFinal() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.JAVA_PARAMETER__PARAMETER_KIND:
-				return getParameterKind();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefFactoryImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefFactoryImpl.java
deleted file mode 100644
index 10eba4d..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefFactoryImpl.java
+++ /dev/null
@@ -1,382 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: JavaRefFactoryImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import java.util.List;
-
-import org.eclipse.emf.common.notify.AdapterFactory;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.ResourceSet;
-import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
-
-import org.eclipse.jem.java.*;
-import org.eclipse.jem.internal.java.adapters.jdk.JavaJDKAdapterFactory;
-
-
-
-/**
- * @generated
- */
-public class JavaRefFactoryImpl extends EFactoryImpl implements JavaRefFactory {
-
-	
-	protected static Class ReflectionFactoryClass = JavaJDKAdapterFactory.class;
-	public JavaRefFactoryImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject create(EClass eClass) {
-		switch (eClass.getClassifierID()) {
-			case JavaRefPackage.JAVA_CLASS: return createJavaClass();
-			case JavaRefPackage.INITIALIZER: return createInitializer();
-			case JavaRefPackage.JAVA_PARAMETER: return createJavaParameter();
-			case JavaRefPackage.METHOD: return createMethod();
-			case JavaRefPackage.FIELD: return createField();
-			case JavaRefPackage.BLOCK: return createBlock();
-			case JavaRefPackage.COMMENT: return createComment();
-			case JavaRefPackage.STATEMENT: return createStatement();
-			case JavaRefPackage.JAVA_PACKAGE: return createJavaPackage();
-			case JavaRefPackage.JAVA_DATA_TYPE: return createJavaDataType();
-			case JavaRefPackage.ARRAY_TYPE: return createArrayType();
-			default:
-				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object createFromString(EDataType eDataType, String initialValue) {
-		switch (eDataType.getClassifierID()) {
-			case JavaRefPackage.TYPE_KIND: {
-				TypeKind result = TypeKind.get(initialValue);
-				if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
-				return result;
-			}
-			case JavaRefPackage.JAVA_VISIBILITY_KIND: {
-				JavaVisibilityKind result = JavaVisibilityKind.get(initialValue);
-				if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
-				return result;
-			}
-			case JavaRefPackage.JAVA_PARAMETER_KIND: {
-				JavaParameterKind result = JavaParameterKind.get(initialValue);
-				if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
-				return result;
-			}
-			case JavaRefPackage.JTYPE_JAVA_HELPERS:
-				return createJTypeJavaHelpersFromString(eDataType, initialValue);
-			case JavaRefPackage.JTYPE_LIST:
-				return createJTypeListFromString(eDataType, initialValue);
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String convertToString(EDataType eDataType, Object instanceValue) {
-		switch (eDataType.getClassifierID()) {
-			case JavaRefPackage.TYPE_KIND:
-				return instanceValue == null ? null : instanceValue.toString();
-			case JavaRefPackage.JAVA_VISIBILITY_KIND:
-				return instanceValue == null ? null : instanceValue.toString();
-			case JavaRefPackage.JAVA_PARAMETER_KIND:
-				return instanceValue == null ? null : instanceValue.toString();
-			case JavaRefPackage.JTYPE_JAVA_HELPERS:
-				return convertJTypeJavaHelpersToString(eDataType, instanceValue);
-			case JavaRefPackage.JTYPE_LIST:
-				return convertJTypeListToString(eDataType, instanceValue);
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
-		}
-	}
-
-	public ArrayType createArrayType(JavaHelpers componentType) {
-		ArrayType at = createArrayType();
-		
-		String computedName = componentType.getQualifiedName() + "[]";
-		at.setName(computedName);
-		return at;
-	}
-	public ArrayType createArrayType(JavaHelpers finalComponentType, int dimensions) {
-		ArrayType at = createArrayType();
-		
-		String computedName = finalComponentType.getQualifiedName();
-		for (int i = 0; i < dimensions; i++){
-			computedName = computedName + "[]";
-		}
-		at.setName(computedName);
-		return at;
-	}
-  public static ResourceSet createJavaContext() {
-    org.eclipse.jem.internal.java.init.JavaInit.init();
-    ResourceSet set = new ResourceSetImpl();
-    set.getAdapterFactories().add(createJavaReflectionAdapterFactory());
-    return set;
-  }
-	protected static AdapterFactory createJavaReflectionAdapterFactory() {
-		AdapterFactory factoryInstance = null;
-		try {
-			if (getReflectionAdapterFactoryClass() != null)
-				factoryInstance = (AdapterFactory) getReflectionAdapterFactoryClass().newInstance();
-		} catch (Exception e) {
-			// Reflection or instantiation problems.
-			// OK, can't do Java Model reflection
-		}
-		return factoryInstance;
-	}
-	/**
-	 * Return the Class for the Java refection adapter factory.
-	 */
-	public static Class getReflectionAdapterFactoryClass() {
-		return ReflectionFactoryClass;
-	}
-	/**
-	 * Set the Class for the Java refection adapter factory.
-	 * 
-	 * @see JavaPlugin.startup()
-	 */
-	public static void setReflectionAdapterFactoryClass(Class javaReflectionFactoryClass) {
-		ReflectionFactoryClass = javaReflectionFactoryClass;
-	}
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public Method createMethod() {
-		MethodImpl method = new MethodImpl();
-		return method;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public JavaClass createJavaClass() {
-		JavaClassImpl javaClass = new JavaClassImpl();
-		return javaClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public Field createField() {
-		FieldImpl field = new FieldImpl();
-		return field;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public Block createBlock() {
-		BlockImpl block = new BlockImpl();
-		return block;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public Comment createComment() {
-		CommentImpl comment = new CommentImpl();
-		return comment;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public Statement createStatement() {
-		StatementImpl statement = new StatementImpl();
-		return statement;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public Initializer createInitializer() {
-		InitializerImpl initializer = new InitializerImpl();
-		return initializer;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public JavaParameter createJavaParameter() {
-		JavaParameterImpl javaParameter = new JavaParameterImpl();
-		return javaParameter;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public ArrayType createArrayType() {
-		ArrayTypeImpl arrayType = new ArrayTypeImpl();
-		return arrayType;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaHelpers createJTypeJavaHelpersFromString(EDataType eDataType, String initialValue) {
-		return (JavaHelpers)super.createFromString(eDataType, initialValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String convertJTypeJavaHelpersToString(EDataType eDataType, Object instanceValue) {
-		return super.convertToString(eDataType, instanceValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List createJTypeListFromString(EDataType eDataType, String initialValue) {
-		return (List)super.createFromString(eDataType, initialValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String convertJTypeListToString(EDataType eDataType, Object instanceValue) {
-		return super.convertToString(eDataType, instanceValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public JavaDataType createJavaDataType() {
-		JavaDataTypeImpl javaDataType = new JavaDataTypeImpl();
-		return javaDataType;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public JavaPackage createJavaPackage() {
-		JavaPackageImpl javaPackage = new JavaPackageImpl();
-		return javaPackage;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public JavaRefPackage getJavaRefPackage() {
-		return (JavaRefPackage)getEPackage();
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public static JavaRefPackage getPackage() {
-		return JavaRefPackage.eINSTANCE;
-	}
-
-	public static JavaRefFactory getActiveFactory() {
-		return JavaRefFactory.eINSTANCE;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jem.java.JavaRefFactory#createClassRef(java.lang.String)
-	 */
-	public JavaClass createClassRef(String targetName) {
-		JavaClass ref = createJavaClass();
-		JavaURL javaurl = new JavaURL(targetName);
-		((InternalEObject) ref).eSetProxyURI(URI.createURI(javaurl.getFullString()));
-		return ref;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, org.eclipse.emf.ecore.EObject)
-	 */
-	public JavaHelpers reflectType(String aQualifiedName, EObject relatedObject) {
-		Resource r = relatedObject.eResource();
-		if (r != null) {
-			ResourceSet rs = r.getResourceSet();
-			if (rs != null) {
-				return reflectType(aQualifiedName, rs);
-			}
-		}
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet)
-	 */
-	public JavaHelpers reflectType(String aQualifiedName, ResourceSet set) {
-		if (aQualifiedName != null) {
-			int index = aQualifiedName.lastIndexOf(".");
-			if (index > 0)
-				return reflectType(aQualifiedName.substring(0, index), aQualifiedName.substring(index + 1, aQualifiedName.length()), set);
-			else
-				return reflectType("", aQualifiedName, set);
-		}
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaRefFactory#reflectType(java.lang.String, java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet)
-	 */
-	public JavaHelpers reflectType(String aPackageName, String aTypeName, ResourceSet set) {
-		if (aTypeName != null && aPackageName != null) {
-			org.eclipse.jem.internal.java.init.JavaInit.init();
-			JavaURL url = new JavaURL(aPackageName, aTypeName);
-			return (JavaHelpers) set.getEObject(URI.createURI(url.getFullString()), true);
-		}
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jem.java.JavaRefFactory#reflectPackage(java.lang.String, org.eclipse.emf.ecore.resource.ResourceSet)
-	 */
-	public JavaPackage reflectPackage(String packageName, ResourceSet set) {
-		if (packageName != null) {
-			org.eclipse.jem.internal.java.init.JavaInit.init();
-			JavaURL url = new JavaURL(packageName, JavaPackage.PACKAGE_ID);
-			return (JavaPackage) set.getEObject(URI.createURI(url.getFullString()), true);
-		}
-		return null;
-	}
-
-}
-
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefPackageImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefPackageImpl.java
deleted file mode 100644
index 4eff05b..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/JavaRefPackageImpl.java
+++ /dev/null
@@ -1,1002 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: JavaRefPackageImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import java.util.List;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EOperation;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.emf.ecore.impl.EcorePackageImpl;
-
-
-import org.eclipse.jem.java.ArrayType;
-import org.eclipse.jem.java.Block;
-import org.eclipse.jem.java.Comment;
-import org.eclipse.jem.java.Field;
-import org.eclipse.jem.java.Initializer;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaDataType;
-import org.eclipse.jem.java.JavaEvent;
-import org.eclipse.jem.java.JavaHelpers;
-import org.eclipse.jem.java.JavaPackage;
-import org.eclipse.jem.java.JavaParameter;
-import org.eclipse.jem.java.JavaParameterKind;
-import org.eclipse.jem.java.JavaRefFactory;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.JavaVisibilityKind;
-import org.eclipse.jem.java.Method;
-import org.eclipse.jem.java.Statement;
-import org.eclipse.jem.java.TypeKind;
-
-
-/**
- * @lastgen class JavaRefPackageImpl extends EPackageImpl implements JavaRefPackage, EPackage {}
- */
-public class JavaRefPackageImpl extends EPackageImpl implements JavaRefPackage {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass javaClassEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass initializerEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass javaParameterEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass methodEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass fieldEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass blockEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass commentEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass statementEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass javaPackageEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass javaDataTypeEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass arrayTypeEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass javaEventEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EEnum typeKindEEnum = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EEnum javaVisibilityKindEEnum = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EEnum javaParameterKindEEnum = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EDataType jTypeJavaHelpersEDataType = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EDataType jTypeListEDataType = null;
-
-		   /**
-		 * @generated This field/method will be replaced during code generation.
-		 */
-	private JavaRefPackageImpl() {
-		super(eNS_URI, JavaRefFactory.eINSTANCE);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static boolean isInited = false;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public static JavaRefPackage init() {
-		if (isInited) return (JavaRefPackage)EPackage.Registry.INSTANCE.getEPackage(JavaRefPackage.eNS_URI);
-
-		// Obtain or create and register package
-		JavaRefPackageImpl theJavaRefPackage = (JavaRefPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof JavaRefPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new JavaRefPackageImpl());
-
-		isInited = true;
-
-		// Initialize simple dependencies
-		EcorePackageImpl.init();
-
-		// Create package meta-data objects
-		theJavaRefPackage.createPackageContents();
-
-		// Initialize created meta-data
-		theJavaRefPackage.initializePackageContents();
-
-		// Mark meta-data to indicate it can't be changed
-		theJavaRefPackage.freeze();
-
-		return theJavaRefPackage;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getJavaClass() {
-		return javaClassEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getJavaClass_Kind() {
-		return (EAttribute)javaClassEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getJavaClass_Public() {
-		return (EAttribute)javaClassEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getJavaClass_Final() {
-		return (EAttribute)javaClassEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_ImplementsInterfaces() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_ClassImport() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_PackageImports() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_Fields() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_Methods() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(7);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_Initializers() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(8);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_DeclaringClass() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(10);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_DeclaredClasses() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(9);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_JavaPackage() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(11);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_Events() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(12);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaClass_AllEvents() {
-		return (EReference)javaClassEClass.getEStructuralFeatures().get(13);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getField() {
-		return fieldEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getField_Final() {
-		return (EAttribute)fieldEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getField_Static() {
-		return (EAttribute)fieldEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getField_JavaVisibility() {
-		return (EAttribute)fieldEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getField_Transient() {
-		return (EAttribute)fieldEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getField_Volatile() {
-		return (EAttribute)fieldEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getField_JavaClass() {
-		return (EReference)fieldEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getField_Initializer() {
-		return (EReference)fieldEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getMethod() {
-		return methodEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethod_Abstract() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethod_Native() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethod_Synchronized() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethod_Final() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(3);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethod_Constructor() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(4);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMethod_Static() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(5);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getMethod_JavaVisibility() {
-		return (EAttribute)methodEClass.getEStructuralFeatures().get(6);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getMethod_Parameters() {
-		return (EReference)methodEClass.getEStructuralFeatures().get(7);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getMethod_JavaExceptions() {
-		return (EReference)methodEClass.getEStructuralFeatures().get(8);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getMethod_JavaClass() {
-		return (EReference)methodEClass.getEStructuralFeatures().get(9);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getMethod_Source() {
-		return (EReference)methodEClass.getEStructuralFeatures().get(10);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getJavaParameter() {
-		return javaParameterEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getJavaParameter_Final() {
-		return (EAttribute)javaParameterEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getJavaParameter_ParameterKind() {
-		return (EAttribute)javaParameterEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getArrayType() {
-		return arrayTypeEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getArrayType_ArrayDimensions() {
-		return (EAttribute)arrayTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getArrayType_ComponentType() {
-		return (EReference)arrayTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getJavaDataType() {
-		return javaDataTypeEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getJavaEvent() {
-		return javaEventEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getJavaPackage() {
-		return javaPackageEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getJavaPackage_JavaClasses() {
-		return (EReference)javaPackageEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getBlock() {
-		return blockEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getBlock_Source() {
-		return (EAttribute)blockEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getBlock_Name() {
-		return (EAttribute)blockEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getBlock_Contents() {
-		return (EReference)blockEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getComment() {
-		return commentEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getStatement() {
-		return statementEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EClass getInitializer() {
-		return initializerEClass;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EAttribute getInitializer_IsStatic() {
-		return (EAttribute)initializerEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getInitializer_JavaClass() {
-		return (EReference)initializerEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EReference getInitializer_Source() {
-		return (EReference)initializerEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EEnum getJavaVisibilityKind() {
-		return javaVisibilityKindEEnum;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EEnum getJavaParameterKind() {
-		return javaParameterKindEEnum;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EEnum getTypeKind() {
-		return typeKindEEnum;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EDataType getJTypeList() {
-		return jTypeListEDataType;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public EDataType getJTypeJavaHelpers() {
-		return jTypeJavaHelpersEDataType;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public JavaRefFactory getJavaRefFactory() {
-		return (JavaRefFactory)getEFactoryInstance();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isCreated = false;
-
-	/**
-	 * Creates the meta-model objects for the package.  This method is
-	 * guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void createPackageContents() {
-		if (isCreated) return;
-		isCreated = true;
-
-		// Create classes and their features
-		javaClassEClass = createEClass(JAVA_CLASS);
-		createEAttribute(javaClassEClass, JAVA_CLASS__KIND);
-		createEAttribute(javaClassEClass, JAVA_CLASS__PUBLIC);
-		createEAttribute(javaClassEClass, JAVA_CLASS__FINAL);
-		createEReference(javaClassEClass, JAVA_CLASS__IMPLEMENTS_INTERFACES);
-		createEReference(javaClassEClass, JAVA_CLASS__CLASS_IMPORT);
-		createEReference(javaClassEClass, JAVA_CLASS__PACKAGE_IMPORTS);
-		createEReference(javaClassEClass, JAVA_CLASS__FIELDS);
-		createEReference(javaClassEClass, JAVA_CLASS__METHODS);
-		createEReference(javaClassEClass, JAVA_CLASS__INITIALIZERS);
-		createEReference(javaClassEClass, JAVA_CLASS__DECLARED_CLASSES);
-		createEReference(javaClassEClass, JAVA_CLASS__DECLARING_CLASS);
-		createEReference(javaClassEClass, JAVA_CLASS__JAVA_PACKAGE);
-		createEReference(javaClassEClass, JAVA_CLASS__EVENTS);
-		createEReference(javaClassEClass, JAVA_CLASS__ALL_EVENTS);
-
-		initializerEClass = createEClass(INITIALIZER);
-		createEAttribute(initializerEClass, INITIALIZER__IS_STATIC);
-		createEReference(initializerEClass, INITIALIZER__JAVA_CLASS);
-		createEReference(initializerEClass, INITIALIZER__SOURCE);
-
-		javaParameterEClass = createEClass(JAVA_PARAMETER);
-		createEAttribute(javaParameterEClass, JAVA_PARAMETER__FINAL);
-		createEAttribute(javaParameterEClass, JAVA_PARAMETER__PARAMETER_KIND);
-
-		methodEClass = createEClass(METHOD);
-		createEAttribute(methodEClass, METHOD__ABSTRACT);
-		createEAttribute(methodEClass, METHOD__NATIVE);
-		createEAttribute(methodEClass, METHOD__SYNCHRONIZED);
-		createEAttribute(methodEClass, METHOD__FINAL);
-		createEAttribute(methodEClass, METHOD__CONSTRUCTOR);
-		createEAttribute(methodEClass, METHOD__STATIC);
-		createEAttribute(methodEClass, METHOD__JAVA_VISIBILITY);
-		createEReference(methodEClass, METHOD__PARAMETERS);
-		createEReference(methodEClass, METHOD__JAVA_EXCEPTIONS);
-		createEReference(methodEClass, METHOD__JAVA_CLASS);
-		createEReference(methodEClass, METHOD__SOURCE);
-
-		fieldEClass = createEClass(FIELD);
-		createEAttribute(fieldEClass, FIELD__FINAL);
-		createEAttribute(fieldEClass, FIELD__STATIC);
-		createEAttribute(fieldEClass, FIELD__JAVA_VISIBILITY);
-		createEAttribute(fieldEClass, FIELD__TRANSIENT);
-		createEAttribute(fieldEClass, FIELD__VOLATILE);
-		createEReference(fieldEClass, FIELD__JAVA_CLASS);
-		createEReference(fieldEClass, FIELD__INITIALIZER);
-
-		blockEClass = createEClass(BLOCK);
-		createEAttribute(blockEClass, BLOCK__SOURCE);
-		createEAttribute(blockEClass, BLOCK__NAME);
-		createEReference(blockEClass, BLOCK__CONTENTS);
-
-		commentEClass = createEClass(COMMENT);
-
-		statementEClass = createEClass(STATEMENT);
-
-		javaPackageEClass = createEClass(JAVA_PACKAGE);
-		createEReference(javaPackageEClass, JAVA_PACKAGE__JAVA_CLASSES);
-
-		javaDataTypeEClass = createEClass(JAVA_DATA_TYPE);
-
-		arrayTypeEClass = createEClass(ARRAY_TYPE);
-		createEAttribute(arrayTypeEClass, ARRAY_TYPE__ARRAY_DIMENSIONS);
-		createEReference(arrayTypeEClass, ARRAY_TYPE__COMPONENT_TYPE);
-
-		javaEventEClass = createEClass(JAVA_EVENT);
-
-		// Create enums
-		typeKindEEnum = createEEnum(TYPE_KIND);
-		javaVisibilityKindEEnum = createEEnum(JAVA_VISIBILITY_KIND);
-		javaParameterKindEEnum = createEEnum(JAVA_PARAMETER_KIND);
-
-		// Create data types
-		jTypeJavaHelpersEDataType = createEDataType(JTYPE_JAVA_HELPERS);
-		jTypeListEDataType = createEDataType(JTYPE_LIST);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isInitialized = false;
-
-	/**
-	 * Complete the initialization of the package and its meta-model.  This
-	 * method is guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void initializePackageContents() {
-		if (isInitialized) return;
-		isInitialized = true;
-
-		// Initialize package
-		setName(eNAME);
-		setNsPrefix(eNS_PREFIX);
-		setNsURI(eNS_URI);
-
-		// Obtain other dependent packages
-		EcorePackageImpl theEcorePackage = (EcorePackageImpl)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
-
-		// Add supertypes to classes
-		javaClassEClass.getESuperTypes().add(theEcorePackage.getEClass());
-		javaParameterEClass.getESuperTypes().add(theEcorePackage.getEParameter());
-		methodEClass.getESuperTypes().add(theEcorePackage.getEOperation());
-		fieldEClass.getESuperTypes().add(theEcorePackage.getETypedElement());
-		commentEClass.getESuperTypes().add(this.getBlock());
-		statementEClass.getESuperTypes().add(this.getBlock());
-		javaPackageEClass.getESuperTypes().add(theEcorePackage.getEPackage());
-		javaDataTypeEClass.getESuperTypes().add(theEcorePackage.getEClass());
-		arrayTypeEClass.getESuperTypes().add(this.getJavaClass());
-		javaEventEClass.getESuperTypes().add(theEcorePackage.getEStructuralFeature());
-
-		// Initialize classes and features; add operations and parameters
-		initEClass(javaClassEClass, JavaClass.class, "JavaClass", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getJavaClass_Kind(), this.getTypeKind(), "kind", null, 0, 1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getJavaClass_Public(), ecorePackage.getEBoolean(), "public", null, 0, 1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getJavaClass_Final(), ecorePackage.getEBoolean(), "final", null, 0, 1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_ImplementsInterfaces(), this.getJavaClass(), null, "implementsInterfaces", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_ClassImport(), this.getJavaClass(), null, "classImport", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_PackageImports(), this.getJavaPackage(), null, "packageImports", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_Fields(), this.getField(), this.getField_JavaClass(), "fields", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_Methods(), this.getMethod(), this.getMethod_JavaClass(), "methods", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_Initializers(), this.getInitializer(), this.getInitializer_JavaClass(), "initializers", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_DeclaredClasses(), this.getJavaClass(), this.getJavaClass_DeclaringClass(), "declaredClasses", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_DeclaringClass(), this.getJavaClass(), this.getJavaClass_DeclaredClasses(), "declaringClass", null, 0, 1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_JavaPackage(), this.getJavaPackage(), this.getJavaPackage_JavaClasses(), "javaPackage", null, 0, 1, JavaClass.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_Events(), this.getJavaEvent(), null, "events", null, 0, -1, JavaClass.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getJavaClass_AllEvents(), this.getJavaEvent(), null, "allEvents", null, 0, -1, JavaClass.class, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(javaClassEClass, ecorePackage.getEBoolean(), "isNested");
-
-		EOperation op = addEOperation(javaClassEClass, this.getField(), "getField");
-		addEParameter(op, ecorePackage.getEString(), "fieldName");
-
-		op = addEOperation(javaClassEClass, this.getField(), "getFieldExtended");
-		addEParameter(op, ecorePackage.getEString(), "fieldName");
-
-		op = addEOperation(javaClassEClass, this.getField(), "getFieldNamed");
-		addEParameter(op, ecorePackage.getEString(), "fieldName");
-
-		addEOperation(javaClassEClass, this.getJTypeList(), "getFieldsExtended");
-
-		op = addEOperation(javaClassEClass, this.getMethod(), "getMethod");
-		addEParameter(op, ecorePackage.getEString(), "methodName");
-		addEParameter(op, this.getJTypeList(), "parameterTypes");
-
-		addEOperation(javaClassEClass, this.getJTypeList(), "getMethodElementSignatures");
-
-		op = addEOperation(javaClassEClass, this.getMethod(), "getMethodExtended");
-		addEParameter(op, ecorePackage.getEString(), "methodName");
-		addEParameter(op, this.getJTypeList(), "parameterTypes");
-
-		addEOperation(javaClassEClass, this.getJTypeList(), "getMethodsExtended");
-
-		op = addEOperation(javaClassEClass, this.getJTypeList(), "getOnlySpecificMethods");
-		addEParameter(op, ecorePackage.getEString(), "aMethodNamePrefix");
-		addEParameter(op, this.getJTypeList(), "excludedNames");
-
-		op = addEOperation(javaClassEClass, this.getMethod(), "getPublicMethod");
-		addEParameter(op, ecorePackage.getEString(), "methodName");
-		addEParameter(op, this.getJTypeList(), "parameterTypes");
-
-		addEOperation(javaClassEClass, this.getJTypeList(), "getPublicMethods");
-
-		addEOperation(javaClassEClass, this.getJTypeList(), "getPublicMethodsExtended");
-
-		op = addEOperation(javaClassEClass, this.getJTypeList(), "getPublicMethodsNamed");
-		addEParameter(op, ecorePackage.getEString(), "name");
-
-		addEOperation(javaClassEClass, this.getJavaClass(), "getSupertype");
-
-		op = addEOperation(javaClassEClass, ecorePackage.getEBoolean(), "implementsInterface");
-		addEParameter(op, this.getJavaClass(), "interfaceType");
-
-		addEOperation(javaClassEClass, ecorePackage.getEString(), "infoString");
-
-		op = addEOperation(javaClassEClass, ecorePackage.getEBoolean(), "inheritsFrom");
-		addEParameter(op, this.getJavaClass(), "javaClass");
-
-		addEOperation(javaClassEClass, ecorePackage.getEBoolean(), "isExistingType");
-
-		addEOperation(javaClassEClass, ecorePackage.getEBoolean(), "isInterface");
-
-		op = addEOperation(javaClassEClass, null, "setSupertype");
-		addEParameter(op, this.getJavaClass(), "javaclass");
-
-		initEClass(initializerEClass, Initializer.class, "Initializer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getInitializer_IsStatic(), ecorePackage.getEBooleanObject(), "isStatic", null, 0, 1, Initializer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getInitializer_JavaClass(), this.getJavaClass(), this.getJavaClass_Initializers(), "javaClass", null, 0, 1, Initializer.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getInitializer_Source(), this.getBlock(), null, "source", null, 0, 1, Initializer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(javaParameterEClass, JavaParameter.class, "JavaParameter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getJavaParameter_Final(), ecorePackage.getEBoolean(), "final", null, 0, 1, JavaParameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getJavaParameter_ParameterKind(), this.getJavaParameterKind(), "parameterKind", null, 0, 1, JavaParameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(javaParameterEClass, ecorePackage.getEBoolean(), "isArray");
-
-		addEOperation(javaParameterEClass, ecorePackage.getEBoolean(), "isReturn");
-
-		addEOperation(javaParameterEClass, this.getJTypeJavaHelpers(), "getJavaType");
-
-		addEOperation(javaParameterEClass, ecorePackage.getEString(), "getQualifiedName");
-
-		initEClass(methodEClass, Method.class, "Method", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getMethod_Abstract(), ecorePackage.getEBoolean(), "abstract", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMethod_Native(), ecorePackage.getEBoolean(), "native", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMethod_Synchronized(), ecorePackage.getEBoolean(), "synchronized", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMethod_Final(), ecorePackage.getEBoolean(), "final", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMethod_Constructor(), ecorePackage.getEBoolean(), "constructor", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMethod_Static(), ecorePackage.getEBoolean(), "static", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMethod_JavaVisibility(), this.getJavaVisibilityKind(), "javaVisibility", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMethod_Parameters(), this.getJavaParameter(), null, "parameters", null, 0, -1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMethod_JavaExceptions(), this.getJavaClass(), null, "javaExceptions", null, 0, -1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMethod_JavaClass(), this.getJavaClass(), this.getJavaClass_Methods(), "javaClass", null, 0, 1, Method.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMethod_Source(), this.getBlock(), null, "source", null, 0, 1, Method.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(methodEClass, this.getJavaClass(), "getContainingJavaClass");
-
-		addEOperation(methodEClass, ecorePackage.getEString(), "getMethodElementSignature");
-
-		op = addEOperation(methodEClass, this.getJavaParameter(), "getParameter");
-		addEParameter(op, ecorePackage.getEString(), "parameterName");
-
-		addEOperation(methodEClass, this.getJTypeJavaHelpers(), "getReturnType");
-
-		op = addEOperation(methodEClass, null, "setReturnType");
-		addEParameter(op, this.getJTypeJavaHelpers(), "type");
-
-		addEOperation(methodEClass, ecorePackage.getEString(), "getSignature");
-
-		addEOperation(methodEClass, ecorePackage.getEBoolean(), "isGenerated");
-
-		op = addEOperation(methodEClass, null, "setIsGenerated");
-		addEParameter(op, ecorePackage.getEBoolean(), "generated");
-
-		addEOperation(methodEClass, ecorePackage.getEBoolean(), "isVoid");
-
-		initEClass(fieldEClass, Field.class, "Field", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getField_Final(), ecorePackage.getEBoolean(), "final", null, 0, 1, Field.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getField_Static(), ecorePackage.getEBoolean(), "static", null, 0, 1, Field.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getField_JavaVisibility(), this.getJavaVisibilityKind(), "javaVisibility", null, 0, 1, Field.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getField_Transient(), ecorePackage.getEBoolean(), "transient", null, 0, 1, Field.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getField_Volatile(), ecorePackage.getEBoolean(), "volatile", null, 0, 1, Field.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getField_JavaClass(), this.getJavaClass(), this.getJavaClass_Fields(), "javaClass", null, 0, 1, Field.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getField_Initializer(), this.getBlock(), null, "initializer", null, 0, 1, Field.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(fieldEClass, this.getJavaClass(), "getContainingJavaClass");
-
-		addEOperation(fieldEClass, ecorePackage.getEBoolean(), "isArray");
-
-		initEClass(blockEClass, Block.class, "Block", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getBlock_Source(), ecorePackage.getEString(), "source", null, 0, 1, Block.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBlock_Name(), ecorePackage.getEString(), "name", null, 0, 1, Block.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBlock_Contents(), this.getBlock(), null, "contents", null, 0, -1, Block.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(commentEClass, Comment.class, "Comment", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(statementEClass, Statement.class, "Statement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(javaPackageEClass, JavaPackage.class, "JavaPackage", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getJavaPackage_JavaClasses(), this.getJavaClass(), this.getJavaClass_JavaPackage(), "javaClasses", null, 0, -1, JavaPackage.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(javaDataTypeEClass, JavaDataType.class, "JavaDataType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		addEOperation(javaDataTypeEClass, ecorePackage.getEString(), "getDefaultValueString");
-
-		initEClass(arrayTypeEClass, ArrayType.class, "ArrayType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getArrayType_ArrayDimensions(), ecorePackage.getEInt(), "arrayDimensions", null, 0, 1, ArrayType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getArrayType_ComponentType(), theEcorePackage.getEClassifier(), null, "componentType", null, 1, 1, ArrayType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		addEOperation(arrayTypeEClass, this.getJTypeJavaHelpers(), "getFinalComponentType");
-
-		addEOperation(arrayTypeEClass, this.getJTypeJavaHelpers(), "getComponentTypeAsHelper");
-
-		addEOperation(arrayTypeEClass, ecorePackage.getEBoolean(), "isPrimitiveArray");
-
-		op = addEOperation(arrayTypeEClass, null, "setComponentType");
-		addEParameter(op, this.getJTypeJavaHelpers(), "helperComponentType");
-
-		initEClass(javaEventEClass, JavaEvent.class, "JavaEvent", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		// Initialize enums and add enum literals
-		initEEnum(typeKindEEnum, TypeKind.class, "TypeKind");
-		addEEnumLiteral(typeKindEEnum, TypeKind.UNDEFINED_LITERAL);
-		addEEnumLiteral(typeKindEEnum, TypeKind.CLASS_LITERAL);
-		addEEnumLiteral(typeKindEEnum, TypeKind.INTERFACE_LITERAL);
-		addEEnumLiteral(typeKindEEnum, TypeKind.EXCEPTION_LITERAL);
-
-		initEEnum(javaVisibilityKindEEnum, JavaVisibilityKind.class, "JavaVisibilityKind");
-		addEEnumLiteral(javaVisibilityKindEEnum, JavaVisibilityKind.PUBLIC_LITERAL);
-		addEEnumLiteral(javaVisibilityKindEEnum, JavaVisibilityKind.PRIVATE_LITERAL);
-		addEEnumLiteral(javaVisibilityKindEEnum, JavaVisibilityKind.PROTECTED_LITERAL);
-		addEEnumLiteral(javaVisibilityKindEEnum, JavaVisibilityKind.PACKAGE_LITERAL);
-
-		initEEnum(javaParameterKindEEnum, JavaParameterKind.class, "JavaParameterKind");
-		addEEnumLiteral(javaParameterKindEEnum, JavaParameterKind.IN_LITERAL);
-		addEEnumLiteral(javaParameterKindEEnum, JavaParameterKind.OUT_LITERAL);
-		addEEnumLiteral(javaParameterKindEEnum, JavaParameterKind.INOUT_LITERAL);
-		addEEnumLiteral(javaParameterKindEEnum, JavaParameterKind.RETURN_LITERAL);
-
-		// Initialize data types
-		initEDataType(jTypeJavaHelpersEDataType, JavaHelpers.class, "JTypeJavaHelpers", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS);
-		initEDataType(jTypeListEDataType, List.class, "JTypeList", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS);
-
-		// Create resource
-		createResource(eNS_URI);
-	}
-
-} //JavaRefPackageImpl
-
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/MethodImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/MethodImpl.java
deleted file mode 100644
index 4486cbb..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/MethodImpl.java
+++ /dev/null
@@ -1,1133 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-
-/*
- *  $RCSfile: MethodImpl.java,v $
- *  $Revision: 1.2 $  $Date: 2005/09/15 20:28:03 $ 
- */
-
-import java.util.Collection;
-import java.util.List;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.BasicEList;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EOperationImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.emf.ecore.util.EcoreUtil;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.Block;
-import org.eclipse.jem.java.JavaClass;
-import org.eclipse.jem.java.JavaHelpers;
-import org.eclipse.jem.java.JavaParameter;
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.JavaVisibilityKind;
-import org.eclipse.jem.java.Method;
-
-
-import org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter;
-import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
-
-/**
- * @generated
- */
-public class MethodImpl extends EOperationImpl implements Method {
-
-	protected String signature;
-
-	/**
-	 * The default value of the '{@link #isAbstract() <em>Abstract</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isAbstract()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean ABSTRACT_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isAbstract() <em>Abstract</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isAbstract()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int ABSTRACT_EFLAG = 1 << 10;
-
-	/**
-	 * The default value of the '{@link #isNative() <em>Native</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isNative()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean NATIVE_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isNative() <em>Native</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isNative()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int NATIVE_EFLAG = 1 << 11;
-
-	/**
-	 * The default value of the '{@link #isSynchronized() <em>Synchronized</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSynchronized()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean SYNCHRONIZED_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isSynchronized() <em>Synchronized</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSynchronized()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int SYNCHRONIZED_EFLAG = 1 << 12;
-
-	/**
-	 * The default value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean FINAL_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isFinal() <em>Final</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isFinal()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int FINAL_EFLAG = 1 << 13;
-
-	/**
-	 * The default value of the '{@link #isConstructor() <em>Constructor</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isConstructor()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean CONSTRUCTOR_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isConstructor() <em>Constructor</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isConstructor()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int CONSTRUCTOR_EFLAG = 1 << 14;
-
-	/**
-	 * The default value of the '{@link #isStatic() <em>Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isStatic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean STATIC_EDEFAULT = false;
-
-	/**
-	 * The flag representing the value of the '{@link #isStatic() <em>Static</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isStatic()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int STATIC_EFLAG = 1 << 15;
-
-	/**
-	 * The default value of the '{@link #getJavaVisibility() <em>Java Visibility</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getJavaVisibility()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final JavaVisibilityKind JAVA_VISIBILITY_EDEFAULT = JavaVisibilityKind.PUBLIC_LITERAL;
-
-	private transient boolean isGenerated = false;
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	protected JavaVisibilityKind javaVisibility = JAVA_VISIBILITY_EDEFAULT;
-
-	/**
-	 * The cached value of the '{@link #getParameters() <em>Parameters</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getParameters()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList parameters = null;
-
-	/**
-	 * The cached value of the '{@link #getJavaExceptions() <em>Java Exceptions</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getJavaExceptions()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList javaExceptions = null;
-
-	/**
-	 * The cached value of the '{@link #getSource() <em>Source</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSource()
-	 * @generated
-	 * @ordered
-	 */
-	protected Block source = null;
-
-	protected MethodImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getMethod();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isAbstractGen() {
-		return (eFlags & ABSTRACT_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAbstract(boolean newAbstract) {
-		boolean oldAbstract = (eFlags & ABSTRACT_EFLAG) != 0;
-		if (newAbstract) eFlags |= ABSTRACT_EFLAG; else eFlags &= ~ABSTRACT_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__ABSTRACT, oldAbstract, newAbstract));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isNativeGen() {
-		return (eFlags & NATIVE_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNative(boolean newNative) {
-		boolean oldNative = (eFlags & NATIVE_EFLAG) != 0;
-		if (newNative) eFlags |= NATIVE_EFLAG; else eFlags &= ~NATIVE_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__NATIVE, oldNative, newNative));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSynchronizedGen() {
-		return (eFlags & SYNCHRONIZED_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSynchronized(boolean newSynchronized) {
-		boolean oldSynchronized = (eFlags & SYNCHRONIZED_EFLAG) != 0;
-		if (newSynchronized) eFlags |= SYNCHRONIZED_EFLAG; else eFlags &= ~SYNCHRONIZED_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__SYNCHRONIZED, oldSynchronized, newSynchronized));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isFinalGen() {
-		return (eFlags & FINAL_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFinal(boolean newFinal) {
-		boolean oldFinal = (eFlags & FINAL_EFLAG) != 0;
-		if (newFinal) eFlags |= FINAL_EFLAG; else eFlags &= ~FINAL_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__FINAL, oldFinal, newFinal));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isConstructorGen() {
-		return (eFlags & CONSTRUCTOR_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConstructor(boolean newConstructor) {
-		boolean oldConstructor = (eFlags & CONSTRUCTOR_EFLAG) != 0;
-		if (newConstructor) eFlags |= CONSTRUCTOR_EFLAG; else eFlags &= ~CONSTRUCTOR_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__CONSTRUCTOR, oldConstructor, newConstructor));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isStaticGen() {
-		return (eFlags & STATIC_EFLAG) != 0;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setStatic(boolean newStatic) {
-		boolean oldStatic = (eFlags & STATIC_EFLAG) != 0;
-		if (newStatic) eFlags |= STATIC_EFLAG; else eFlags &= ~STATIC_EFLAG;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__STATIC, oldStatic, newStatic));
-	}
-
-	/**
-	 * Return the java class that this method is defined in.
-	 */
-	public JavaClass getContainingJavaClass() {
-		return this.getJavaClass();
-	}
-
-	/**
-	 * Overrides to ensure reflection is done.
-	 */
-	public boolean isAbstract() {
-		reflectValues();
-		return isAbstractGen();
-	}
-
-	public boolean isConstructor() {
-		reflectValues();
-		return isConstructorGen();
-	}
-
-	public boolean isFinal() {
-		reflectValues();
-		return isFinalGen();
-	}
-
-	public boolean isNative() {
-		reflectValues();
-		return isNativeGen();
-	}
-
-	public boolean isStatic() {
-		reflectValues();
-		return isStaticGen();
-	}
-
-	public boolean isSynchronized() {
-		reflectValues();
-		return isSynchronizedGen();
-	}
-
-	public EList getJavaExceptions() {
-		reflectValues();
-		return getJavaExceptionsGen();
-	}
-
-	public JavaVisibilityKind getJavaVisibility() {
-		reflectValues();
-		return getJavaVisibilityGen();
-	}
-
-	public EList getParameters() {
-		reflectValues();
-		return getParametersGen();
-	}
-
-	/**
-	 * @see org.eclipse.emf.ecore.ETypedElement#getEType()
-	 */
-	public EClassifier getEType() {
-		reflectValues();
-		return super.getEType();
-	}
-
-	/**
-	 * Return a String with the the method name and its parameters. e.g. <code> setFirstName(java.lang.String) <//code> .
-	 *
-	 */
-	public String getMethodElementSignature() {
-		StringBuffer sb = new StringBuffer(75);
-		sb.append(getName());
-		sb.append("(");
-		List params = getParameters();
-		JavaParameter param;
-		int parmSize = params.size();
-		int commaTest = 0;
-		for (int j = 0; j < parmSize; j++) {
-			if (j > commaTest) {
-				sb.append(",");
-			}
-			param = (JavaParameter) params.get(j);
-			//FB if (param.isReturn()) {
-			//FB commaTest ++;
-			//FB continue;
-			//FB }
-			sb.append(((JavaHelpers) param.getEType()).getQualifiedName());
-		}
-		sb.append(")");
-		return sb.toString();
-	}
-
-	/**
-	 * Return a Parameter with the passed name, or null.
-	 */
-	public JavaParameter getParameter(String parameterName) {
-		List parms = getParameters();
-		JavaParameter parm;
-		int parmSize = parms.size();
-		for (int j = 0; j < parmSize; j++) {
-			parm = (JavaParameter) parms.get(j);
-			if (parm.getName().equals(parameterName))
-				return parm;
-		}
-		return null;
-	}
-
-	private static final int NOT_REFLECTED = 0x0, REFLECTED_BASE = 0x1, REFLECTED_GENERATED = 0x2;
-
-	protected int reflectionStatus = NOT_REFLECTED;
-
-	protected void reflectValues() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if ((reflectionStatus & REFLECTED_BASE) == 0) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = readAdaptor.reflectValuesIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				if (setReflected)
-					reflectionStatus |= REFLECTED_BASE;
-			}
-		}
-	}
-
-	/*
-	 * This is not meant to be used outside of the reflection adapters.
-	 */
-	public synchronized ReadAdaptor getReadAdapter() {
-		return (ReadAdaptor) EcoreUtil.getRegisteredAdapter(this, ReadAdaptor.TYPE_KEY);
-	}
-
-	/*
-	 * Used by reflection adapter to clear the reflection. This not intended to be used by others.
-	 */
-	public synchronized void setReflected(boolean reflected) {
-		if (!reflected)
-			reflectionStatus = NOT_REFLECTED;
-	}
-
-	/**
-	 * Get the return type.
-	 */
-	public JavaHelpers getReturnType() {
-		return (JavaHelpers) getEType();
-	}
-
-	public String getSignature() {
-		if (signature == null)
-			signature = doGetSignature();
-		return signature;
-	}
-
-	/**
-	 * Replicate the functionality of java.lang.reflect.Method.toString().
-	 * 
-	 * Returns a string describing this Method. The string is formatted as the method access modifiers, if any, followed by the method return type,
-	 * followed by a space, followed by the class declaring the method, followed by a period, followed by the method name, followed by a
-	 * parenthesized, comma-separated list of the method's formal parameter types. If the method throws checked exceptions, the parameter list is
-	 * followed by a space, followed by the word throws followed by a comma-separated list of the thrown exception types.
-	 * 
-	 * For example:
-	 * 
-	 * public boolean java.lang.Object.equals(java.lang.Object)
-	 * 
-	 * The access modifiers are placed in canonical order as specified by "The Java Language Specification". This is public,
-	 * <tt>protected<//tt> or <tt>private<//tt> first, and then other modifiers in the following order: <tt>abstract<//tt>, <tt>static<//tt>, <tt>final<//tt>, <tt>synchronized<//tt> <tt>native<//tt>.
-
-	 */
-	protected String doGetSignature() {
-		StringBuffer sb = new StringBuffer();
-		switch (getJavaVisibility().getValue()) {
-			case JavaVisibilityKind.PUBLIC:
-				sb.append("Public ");
-				break;
-			case JavaVisibilityKind.PROTECTED:
-				sb.append("Protected ");
-				break;
-			case JavaVisibilityKind.PRIVATE:
-				sb.append("Private ");
-				break;
-			case JavaVisibilityKind.PACKAGE:
-				sb.append("Package ");
-				break;
-		}
-		if (isAbstract())
-			sb.append("abstract ");
-		if (isStatic())
-			sb.append("static ");
-		if (isFinal())
-			sb.append("final ");
-		if (isSynchronized())
-			sb.append("synchronized ");
-		if (isNative())
-			sb.append("native ");
-		if (isVoid())
-			sb.append("void ");
-		else
-			sb.append(getReturnType().getQualifiedName() + " ");
-		sb.append(getContainingJavaClass().getJavaName() + ".");
-		sb.append(getName() + "(");
-		List params = getParameters();
-		JavaParameter param;
-		int parmSize = params.size();
-		for (int j = 0; j < parmSize; j++) {
-			param = (JavaParameter) params.get(j);
-			//FB if (param.isReturn())
-			//FB continue; // listParameters() includes return type in array
-			sb.append(((JavaHelpers) param.getEType()).getQualifiedName());
-			if (j < (params.size() - 1)) {
-				sb.append(",");
-			}
-		}
-		sb.append(")");
-		List exceptions = getJavaExceptions();
-		JavaClass exception;
-		if (exceptions.size() > 0) {
-			sb.append(" throws ");
-			for (int k = 0; k < exceptions.size(); k++) {
-				exception = (JavaClass) exceptions.get(k);
-				sb.append(exception.getJavaName());
-				if (k < (exceptions.size() - 1)) {
-					sb.append(",");
-				}
-			}
-		}
-		return sb.toString();
-	}
-
-	protected void reflectGenerated() {
-		// We only want the testing of the hasReflected and get readadapter to be sync(this) so that
-		// it is short and no deadlock possibility (this is because the the method reflection adapter may go
-		// back to the containing java class to get its reflection adapter, which would lock on itself. So
-		// we need to keep the sections that are sync(this) to not be deadlockable by not doing significant work
-		// during the sync.
-		ReadAdaptor readAdaptor = null;
-		synchronized (this) {
-			if ((reflectionStatus & REFLECTED_GENERATED) == 0) {
-				readAdaptor = getReadAdapter();
-			}
-		}
-		if (readAdaptor != null) {
-			boolean setReflected = ((IJavaMethodAdapter) readAdaptor).reflectGeneratedIfNecessary();
-			synchronized (this) {
-				// Don't want to set it false. That is job of reflection adapter. Otherwise we could have a race.
-				if (setReflected)
-					reflectionStatus |= (REFLECTED_GENERATED | REFLECTED_BASE); // We can be certain base will be done by reflect generated if not already
-																			  // done.
-			}
-		}
-	}
-
-	/**
-	 * Returns true if the method is system generated. This is usually determined by the "generated" tag in the comment.
-	 */
-	public boolean isGenerated() {
-		reflectGenerated();
-		return isGenerated;
-	}
-	
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 */
-	public boolean isGeneratedGen() {
-		// Ensure that you remove @generated or mark it @generated NOT
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Is this a void return type method.
-	 */
-	public boolean isVoid() {
-		//FB return (getReturnParameter() == null || "void".equals(getReturnType().getName()));
-		return (getReturnType() == null || "void".equals(getReturnType().getName()));
-	}
-
-	public JavaParameter[] listParametersWithoutReturn() {
-		Collection v = getParameters();
-		JavaParameter[] result = new JavaParameter[v.size()];
-		v.toArray(result);
-		return result;
-	}
-
-	public EList eContents() {
-		EList results = new BasicEList();
-		results.addAll(getParametersGen()); //FB
-		return results;
-	}
-
-	/**
-	 * Set the isGenerated flag.
-	 */
-	public void setIsGenerated(boolean generated) {
-		isGenerated = generated;
-	}
-
-	/**
-	 * Set the return type
-	 */
-	public void setReturnType(JavaHelpers type) {
-		this.setEType(type);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public JavaVisibilityKind getJavaVisibilityGen() {
-		return javaVisibility;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setJavaVisibility(JavaVisibilityKind newJavaVisibility) {
-		JavaVisibilityKind oldJavaVisibility = javaVisibility;
-		javaVisibility = newJavaVisibility == null ? JAVA_VISIBILITY_EDEFAULT : newJavaVisibility;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__JAVA_VISIBILITY, oldJavaVisibility, javaVisibility));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public JavaClass getJavaClass() {
-		if (eContainerFeatureID != JavaRefPackage.METHOD__JAVA_CLASS) return null;
-		return (JavaClass)eContainer;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setJavaClass(JavaClass newJavaClass) {
-		if (newJavaClass != eContainer || (eContainerFeatureID != JavaRefPackage.METHOD__JAVA_CLASS && newJavaClass != null)) {
-			if (EcoreUtil.isAncestor(this, newJavaClass))
-				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
-			NotificationChain msgs = null;
-			if (eContainer != null)
-				msgs = eBasicRemoveFromContainer(msgs);
-			if (newJavaClass != null)
-				msgs = ((InternalEObject)newJavaClass).eInverseAdd(this, JavaRefPackage.JAVA_CLASS__METHODS, JavaClass.class, msgs);
-			msgs = eBasicSetContainer((InternalEObject)newJavaClass, JavaRefPackage.METHOD__JAVA_CLASS, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__JAVA_CLASS, newJavaClass, newJavaClass));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public Block getSource() {
-		if (source != null && source.eIsProxy()) {
-			Block oldSource = source;
-			source = (Block)eResolveProxy((InternalEObject)source);
-			if (source != oldSource) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, JavaRefPackage.METHOD__SOURCE, oldSource, source));
-			}
-		}
-		return source;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Block basicGetSource() {
-		return source;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSource(Block newSource) {
-		Block oldSource = source;
-		source = newSource;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, JavaRefPackage.METHOD__SOURCE, oldSource, source));
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.METHOD__EANNOTATIONS:
-				return eAnnotations != null && !eAnnotations.isEmpty();
-			case JavaRefPackage.METHOD__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.METHOD__ORDERED:
-				return ((eFlags & ORDERED_EFLAG) != 0) != ORDERED_EDEFAULT;
-			case JavaRefPackage.METHOD__UNIQUE:
-				return ((eFlags & UNIQUE_EFLAG) != 0) != UNIQUE_EDEFAULT;
-			case JavaRefPackage.METHOD__LOWER_BOUND:
-				return lowerBound != LOWER_BOUND_EDEFAULT;
-			case JavaRefPackage.METHOD__UPPER_BOUND:
-				return upperBound != UPPER_BOUND_EDEFAULT;
-			case JavaRefPackage.METHOD__MANY:
-				return isMany() != MANY_EDEFAULT;
-			case JavaRefPackage.METHOD__REQUIRED:
-				return isRequired() != REQUIRED_EDEFAULT;
-			case JavaRefPackage.METHOD__ETYPE:
-				return eType != null;
-			case JavaRefPackage.METHOD__ECONTAINING_CLASS:
-				return getEContainingClass() != null;
-			case JavaRefPackage.METHOD__EPARAMETERS:
-				return eParameters != null && !eParameters.isEmpty();
-			case JavaRefPackage.METHOD__EEXCEPTIONS:
-				return eExceptions != null && !eExceptions.isEmpty();
-			case JavaRefPackage.METHOD__ABSTRACT:
-				return ((eFlags & ABSTRACT_EFLAG) != 0) != ABSTRACT_EDEFAULT;
-			case JavaRefPackage.METHOD__NATIVE:
-				return ((eFlags & NATIVE_EFLAG) != 0) != NATIVE_EDEFAULT;
-			case JavaRefPackage.METHOD__SYNCHRONIZED:
-				return ((eFlags & SYNCHRONIZED_EFLAG) != 0) != SYNCHRONIZED_EDEFAULT;
-			case JavaRefPackage.METHOD__FINAL:
-				return ((eFlags & FINAL_EFLAG) != 0) != FINAL_EDEFAULT;
-			case JavaRefPackage.METHOD__CONSTRUCTOR:
-				return ((eFlags & CONSTRUCTOR_EFLAG) != 0) != CONSTRUCTOR_EDEFAULT;
-			case JavaRefPackage.METHOD__STATIC:
-				return ((eFlags & STATIC_EFLAG) != 0) != STATIC_EDEFAULT;
-			case JavaRefPackage.METHOD__JAVA_VISIBILITY:
-				return javaVisibility != JAVA_VISIBILITY_EDEFAULT;
-			case JavaRefPackage.METHOD__PARAMETERS:
-				return parameters != null && !parameters.isEmpty();
-			case JavaRefPackage.METHOD__JAVA_EXCEPTIONS:
-				return javaExceptions != null && !javaExceptions.isEmpty();
-			case JavaRefPackage.METHOD__JAVA_CLASS:
-				return getJavaClass() != null;
-			case JavaRefPackage.METHOD__SOURCE:
-				return source != null;
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.METHOD__EANNOTATIONS:
-				getEAnnotations().clear();
-				getEAnnotations().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.METHOD__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.METHOD__ORDERED:
-				setOrdered(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__UNIQUE:
-				setUnique(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__LOWER_BOUND:
-				setLowerBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.METHOD__UPPER_BOUND:
-				setUpperBound(((Integer)newValue).intValue());
-				return;
-			case JavaRefPackage.METHOD__ETYPE:
-				setEType((EClassifier)newValue);
-				return;
-			case JavaRefPackage.METHOD__EPARAMETERS:
-				getEParameters().clear();
-				getEParameters().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.METHOD__EEXCEPTIONS:
-				getEExceptions().clear();
-				getEExceptions().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.METHOD__ABSTRACT:
-				setAbstract(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__NATIVE:
-				setNative(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__SYNCHRONIZED:
-				setSynchronized(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__FINAL:
-				setFinal(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__CONSTRUCTOR:
-				setConstructor(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__STATIC:
-				setStatic(((Boolean)newValue).booleanValue());
-				return;
-			case JavaRefPackage.METHOD__JAVA_VISIBILITY:
-				setJavaVisibility((JavaVisibilityKind)newValue);
-				return;
-			case JavaRefPackage.METHOD__PARAMETERS:
-				getParameters().clear();
-				getParameters().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.METHOD__JAVA_EXCEPTIONS:
-				getJavaExceptions().clear();
-				getJavaExceptions().addAll((Collection)newValue);
-				return;
-			case JavaRefPackage.METHOD__JAVA_CLASS:
-				setJavaClass((JavaClass)newValue);
-				return;
-			case JavaRefPackage.METHOD__SOURCE:
-				setSource((Block)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.METHOD__EANNOTATIONS:
-				getEAnnotations().clear();
-				return;
-			case JavaRefPackage.METHOD__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__ORDERED:
-				setOrdered(ORDERED_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__UNIQUE:
-				setUnique(UNIQUE_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__LOWER_BOUND:
-				setLowerBound(LOWER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__UPPER_BOUND:
-				setUpperBound(UPPER_BOUND_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__ETYPE:
-				setEType((EClassifier)null);
-				return;
-			case JavaRefPackage.METHOD__EPARAMETERS:
-				getEParameters().clear();
-				return;
-			case JavaRefPackage.METHOD__EEXCEPTIONS:
-				getEExceptions().clear();
-				return;
-			case JavaRefPackage.METHOD__ABSTRACT:
-				setAbstract(ABSTRACT_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__NATIVE:
-				setNative(NATIVE_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__SYNCHRONIZED:
-				setSynchronized(SYNCHRONIZED_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__FINAL:
-				setFinal(FINAL_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__CONSTRUCTOR:
-				setConstructor(CONSTRUCTOR_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__STATIC:
-				setStatic(STATIC_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__JAVA_VISIBILITY:
-				setJavaVisibility(JAVA_VISIBILITY_EDEFAULT);
-				return;
-			case JavaRefPackage.METHOD__PARAMETERS:
-				getParameters().clear();
-				return;
-			case JavaRefPackage.METHOD__JAVA_EXCEPTIONS:
-				getJavaExceptions().clear();
-				return;
-			case JavaRefPackage.METHOD__JAVA_CLASS:
-				setJavaClass((JavaClass)null);
-				return;
-			case JavaRefPackage.METHOD__SOURCE:
-				setSource((Block)null);
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation.
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (abstract: ");
-		result.append((eFlags & ABSTRACT_EFLAG) != 0);
-		result.append(", native: ");
-		result.append((eFlags & NATIVE_EFLAG) != 0);
-		result.append(", synchronized: ");
-		result.append((eFlags & SYNCHRONIZED_EFLAG) != 0);
-		result.append(", final: ");
-		result.append((eFlags & FINAL_EFLAG) != 0);
-		result.append(", constructor: ");
-		result.append((eFlags & CONSTRUCTOR_EFLAG) != 0);
-		result.append(", static: ");
-		result.append((eFlags & STATIC_EFLAG) != 0);
-		result.append(", javaVisibility: ");
-		result.append(javaVisibility);
-		result.append(')');
-		return result.toString();
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public EList getParametersGen() {
-		if (parameters == null) {
-			parameters = new EObjectContainmentEList(JavaParameter.class, this, JavaRefPackage.METHOD__PARAMETERS);
-		}
-		return parameters;
-	}
-
-	/**
-	 * @generated This field/method will be replaced during code generation 
-	 */
-	public EList getJavaExceptionsGen() {
-		if (javaExceptions == null) {
-			javaExceptions = new EObjectResolvingEList(JavaClass.class, this, JavaRefPackage.METHOD__JAVA_EXCEPTIONS);
-		}
-		return javaExceptions;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.METHOD__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.METHOD__ECONTAINING_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.METHOD__ECONTAINING_CLASS, msgs);
-				case JavaRefPackage.METHOD__EPARAMETERS:
-					return ((InternalEList)getEParameters()).basicAdd(otherEnd, msgs);
-				case JavaRefPackage.METHOD__JAVA_CLASS:
-					if (eContainer != null)
-						msgs = eBasicRemoveFromContainer(msgs);
-					return eBasicSetContainer(otherEnd, JavaRefPackage.METHOD__JAVA_CLASS, msgs);
-				default:
-					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		if (eContainer != null)
-			msgs = eBasicRemoveFromContainer(msgs);
-		return eBasicSetContainer(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.METHOD__EANNOTATIONS:
-					return ((InternalEList)getEAnnotations()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.METHOD__ECONTAINING_CLASS:
-					return eBasicSetContainer(null, JavaRefPackage.METHOD__ECONTAINING_CLASS, msgs);
-				case JavaRefPackage.METHOD__EPARAMETERS:
-					return ((InternalEList)getEParameters()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.METHOD__PARAMETERS:
-					return ((InternalEList)getParameters()).basicRemove(otherEnd, msgs);
-				case JavaRefPackage.METHOD__JAVA_CLASS:
-					return eBasicSetContainer(null, JavaRefPackage.METHOD__JAVA_CLASS, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
-		if (eContainerFeatureID >= 0) {
-			switch (eContainerFeatureID) {
-				case JavaRefPackage.METHOD__ECONTAINING_CLASS:
-					return eContainer.eInverseRemove(this, EcorePackage.ECLASS__EOPERATIONS, EClass.class, msgs);
-				case JavaRefPackage.METHOD__JAVA_CLASS:
-					return eContainer.eInverseRemove(this, JavaRefPackage.JAVA_CLASS__METHODS, JavaClass.class, msgs);
-				default:
-					return eDynamicBasicRemoveFromContainer(msgs);
-			}
-		}
-		return eContainer.eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.METHOD__EANNOTATIONS:
-				return getEAnnotations();
-			case JavaRefPackage.METHOD__NAME:
-				return getName();
-			case JavaRefPackage.METHOD__ORDERED:
-				return isOrdered() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__UNIQUE:
-				return isUnique() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__LOWER_BOUND:
-				return new Integer(getLowerBound());
-			case JavaRefPackage.METHOD__UPPER_BOUND:
-				return new Integer(getUpperBound());
-			case JavaRefPackage.METHOD__MANY:
-				return isMany() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__REQUIRED:
-				return isRequired() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__ETYPE:
-				if (resolve) return getEType();
-				return basicGetEType();
-			case JavaRefPackage.METHOD__ECONTAINING_CLASS:
-				return getEContainingClass();
-			case JavaRefPackage.METHOD__EPARAMETERS:
-				return getEParameters();
-			case JavaRefPackage.METHOD__EEXCEPTIONS:
-				return getEExceptions();
-			case JavaRefPackage.METHOD__ABSTRACT:
-				return isAbstract() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__NATIVE:
-				return isNative() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__SYNCHRONIZED:
-				return isSynchronized() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__FINAL:
-				return isFinal() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__CONSTRUCTOR:
-				return isConstructor() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__STATIC:
-				return isStatic() ? Boolean.TRUE : Boolean.FALSE;
-			case JavaRefPackage.METHOD__JAVA_VISIBILITY:
-				return getJavaVisibility();
-			case JavaRefPackage.METHOD__PARAMETERS:
-				return getParameters();
-			case JavaRefPackage.METHOD__JAVA_EXCEPTIONS:
-				return getJavaExceptions();
-			case JavaRefPackage.METHOD__JAVA_CLASS:
-				return getJavaClass();
-			case JavaRefPackage.METHOD__SOURCE:
-				if (resolve) return getSource();
-				return basicGetSource();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-}
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/StatementImpl.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/StatementImpl.java
deleted file mode 100644
index 8ea3905..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/StatementImpl.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: StatementImpl.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.util.InternalEList;
-
-import org.eclipse.jem.java.JavaRefPackage;
-import org.eclipse.jem.java.Statement;
-/**
- * @generated
- */
-public class StatementImpl extends BlockImpl implements Statement{
-
-	protected StatementImpl() {
-		super();
-	}
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return JavaRefPackage.eINSTANCE.getStatement();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
-		if (featureID >= 0) {
-			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
-				case JavaRefPackage.STATEMENT__CONTENTS:
-					return ((InternalEList)getContents()).basicRemove(otherEnd, msgs);
-				default:
-					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
-			}
-		}
-		return eBasicSetContainer(null, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.STATEMENT__SOURCE:
-				return getSource();
-			case JavaRefPackage.STATEMENT__NAME:
-				return getName();
-			case JavaRefPackage.STATEMENT__CONTENTS:
-				return getContents();
-		}
-		return eDynamicGet(eFeature, resolve);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(EStructuralFeature eFeature, Object newValue) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.STATEMENT__SOURCE:
-				setSource((String)newValue);
-				return;
-			case JavaRefPackage.STATEMENT__NAME:
-				setName((String)newValue);
-				return;
-			case JavaRefPackage.STATEMENT__CONTENTS:
-				getContents().clear();
-				getContents().addAll((Collection)newValue);
-				return;
-		}
-		eDynamicSet(eFeature, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.STATEMENT__SOURCE:
-				setSource(SOURCE_EDEFAULT);
-				return;
-			case JavaRefPackage.STATEMENT__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case JavaRefPackage.STATEMENT__CONTENTS:
-				getContents().clear();
-				return;
-		}
-		eDynamicUnset(eFeature);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(EStructuralFeature eFeature) {
-		switch (eDerivedStructuralFeatureID(eFeature)) {
-			case JavaRefPackage.STATEMENT__SOURCE:
-				return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source);
-			case JavaRefPackage.STATEMENT__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case JavaRefPackage.STATEMENT__CONTENTS:
-				return contents != null && !contents.isEmpty();
-		}
-		return eDynamicIsSet(eFeature);
-	}
-
-}
-
-
-
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/URL.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/URL.java
deleted file mode 100644
index 4b6febd..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/internal/impl/URL.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.internal.impl;
-/*
- *  $RCSfile: URL.java,v $
- *  $Revision: 1.1 $  $Date: 2005/09/14 23:30:32 $ 
- */
-import java.util.ArrayList;
-import java.util.List;
-
-public class URL {
-	public String namespaceName;
-	public String ID;
-	List attributeNames;
-/**
- * URL constructor comment.
- */
-public URL(String urlString) {
-	initializeFromString(urlString);
-}
-/**
- * URL constructor comment.
- */
-public URL(String nameSpaceName, String anID) {
-	this.namespaceName = nameSpaceName;
-	this.ID = anID;
-}
-public List getAttributeNames() {
-	return attributeNames;
-}
-public void initializeFromString(String urlString) {
-	int poundInx = urlString.lastIndexOf('#');
-	if (poundInx > -1) {
-		namespaceName = urlString.substring(0, poundInx);
-		urlString = urlString.substring(poundInx + 1);
-		int dotIndex = urlString.indexOf("->"); //$NON-NLS-1$
-		if (dotIndex > -1) {
-			ID = urlString.substring(0, dotIndex);
-			String attributeNameString = urlString.substring(dotIndex + 2);
-			attributeNames = new ArrayList();
-			do {
-				dotIndex = attributeNameString.indexOf("->"); //$NON-NLS-1$
-				if (dotIndex > -1) {
-					attributeNames.add(attributeNameString.substring(0, dotIndex));
-					attributeNameString = attributeNameString.substring(dotIndex + 2);
-				} else
-					attributeNames.add(attributeNameString);
-			} while (dotIndex > -1);
-		} else {
-			ID = urlString;
-		}
-	} else {
-		// assume that any URL string that ends with .xmi is a namespace.
-		if (urlString.endsWith(".xmi")){ //$NON-NLS-1$
-			namespaceName = urlString;
-			ID = null;
-		} else {
-			namespaceName = "?defaultURL?"; //$NON-NLS-1$
-			ID = urlString;
-		}
-	}
-}
-public String toString() {
-	return "URL(" + ((namespaceName == null) ? "" : namespaceName + "#") + ((ID == null) ? "" : ID) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
-}
-}
-
-
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/JavaRefAdapterFactory.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/JavaRefAdapterFactory.java
deleted file mode 100644
index 469898c..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/JavaRefAdapterFactory.java
+++ /dev/null
@@ -1,478 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.util;
-/*
- *  $RCSfile: JavaRefAdapterFactory.java,v $
- *  $Revision: 1.6 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import org.eclipse.emf.common.notify.Adapter;
-import org.eclipse.emf.common.notify.Notifier;
-
-import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.ENamedElement;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EOperation;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EParameter;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.ETypedElement;
-
-import org.eclipse.jem.java.*;
-
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Adapter Factory</b> for the model.
- * It provides an adapter <code>createXXX</code> method for each class of the model.
- * <!-- end-user-doc -->
- * @see org.eclipse.jem.java.JavaRefPackage
- * @generated
- */
-public class JavaRefAdapterFactory extends AdapterFactoryImpl
-{
-	/**
-	 * The cached model package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected static JavaRefPackage modelPackage;
-
-	/**
-	 * Creates an instance of the adapter factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaRefAdapterFactory() {
-		if (modelPackage == null) {
-			modelPackage = JavaRefPackage.eINSTANCE;
-		}
-	}
-
-	/**
-	 * Returns whether this factory is applicable for the type of the object.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
-	 * <!-- end-user-doc -->
-	 * @return whether this factory is applicable for the type of the object.
-	 * @generated
-	 */
-	public boolean isFactoryForType(Object object) {
-		if (object == modelPackage) {
-			return true;
-		}
-		if (object instanceof EObject) {
-			return ((EObject)object).eClass().getEPackage() == modelPackage;
-		}
-		return false;
-	}
-
-	/**
-	 * The switch the delegates to the <code>createXXX</code> methods.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected JavaRefSwitch modelSwitch =
-		new JavaRefSwitch() {
-			public Object caseJavaClass(JavaClass object) {
-				return createJavaClassAdapter();
-			}
-			public Object caseInitializer(Initializer object) {
-				return createInitializerAdapter();
-			}
-			public Object caseJavaParameter(JavaParameter object) {
-				return createJavaParameterAdapter();
-			}
-			public Object caseMethod(Method object) {
-				return createMethodAdapter();
-			}
-			public Object caseField(Field object) {
-				return createFieldAdapter();
-			}
-			public Object caseBlock(Block object) {
-				return createBlockAdapter();
-			}
-			public Object caseComment(Comment object) {
-				return createCommentAdapter();
-			}
-			public Object caseStatement(Statement object) {
-				return createStatementAdapter();
-			}
-			public Object caseJavaPackage(JavaPackage object) {
-				return createJavaPackageAdapter();
-			}
-			public Object caseJavaDataType(JavaDataType object) {
-				return createJavaDataTypeAdapter();
-			}
-			public Object caseArrayType(ArrayType object) {
-				return createArrayTypeAdapter();
-			}
-			public Object caseJavaEvent(JavaEvent object) {
-				return createJavaEventAdapter();
-			}
-			public Object caseEModelElement(EModelElement object) {
-				return createEModelElementAdapter();
-			}
-			public Object caseENamedElement(ENamedElement object) {
-				return createENamedElementAdapter();
-			}
-			public Object caseEClassifier(EClassifier object) {
-				return createEClassifierAdapter();
-			}
-			public Object caseEClass(EClass object) {
-				return createEClassAdapter();
-			}
-			public Object caseETypedElement(ETypedElement object) {
-				return createETypedElementAdapter();
-			}
-			public Object caseEParameter(EParameter object) {
-				return createEParameterAdapter();
-			}
-			public Object caseEOperation(EOperation object) {
-				return createEOperationAdapter();
-			}
-			public Object caseEPackage(EPackage object) {
-				return createEPackageAdapter();
-			}
-			public Object caseEStructuralFeature(EStructuralFeature object) {
-				return createEStructuralFeatureAdapter();
-			}
-			public Object defaultCase(EObject object) {
-				return createEObjectAdapter();
-			}
-		};
-
-	/**
-	 * Creates an adapter for the <code>target</code>.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param target the object to adapt.
-	 * @return the adapter for the <code>target</code>.
-	 * @generated
-	 */
-	public Adapter createAdapter(Notifier target) {
-		return (Adapter)modelSwitch.doSwitch((EObject)target);
-	}
-
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.JavaClass <em>Java Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.JavaClass
-	 * @generated
-	 */
-	public Adapter createJavaClassAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.Initializer <em>Initializer</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.Initializer
-	 * @generated
-	 */
-	public Adapter createInitializerAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.JavaParameter <em>Java Parameter</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.JavaParameter
-	 * @generated
-	 */
-	public Adapter createJavaParameterAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.Method <em>Method</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.Method
-	 * @generated
-	 */
-	public Adapter createMethodAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.Field <em>Field</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.Field
-	 * @generated
-	 */
-	public Adapter createFieldAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.Block <em>Block</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.Block
-	 * @generated
-	 */
-	public Adapter createBlockAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.Comment <em>Comment</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.Comment
-	 * @generated
-	 */
-	public Adapter createCommentAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.Statement <em>Statement</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.Statement
-	 * @generated
-	 */
-	public Adapter createStatementAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.JavaPackage <em>Java Package</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.JavaPackage
-	 * @generated
-	 */
-	public Adapter createJavaPackageAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.JavaDataType <em>Java Data Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.JavaDataType
-	 * @generated
-	 */
-	public Adapter createJavaDataTypeAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.ArrayType <em>Array Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.ArrayType
-	 * @generated
-	 */
-	public Adapter createArrayTypeAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jem.java.JavaEvent <em>Java Event</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.jem.java.JavaEvent
-	 * @generated
-	 */
-	public Adapter createJavaEventAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EModelElement <em>EModel Element</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EModelElement
-	 * @generated
-	 */
-	public Adapter createEModelElementAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.ENamedElement <em>ENamed Element</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.ENamedElement
-	 * @generated
-	 */
-	public Adapter createENamedElementAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EClassifier <em>EClassifier</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EClassifier
-	 * @generated
-	 */
-	public Adapter createEClassifierAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EClass <em>EClass</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EClass
-	 * @generated
-	 */
-	public Adapter createEClassAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.ETypedElement <em>ETyped Element</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.ETypedElement
-	 * @generated
-	 */
-	public Adapter createETypedElementAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EParameter <em>EParameter</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EParameter
-	 * @generated
-	 */
-	public Adapter createEParameterAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EOperation <em>EOperation</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EOperation
-	 * @generated
-	 */
-	public Adapter createEOperationAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EStructuralFeature <em>EStructural Feature</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EStructuralFeature
-	 * @generated
-	 */
-	public Adapter createEStructuralFeatureAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.emf.ecore.EPackage <em>EPackage</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @see org.eclipse.emf.ecore.EPackage
-	 * @generated
-	 */
-	public Adapter createEPackageAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for the default case.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @generated
-	 */
-	public Adapter createEObjectAdapter() {
-		return null;
-	}
-
-} //JavaRefAdapterFactory
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/JavaRefSwitch.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/JavaRefSwitch.java
deleted file mode 100644
index 1c7edff..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/JavaRefSwitch.java
+++ /dev/null
@@ -1,547 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jem.java.util;
-
-/*
- *  $RCSfile: JavaRefSwitch.java,v $
- *  $Revision: 1.7 $  $Date: 2005/08/24 20:20:24 $ 
- */
-import java.util.List;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
-import org.eclipse.emf.ecore.EModelElement;
-import org.eclipse.emf.ecore.ENamedElement;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EOperation;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EParameter;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.ETypedElement;
-
-import org.eclipse.jem.java.*;
-
-
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Switch</b> for the model's inheritance hierarchy.
- * It supports the call {@link #doSwitch doSwitch(object)}
- * to invoke the <code>caseXXX</code> method for each class of the model,
- * starting with the actual class of the object
- * and proceeding up the inheritance hierarchy
- * until a non-null result is returned,
- * which is the result of the switch.
- * <!-- end-user-doc -->
- * @see org.eclipse.jem.java.JavaRefPackage
- * @generated
- */
-public class JavaRefSwitch {
-	/**
-	 * The cached model package
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected static JavaRefPackage modelPackage;
-
-	/**
-	 * Creates an instance of the switch.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public JavaRefSwitch() {
-		if (modelPackage == null) {
-			modelPackage = JavaRefPackage.eINSTANCE;
-		}
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
-	public Object doSwitch(EObject theEObject) {
-		return doSwitch(theEObject.eClass(), theEObject);
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
-	protected Object doSwitch(EClass theEClass, EObject theEObject) {
-		if (theEClass.eContainer() == modelPackage) {
-			return doSwitch(theEClass.getClassifierID(), theEObject);
-		}
-		else {
-			List eSuperTypes = theEClass.getESuperTypes();
-			return
-				eSuperTypes.isEmpty() ?
-					defaultCase(theEObject) :
-					doSwitch((EClass)eSuperTypes.get(0), theEObject);
-		}
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
-	protected Object doSwitch(int classifierID, EObject theEObject) {
-		switch (classifierID) {
-			case JavaRefPackage.JAVA_CLASS: {
-				JavaClass javaClass = (JavaClass)theEObject;
-				Object result = caseJavaClass(javaClass);
-				if (result == null) result = caseEClass(javaClass);
-				if (result == null) result = caseEClassifier(javaClass);
-				if (result == null) result = caseENamedElement(javaClass);
-				if (result == null) result = caseEModelElement(javaClass);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.INITIALIZER: {
-				Initializer initializer = (Initializer)theEObject;
-				Object result = caseInitializer(initializer);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.JAVA_PARAMETER: {
-				JavaParameter javaParameter = (JavaParameter)theEObject;
-				Object result = caseJavaParameter(javaParameter);
-				if (result == null) result = caseEParameter(javaParameter);
-				if (result == null) result = caseETypedElement(javaParameter);
-				if (result == null) result = caseENamedElement(javaParameter);
-				if (result == null) result = caseEModelElement(javaParameter);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.METHOD: {
-				Method method = (Method)theEObject;
-				Object result = caseMethod(method);
-				if (result == null) result = caseEOperation(method);
-				if (result == null) result = caseETypedElement(method);
-				if (result == null) result = caseENamedElement(method);
-				if (result == null) result = caseEModelElement(method);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.FIELD: {
-				Field field = (Field)theEObject;
-				Object result = caseField(field);
-				if (result == null) result = caseETypedElement(field);
-				if (result == null) result = caseENamedElement(field);
-				if (result == null) result = caseEModelElement(field);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.BLOCK: {
-				Block block = (Block)theEObject;
-				Object result = caseBlock(block);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.COMMENT: {
-				Comment comment = (Comment)theEObject;
-				Object result = caseComment(comment);
-				if (result == null) result = caseBlock(comment);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.STATEMENT: {
-				Statement statement = (Statement)theEObject;
-				Object result = caseStatement(statement);
-				if (result == null) result = caseBlock(statement);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.JAVA_PACKAGE: {
-				JavaPackage javaPackage = (JavaPackage)theEObject;
-				Object result = caseJavaPackage(javaPackage);
-				if (result == null) result = caseEPackage(javaPackage);
-				if (result == null) result = caseENamedElement(javaPackage);
-				if (result == null) result = caseEModelElement(javaPackage);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.JAVA_DATA_TYPE: {
-				JavaDataType javaDataType = (JavaDataType)theEObject;
-				Object result = caseJavaDataType(javaDataType);
-				if (result == null) result = caseEClass(javaDataType);
-				if (result == null) result = caseEClassifier(javaDataType);
-				if (result == null) result = caseENamedElement(javaDataType);
-				if (result == null) result = caseEModelElement(javaDataType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.ARRAY_TYPE: {
-				ArrayType arrayType = (ArrayType)theEObject;
-				Object result = caseArrayType(arrayType);
-				if (result == null) result = caseJavaClass(arrayType);
-				if (result == null) result = caseEClass(arrayType);
-				if (result == null) result = caseEClassifier(arrayType);
-				if (result == null) result = caseENamedElement(arrayType);
-				if (result == null) result = caseEModelElement(arrayType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case JavaRefPackage.JAVA_EVENT: {
-				JavaEvent javaEvent = (JavaEvent)theEObject;
-				Object result = caseJavaEvent(javaEvent);
-				if (result == null) result = caseEStructuralFeature(javaEvent);
-				if (result == null) result = caseETypedElement(javaEvent);
-				if (result == null) result = caseENamedElement(javaEvent);
-				if (result == null) result = caseEModelElement(javaEvent);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			default: return defaultCase(theEObject);
-		}
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Java Class</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Java Class</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseJavaClass(JavaClass object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Initializer</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Initializer</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseInitializer(Initializer object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Java Parameter</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Java Parameter</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseJavaParameter(JavaParameter object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Method</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Method</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseMethod(Method object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Field</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Field</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseField(Field object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Block</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Block</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseBlock(Block object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Comment</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Comment</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseComment(Comment object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Statement</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Statement</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseStatement(Statement object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Java Package</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Java Package</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseJavaPackage(JavaPackage object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Java Data Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Java Data Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseJavaDataType(JavaDataType object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Array Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Array Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseArrayType(ArrayType object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>Java Event</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>Java Event</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseJavaEvent(JavaEvent object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EModel Element</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EModel Element</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEModelElement(EModelElement object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>ENamed Element</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>ENamed Element</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseENamedElement(ENamedElement object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EClassifier</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EClassifier</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEClassifier(EClassifier object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EClass</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EClass</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEClass(EClass object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>ETyped Element</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>ETyped Element</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseETypedElement(ETypedElement object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EParameter</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EParameter</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEParameter(EParameter object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EOperation</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EOperation</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEOperation(EOperation object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EStructural Feature</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EStructural Feature</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEStructuralFeature(EStructuralFeature object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EPackage</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EPackage</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseEPackage(EPackage object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpretting the object as an instance of '<em>EObject</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch, but this is the last case anyway.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpretting the object as an instance of '<em>EObject</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
-	 * @generated
-	 */
-	public Object defaultCase(EObject object) {
-		return null;
-	}
-
-} //JavaRefSwitch
diff --git a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/NotificationUtil.java b/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/NotificationUtil.java
deleted file mode 100644
index c479002..0000000
--- a/plugins/org.eclipse.jem/mofjava/org/eclipse/jem/java/util/NotificationUtil.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- *  $RCSfile: NotificationUtil.java,v $
- *  $Revision: 1.2 $  $Date: 2005/02/15 22:37:02 $ 
- */
-package org.eclipse.jem.java.util;
-
-import org.eclipse.emf.common.notify.Notification;
-
-import org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor;
-import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor;
- 
-
-/**
- * This is a utility class of static methods for handling special JEM notifications.
- * 
- * @since 1.1.0
- */
-public class NotificationUtil {
-	/*
-	 * Not meant to be constructed.
-	 */
-	private NotificationUtil() {
-		
-	}
-	
-	/**
-	 * Answer whether this notification is a reflection notification. If it is, then it means that the JavaClass has
-	 * just had reflection performed on it.
-	 * @param msg
-	 * @return <code>true</code> if this is a reflection event.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static boolean isReflectionEvent(Notification msg) {
-		return msg.getEventType() == ReflectionAdaptor.EVENT && msg.getFeature() == ReflectionAdaptor.REFLECTION_EVENT;
-	}
-	
-	/**
-	 * Answer whether this notification is a reflection flush event of a JavaClass with existing code. If it is, then it means that the 
-	 * JavaClass has just had the reflection results flushed, AND this was a class that had either source or binary code on it..
-	 * @param msg
-	 * @return <code>true</code> if this is a flush event.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static boolean isFlushEvent(Notification msg) {
-		return msg.getEventType() == ReflectionAdaptor.EVENT && msg.getFeature() == JavaReflectionAdaptor.FLUSH_REFLECTION_EVENT;
-	}
-
-	/**
-	 * Answer whether this notification is a reflection flush event of a JavaClass that is new and doesn't have existing code.
-	 * If it is, then it means that the JavaClass has just had the reflection results flushed, AND this was a class that was new and
-	 * had no code behind it.
-	 * @param msg
-	 * @return <code>true</code> if this is a flush event of new class.
-	 * 
-	 * @since 1.1.0
-	 */
-	public static boolean isFlushNewEvent(Notification msg) {
-		return msg.getEventType() == ReflectionAdaptor.EVENT && msg.getFeature() == JavaReflectionAdaptor.FLUSH_NEW_REFLECTION_EVENT;
-	}
-
-}
diff --git a/plugins/org.eclipse.jem/overrides/..ROOT...override b/plugins/org.eclipse.jem/overrides/..ROOT...override
deleted file mode 100644
index b0456ed..0000000
--- a/plugins/org.eclipse.jem/overrides/..ROOT...override
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<change:ChangeDescription xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:change="http://www.eclipse.org/emf/2003/Change" xmi:version="2.0">
-   <objectChanges key="X:ROOT#//@root">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="_eStructuralFeatures"/>
-         <!-- too remind us that these are need to be done yet in the new allocation scheme. 
-  <addedEObjects xsi:type="ecore:EAttribute" name="instantiateUsing" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-  <addedEObjects xsi:type="ecore:EAttribute" name="serializeData" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
--->
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="_eStructuralFeatures" xsi:type="ecore:EReference"/>
-</change:ChangeDescription>
diff --git a/plugins/org.eclipse.jem/overrides/java/lang/Object.override b/plugins/org.eclipse.jem/overrides/java/lang/Object.override
deleted file mode 100644
index ea32058..0000000
--- a/plugins/org.eclipse.jem/overrides/java/lang/Object.override
+++ /dev/null
@@ -1,56 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<change:ChangeDescription xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:change="http://www.eclipse.org/emf/2003/Change" xmi:version="2.0">
-   <!-- 
-      This is kind of cheat, but datatypes are never introspected, so we can't get these attributes
-      added to them in a normal way. By doing it here, when java.lang.Object is introspected, these
-      will be done at the same time. And since Object needs to be introspected before anything else
-      can be done, these will be done before anything needs them. -->
-   <objectChanges key="java:/#boolean">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="boolean_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="boolean_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#char">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="char_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="char_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#int">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="int_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="int_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#float">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="float_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="float_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#short">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="short_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="short_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#long">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="long_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="long_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#double">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="double_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="double_eStructuralFeatures" xsi:type="ecore:EReference"/>
-   <objectChanges key="java:/#byte">
-      <value featureName="eStructuralFeatures">
-         <listChanges referenceValues="byte_eStructuralFeatures"/>
-      </value>
-   </objectChanges>
-   <objectsToAttach containment="true" eType="ecore:EClass http:///org/eclipse/jem/internal/instantiation.ecore#//JavaAllocation" name="allocation" xmi:id="byte_eStructuralFeatures" xsi:type="ecore:EReference"/>
-</change:ChangeDescription>
diff --git a/plugins/org.eclipse.jem/plugin.properties b/plugins/org.eclipse.jem/plugin.properties
deleted file mode 100644
index 50bea86..0000000
--- a/plugins/org.eclipse.jem/plugin.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-###############################################################################
-# Copyright (c) 2003, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     IBM Corporation - initial API and implementation
-###############################################################################
-#
-# $Source: /cvsroot/webtools/jeetools.move/webtools.javaee.git/plugins/org.eclipse.jem/plugin.properties,v $
-# $Revision: 1.3 $  $Date: 2005/08/24 20:20:25 $
-#
-
-
-pluginName = Java EMF Model
-providerName = Eclipse.org
diff --git a/plugins/org.eclipse.jem/plugin.xml b/plugins/org.eclipse.jem/plugin.xml
deleted file mode 100644
index bad4c0e..0000000
--- a/plugins/org.eclipse.jem/plugin.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-
-     <extension
-         point="org.eclipse.emf.ecore.generated_package">
-      <package
-            uri="http:///org/eclipse/jem/internal/instantiation.ecore"
-            class="org.eclipse.jem.internal.instantiation.InstantiationPackage">
-      </package>
-      <package
-            uri="java.xmi"
-            class="org.eclipse.jem.java.JavaRefPackage">
-      </package>
-   </extension>
-   <extension
-         point="org.eclipse.jem.beaninfo.registrations">
-      <registration container="org.eclipse.jdt.launching.JRE_CONTAINER">
-        <override
-            package="java.lang"
-            path="overrides/java/lang">
-        </override>
-        <override
-            package="..ROOT.."
-            path="overrides">
-        </override>
-      </registration>
-   </extension>
-
-</plugin>
diff --git a/plugins/org.eclipse.jem/rose/.cvsignore b/plugins/org.eclipse.jem/rose/.cvsignore
deleted file mode 100644
index 1be3a37..0000000
--- a/plugins/org.eclipse.jem/rose/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*.md~
-*.ca~
\ No newline at end of file
diff --git a/plugins/org.eclipse.jem/rose/edocjava2.cat b/plugins/org.eclipse.jem/rose/edocjava2.cat
deleted file mode 100644
index 25b1eec..0000000
--- a/plugins/org.eclipse.jem/rose/edocjava2.cat
+++ /dev/null
@@ -1,5613 +0,0 @@
-
-(object Petal
-    version    	47
-    _written   	"Rose 8.0.0303.1400"
-    charSet    	0)
-
-(object Class_Category "java"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    attributes 	(list Attribute_Set
-	(object Attribute
-	    tool       	"IDL"
-	    name       	"uuid"
-	    value      	(value Text "DCE:c74525a0-8826-11e1-0000-005d9e6adec4:1"))
-	(object Attribute
-	    tool       	"Ecore"
-	    name       	"basePackage"
-	    value      	(value Text "org.eclipse.jem"))
-	(object Attribute
-	    tool       	"Ecore"
-	    name       	"prefix"
-	    value      	(value Text "JavaRef"))
-	(object Attribute
-	    tool       	"Ecore"
-	    name       	"nsURI"
-	    value      	(value Text "java.xmi")))
-    quid       	"36549F2C004E"
-    documentation 	
-|Changes to synch up with Java3e:
-|- deleted JavaElement, BodyElement which didn't add anything useful
-|- deleted NestedClass and the association which described nesting, contents can be used instead
-|- deleted extends/extendedBy which is replaced with MOF subtype/supertype
-|- deleted the clumsy main diagram
-|- moved the MOF inheritance details to the MOF binding diagram
-|- deleted "final" on JavaParameter, don't know what that was supposed to be
-|- deleted the Category junk
-|- changed the Block-typed attributes on Field, Method, Initializer to be associations to Block
-|
-|Outstanding questions/issues:
-|- JavaParameterKind should go away if we get the base Parameter kind fixed up
-|
-    
-    stereotype 	"metamodel"
-    visible_categories 	(list visibility_relationship_list
-	(object Visibility_Relationship
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0001-005d9e6adec4:1")))
-	    quid       	"381DDF470271"
-	    supplier   	"Logical View::mof"
-	    quidu      	"374AA8F9028E")
-	(object Visibility_Relationship
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0002-005d9e6adec4:1")))
-	    quid       	"39BD366000FE"
-	    supplier   	"Logical View::ecore"
-	    quidu      	"39A5ED04004E"))
-    exportControl 	"Public"
-    logical_models 	(list unit_reference_list
-	(object Class "JavaClass"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0003-005d9e6adec4:1")))
-	    quid       	"36549FCC00FA"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0004-005d9e6adec4:1")))
-		    quid       	"3990950000B3"
-		    supplier   	"Logical View::ecore::EClass"
-		    quidu      	"3903D5BF000A"))
-	    operations 	(list Operations
-		(object Operation "isNested"
-		    quid       	"3A9D7C2101D6"
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "getField"
-		    quid       	"3B65B5B30044"
-		    documentation 	"Return an Field with the passed name, or null."
-		    parameters 	(list Parameters
-			(object Parameter "fieldName"
-			    quid       	"3C62FAB901AA"
-			    type       	"String"))
-		    result     	"Field"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AF8F0280")
-		(object Operation "getFieldExtended"
-		    quid       	"3B65B625011A"
-		    documentation 	
-| Return an Field with the passed name from this JavaClass or any supertypes.
-|
-|Return null if a Field named fieldName is not found.
-		    
-		    parameters 	(list Parameters
-			(object Parameter "fieldName"
-			    quid       	"3C62FAB901AC"
-			    type       	"String"))
-		    result     	"Field"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AF8F0280")
-		(object Operation "getFieldNamed"
-		    quid       	"3B65B6670255"
-		    documentation 	"Return an Field with the passed name, or null."
-		    parameters 	(list Parameters
-			(object Parameter "fieldName"
-			    quid       	"3C62FAB901AE"
-			    type       	"String"))
-		    result     	"Field"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AF8F0280")
-		(object Operation "getFieldsExtended"
-		    quid       	"3B65B68A0328"
-		    documentation 	"Return all fields, including those from supertypes."
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getMethod"
-		    quid       	"3B65B911021A"
-		    documentation 	"Get the method of this name and these parameters. It will not look up the supertype hierarchy."
-		    parameters 	(list Parameters
-			(object Parameter "methodName"
-			    quid       	"3C62FAB901B1"
-			    type       	"String")
-			(object Parameter "parameterTypes"
-			    quid       	"3C62FAB901B2"
-			    documentation 	"List of parameter types."
-			    type       	"JTypeList"
-			    quidu      	"3B65B87602C1"))
-		    result     	"Method"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AE910271")
-		(object Operation "getMethodElementSignatures"
-		    quid       	"3B65B9EA03CA"
-		    documentation 	"Return a List of Strings that represent MethodElement signatures from most general to most specific."
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getMethodExtended"
-		    quid       	"3B65BA510115"
-		    documentation 	"Get the method of this name and these parameters. It will look up the supertype hierarchy."
-		    parameters 	(list Parameters
-			(object Parameter "methodName"
-			    quid       	"3C62FAB901B5"
-			    type       	"String")
-			(object Parameter "parameterTypes"
-			    quid       	"3C62FAB901B6"
-			    documentation 	"List of parameter types."
-			    type       	"JTypeList"
-			    quidu      	"3B65B87602C1"))
-		    result     	"Method"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AE910271")
-		(object Operation "getMethodsExtended"
-		    quid       	"3B65BA7D0354"
-		    documentation 	"Return all methods, including those from supertypes."
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getOnlySpecificMethods"
-		    quid       	"3B65BAC3021E"
-		    documentation 	
-|Return a List of Methods that begins with @aMethodNamePrefix and is not included in the @excludedNames list. If @aMethodNamePrefix is null, all methods will be returned.
-|
-		    
-		    parameters 	(list Parameters
-			(object Parameter "aMethodNamePrefix"
-			    quid       	"3C62FAB901B9"
-			    type       	"String")
-			(object Parameter "excludedNames"
-			    quid       	"3C62FAB901BA"
-			    type       	"JTypeList"
-			    quidu      	"3B65B87602C1"))
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getPublicMethod"
-		    quid       	"3B65BBC90383"
-		    documentation 	"Return a method matching the name, and non-return parameters with fully qualified types matching all the types in the list, if it exists.  It will not look up the supertype hierarchy."
-		    parameters 	(list Parameters
-			(object Parameter "methodName"
-			    quid       	"3C62FAB901BC"
-			    type       	"String")
-			(object Parameter "parameterTypes"
-			    quid       	"3C62FAB901BD"
-			    documentation 	"List of parameter types."
-			    type       	"JTypeList"
-			    quidu      	"3B65B87602C1"))
-		    result     	"Method"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AE910271")
-		(object Operation "getPublicMethods"
-		    quid       	"3B65BC3D034E"
-		    documentation 	"Return all methods, it will not go up the supertype hierarchy."
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getPublicMethodsExtended"
-		    quid       	"3B65BC630320"
-		    documentation 	"Return all public methods, including those from supertypes."
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getPublicMethodsNamed"
-		    quid       	"3B65BCAA005B"
-		    documentation 	"Returns a filtered list on the methods of this class, having a name equal to that of the parameter."
-		    parameters 	(list Parameters
-			(object Parameter "name"
-			    quid       	"3C62FAB901C1"
-			    type       	"String"))
-		    result     	"JTypeList"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65B87602C1")
-		(object Operation "getSupertype"
-		    quid       	"3B65BCF900CD"
-		    result     	"JavaClass"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"36549FCC00FA")
-		(object Operation "implementsInterface"
-		    quid       	"3B65BD39009D"
-		    documentation 	"Test whether the receiver implements the passed interface (or one of its supertypes)."
-		    parameters 	(list Parameters
-			(object Parameter "interfaceType"
-			    quid       	"3C62FAB901C4"
-			    type       	"JavaClass"
-			    quidu      	"36549FCC00FA"))
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "infoString"
-		    quid       	"3B65BD8202D3"
-		    documentation 	"Return a string showing our details."
-		    result     	"String"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "inheritsFrom"
-		    quid       	"3B65BD9E02E7"
-		    documentation 	"Tests whether this class inherits from the passed in class."
-		    parameters 	(list Parameters
-			(object Parameter "javaClass"
-			    quid       	"3C62FAB901C7"
-			    type       	"JavaClass"
-			    quidu      	"36549FCC00FA"))
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "isExistingType"
-		    quid       	"3B65BE110120"
-		    documentation 	"Does this type exist."
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "isInterface"
-		    quid       	"3B65BE2F0137"
-		    documentation 	"Is this an interface."
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "setSupertype"
-		    quid       	"3B65BE7B00A0"
-		    documentation 	"Set the supertype."
-		    parameters 	(list Parameters
-			(object Parameter "javaclass"
-			    quid       	"3C62FAB901CB"
-			    type       	"JavaClass"
-			    quidu      	"36549FCC00FA"))
-		    result     	"void"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "kind"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0005-005d9e6adec4:1")))
-		    quid       	"3654A45E0232"
-		    type       	"TypeKind"
-		    quidu      	"3654B46002BF"
-		    exportControl 	"Public")
-		(object ClassAttribute "public"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0006-005d9e6adec4:1")))
-		    quid       	"380F8CE8020C"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "final"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0008-005d9e6adec4:1")))
-		    quid       	"380F8F9C02D7"
-		    type       	"boolean"
-		    exportControl 	"Public"))
-	    language   	"none")
-	(object Class "Initializer"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0009-005d9e6adec4:1")))
-	    quid       	"3654A5DC00BB"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "isStatic"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-000a-005d9e6adec4:1")))
-		    quid       	"3654A865000F"
-		    type       	"Boolean"
-		    exportControl 	"Public"))
-	    language   	"none")
-	(object Class "JavaParameter"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-000b-005d9e6adec4:1")))
-	    quid       	"3654AD780280"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3B7818B00186"
-		    supplier   	"Logical View::ecore::EParameter"
-		    quidu      	"3903E6150104"))
-	    operations 	(list Operations
-		(object Operation "isArray"
-		    quid       	"3B65BFD4034F"
-		    documentation 	"Is this parameter type an array type."
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "isReturn"
-		    quid       	"3B65BFEF0005"
-		    documentation 	"Is this a return parameter."
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "getJavaType"
-		    quid       	"3B65C8E7001A"
-		    result     	"JTypeJavaHelpers"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65ADE403A6")
-		(object Operation "getQualifiedName"
-		    quid       	"3B65C926002F"
-		    result     	"String"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "final"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-000c-005d9e6adec4:1")))
-		    quid       	"3654B64702AF"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "parameterKind"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-000e-005d9e6adec4:1")))
-		    quid       	"391C1EB400C2"
-		    type       	"JavaParameterKind"
-		    quidu      	"391C1E8F0123"
-		    exportControl 	"Public"))
-	    language   	"none")
-	(object Class "Method"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-000f-005d9e6adec4:1")))
-	    quid       	"3654AE910271"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0010-005d9e6adec4:1")))
-		    quid       	"3990953803AD"
-		    supplier   	"Logical View::ecore::EOperation"
-		    quidu      	"3904DAA200A0"))
-	    operations 	(list Operations
-		(object Operation "getContainingJavaClass"
-		    quid       	"3B65C04202A3"
-		    documentation 	"Return the java class that this method is defined in."
-		    result     	"JavaClass"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"36549FCC00FA")
-		(object Operation "getMethodElementSignature"
-		    quid       	"3B65C076013F"
-		    documentation 	
-|Return a String with the the method name and its parameters. e.g. <code> setFirstName(java.lang.String) </code> .
-| 
-		    
-		    result     	"String"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "getParameter"
-		    quid       	"3B65C0B8011C"
-		    documentation 	"Return a Parameter with the passed name, or null."
-		    parameters 	(list Parameters
-			(object Parameter "parameterName"
-			    quid       	"3C62FAB901E3"
-			    type       	"String"))
-		    result     	"JavaParameter"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3654AD780280")
-		(object Operation "getReturnType"
-		    quid       	"3B65C1470013"
-		    documentation 	"Get the return type."
-		    result     	"JTypeJavaHelpers"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65ADE403A6")
-		(object Operation "setReturnType"
-		    quid       	"3B65C27403CE"
-		    documentation 	"Set the return type"
-		    parameters 	(list Parameters
-			(object Parameter "type"
-			    quid       	"3C62FAB901E8"
-			    type       	"JTypeJavaHelpers"
-			    quidu      	"3B65ADE403A6"))
-		    result     	"void"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "getSignature"
-		    quid       	"3B65C17D0043"
-		    documentation 	
-|Replicate the functionality of java.lang.reflect.Method.toString().
-|
-|Returns a string describing this Method.  The string is formatted as the method access modifiers, if any, followed by the method return type, followed by a space, followed by the class declaring the method, followed by a period, followed by the method name, followed by a parenthesized, comma-separated list of the method's formal parameter types. If the method throws checked exceptions, the parameter list is followed by a space, followed by the word throws followed by a comma-separated list of the thrown exception types.
-|
-|For example:
-|
-|    public boolean java.lang.Object.equals(java.lang.Object)
-|
-|The access modifiers are placed in canonical order as specified by "The Java Language Specification".  This is public, <tt>protected</tt> or <tt>private</tt> first, and then other modifiers in the following order: <tt>abstract</tt>, <tt>static</tt>, <tt>final</tt>, <tt>synchronized</tt> <tt>native</tt>.
-|
-		    
-		    result     	"String"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "isGenerated"
-		    quid       	"3B65C1FC006E"
-		    documentation 	
-|Returns true if the method is system generated.
-|This is usually determined by the @generated tag in the comment.
-		    
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "setIsGenerated"
-		    quid       	"3B65C244037F"
-		    documentation 	"Set the isGenerated flag."
-		    parameters 	(list Parameters
-			(object Parameter "generated"
-			    quid       	"3C62FAB901EC"
-			    type       	"boolean"))
-		    result     	"void"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "isVoid"
-		    quid       	"3B65C218038F"
-		    documentation 	"Is this a void return type method."
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "abstract"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0011-005d9e6adec4:1")))
-		    quid       	"380F90BC022B"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "native"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0012-005d9e6adec4:1")))
-		    quid       	"380F90D10364"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "synchronized"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0013-005d9e6adec4:1")))
-		    quid       	"380F90DB03C1"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "final"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0014-005d9e6adec4:1")))
-		    quid       	"3829C6E00033"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "constructor"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0015-005d9e6adec4:1")))
-		    quid       	"391ADD280245"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "static"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0016-005d9e6adec4:1")))
-		    quid       	"3829C6E40350"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "javaVisibility"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0017-005d9e6adec4:1")))
-		    quid       	"3829C6EB0397"
-		    type       	"JavaVisibilityKind"
-		    quidu      	"382333BE032E"
-		    exportControl 	"Public"))
-	    language   	"none")
-	(object Class "Field"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0018-005d9e6adec4:1")))
-	    quid       	"3654AF8F0280"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400487F90334"
-		    supplier   	"Logical View::ecore::ETypedElement"
-		    quidu      	"3903D4F60398"))
-	    operations 	(list Operations
-		(object Operation "getContainingJavaClass"
-		    quid       	"3B65B5120024"
-		    documentation 	"Get the class that this field is within."
-		    result     	"JavaClass"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"36549FCC00FA")
-		(object Operation "isArray"
-		    quid       	"3B65B55F01E7"
-		    documentation 	"Is this field an array type."
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "final"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-001d-005d9e6adec4:1")))
-		    quid       	"3829C6BE026F"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "static"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-001e-005d9e6adec4:1")))
-		    quid       	"3829C6C202ED"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "javaVisibility"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-001f-005d9e6adec4:1")))
-		    quid       	"3829C6C7034F"
-		    type       	"JavaVisibilityKind"
-		    quidu      	"382333BE032E"
-		    exportControl 	"Public")
-		(object ClassAttribute "transient"
-		    quid       	"4004880103B8"
-		    type       	"boolean"
-		    exportControl 	"Public")
-		(object ClassAttribute "volatile"
-		    quid       	"40048808012D"
-		    type       	"boolean"
-		    exportControl 	"Public"))
-	    language   	"none")
-	(object Class "TypeKind"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0020-005d9e6adec4:1")))
-	    quid       	"3654B46002BF"
-	    documentation 	"UNDEFINED=1 CLASS=2 INTERFACE=3 EXCEPTION=4"
-	    stereotype 	"enumeration"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "UNDEFINED"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0021-005d9e6adec4:1")))
-		    quid       	"380B9E3601A1"
-		    exportControl 	"Public")
-		(object ClassAttribute "CLASS"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0022-005d9e6adec4:1")))
-		    quid       	"380B9E44025D"
-		    exportControl 	"Public")
-		(object ClassAttribute "INTERFACE"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0023-005d9e6adec4:1")))
-		    quid       	"380B9E560124"
-		    exportControl 	"Public")
-		(object ClassAttribute "EXCEPTION"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0024-005d9e6adec4:1")))
-		    quid       	"380B9E6501A1"
-		    exportControl 	"Public"))
-	    language   	"none")
-	(object Class "Block"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0025-005d9e6adec4:1")))
-	    quid       	"380F88370150"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "source"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0026-005d9e6adec4:1")))
-		    quid       	"3810E7FC0239"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "name"
-		    quid       	"3A6C53E10029"
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "Comment"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0027-005d9e6adec4:1")))
-	    quid       	"380F889B02B8"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0028-005d9e6adec4:1")))
-		    quid       	"380F88D600A5"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150")))
-	(object Class "Statement"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0029-005d9e6adec4:1")))
-	    quid       	"380F88B9025A"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-002a-005d9e6adec4:1")))
-		    quid       	"380F88DA0056"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150")))
-	(object Class "JavaPackage"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-002b-005d9e6adec4:1")))
-	    quid       	"38108E0301D2"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-002c-005d9e6adec4:1")))
-		    quid       	"399094D70046"
-		    supplier   	"Logical View::ecore::EPackage"
-		    quidu      	"3905C3F7000A"))
-	    language   	"Java")
-	(object Class "JavaVisibilityKind"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0030-005d9e6adec4:1")))
-	    quid       	"382333BE032E"
-	    documentation 	
-|PACKAGE=1
-|PUBLIC=2
-|PRIVATE=3
-|PROTECTED=4
-	    
-	    stereotype 	"enumeration"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "PUBLIC"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0031-005d9e6adec4:1")))
-		    quid       	"382333E2022C"
-		    exportControl 	"Public")
-		(object ClassAttribute "PRIVATE"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0032-005d9e6adec4:1")))
-		    quid       	"382333E7003E"
-		    exportControl 	"Public")
-		(object ClassAttribute "PROTECTED"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0033-005d9e6adec4:1")))
-		    quid       	"382333E80389"
-		    exportControl 	"Public")
-		(object ClassAttribute "PACKAGE"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0034-005d9e6adec4:1")))
-		    quid       	"382333EA038C"
-		    exportControl 	"Public")))
-	(object Class "JavaParameterKind"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0035-005d9e6adec4:1")))
-	    quid       	"391C1E8F0123"
-	    documentation 	
-|IN=0
-|OUT=1
-|INOUT=2
-|RETURN=3
-	    
-	    stereotype 	"enumeration"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "IN"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0036-005d9e6adec4:1")))
-		    quid       	"391C1EFC02EC"
-		    exportControl 	"Public")
-		(object ClassAttribute "OUT"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0037-005d9e6adec4:1")))
-		    quid       	"391C1EFF016A"
-		    exportControl 	"Public")
-		(object ClassAttribute "INOUT"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0038-005d9e6adec4:1")))
-		    quid       	"391C1F010040"
-		    exportControl 	"Public")
-		(object ClassAttribute "RETURN"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0039-005d9e6adec4:1")))
-		    quid       	"391C21940387"
-		    exportControl 	"Public")))
-	(object Class "JavaDataType"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-003a-005d9e6adec4:1")))
-	    quid       	"395913340316"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3E5268E201B1"
-		    supplier   	"Logical View::ecore::EClass"
-		    quidu      	"3903D5BF000A"))
-	    operations 	(list Operations
-		(object Operation "getDefaultValueString"
-		    quid       	"3B65BF910303"
-		    documentation 	"Return the default string representing the default value of the primitive."
-		    result     	"String"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)))
-	(object Class "ArrayType"
-	    quid       	"3A9D79ED01DF"
-	    documentation 	
-|Describes a Java Array type
-|   For multi-dimensional arrays, it is unlikely that the component type will be
-|   specified directly.  This would require instantiating a chain of component types
-|   such as String[][][][]->String[][][]->String[][]->String[]->String.
-|
-|  The component type relationship will be computed if the finalComponentType
-|  and array dimensions is specified.
-| 
-|  For this reason, the preferred way to create is through the JavaRefFactory factory method:
-|       createArrayType(JavaClass finalComponentType, int dimensions)
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3A9D79FD010F"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"))
-	    operations 	(list Operations
-		(object Operation "getFinalComponentType"
-		    quid       	"3A9D7A820193"
-		    documentation 	
-|Get the final component type for this Array Type.
-|
-|In order to ensure a unique instance, we will resolve this type using reflection. It turns out to be most efficient to just do this by trimming the name.
-		    
-		    result     	"JTypeJavaHelpers"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65ADE403A6")
-		(object Operation "getComponentTypeAsHelper"
-		    quid       	"3B65AF980136"
-		    documentation 	
-|Get the component type of this array. 
-|
-|If this is a multi-dimensional array, the component type will be the nested array type.
-		    
-		    result     	"JTypeJavaHelpers"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0
-		    quidu      	"3B65ADE403A6")
-		(object Operation "isPrimitiveArray"
-		    quid       	"3B65B41702B8"
-		    documentation 	"Is this an array of java primitives"
-		    result     	"boolean"
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0)
-		(object Operation "setComponentType"
-		    quid       	"3B65B45503BC"
-		    documentation 	"Set the component type."
-		    parameters 	(list Parameters
-			(object Parameter "helperComponentType"
-			    quid       	"3C62FAB90226"
-			    type       	"JTypeJavaHelpers"
-			    quidu      	"3B65ADE403A6"))
-		    concurrency 	"Sequential"
-		    opExportControl 	"Public"
-		    uid        	0))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "arrayDimensions"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Java"
-			    name       	"Final"
-			    value      	FALSE)
-			(object Attribute
-			    tool       	"Java"
-			    name       	"Volatile"
-			    value      	FALSE)
-			(object Attribute
-			    tool       	"Java"
-			    name       	"Transient"
-			    value      	FALSE)
-			(object Attribute
-			    tool       	"Java"
-			    name       	"IndividualChangeMgt"
-			    value      	FALSE)
-			(object Attribute
-			    tool       	"Java"
-			    name       	"PropertyType"
-			    value      	("BeanProperty_Set" 71))
-			(object Attribute
-			    tool       	"Java"
-			    name       	"Read/Write"
-			    value      	("Read/Write_Set" 81)))
-		    quid       	"3A9D7AC80284"
-		    type       	"int"
-		    exportControl 	"Public"))
-	    language   	"Java")
-	(object Class "JTypeJavaHelpers"
-	    quid       	"3B65ADE403A6"
-	    documentation 	"This interface is a common interface between JavaClass and JavaDataType plus some common helper methods."
-	    stereotype 	"datatype"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "org.eclipse.jem.java.JavaHelpers"
-		    quid       	"3B65AE170269"
-		    stereotype 	"javaclass"
-		    exportControl 	"Public")))
-	(object Class "JTypeList"
-	    quid       	"3B65B87602C1"
-	    documentation 	"java.util.List type"
-	    stereotype 	"datatype"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "java.util.List"
-		    quid       	"3B65B88F0399"
-		    stereotype 	"javaclass"
-		    exportControl 	"Public")))
-	(object Class "JavaEvent"
-	    quid       	"3C62FAF103C8"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3DF4CE830390"
-		    supplier   	"Logical View::ecore::EStructuralFeature"
-		    quidu      	"3903D59D0230"))
-	    abstract   	TRUE)
-	(object Association "Implements"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-003c-005d9e6adec4:1")))
-	    quid       	"3654A0D70242"
-	    documentation 	"Constraint - Source of implements is of TypeKind CLASSTYPE and target is INTERFACETYPE"
-	    roles      	(list role_list
-		(object Role "implementsInterfaces"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-003d-005d9e6adec4:1")))
-		    quid       	"3654A0DA0109"
-		    label      	"implementsInterfaces"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    is_navigable 	TRUE)
-		(object Role "implementedBy"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-003e-005d9e6adec4:1")))
-		    quid       	"3654A0DA0138"
-		    label      	"implementedBy"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n"))))
-	(object Association "MethodHas"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-003f-005d9e6adec4:1")))
-	    quid       	"3654AF0302CE"
-	    roles      	(list role_list
-		(object Role "parameters"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0040-005d9e6adec4:1")))
-		    quid       	"3654AF080196"
-		    label      	"parameters"
-		    supplier   	"Logical View::java::JavaParameter"
-		    quidu      	"3654AD780280"
-		    client_cardinality 	(value cardinality "0..n")
-		    Constraints 	"ordered"
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "method"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0041-005d9e6adec4:1")))
-		    quid       	"3654AF080197"
-		    label      	"method"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$0"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0042-005d9e6adec4:1")))
-	    quid       	"3654B08801A5"
-	    roles      	(list role_list
-		(object Role "/type"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0043-005d9e6adec4:1")))
-		    quid       	"3654B091007D"
-		    label      	"/type"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    is_navigable 	TRUE)
-		(object Role "/typedElement"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0044-005d9e6adec4:1")))
-		    quid       	"3654B091008C"
-		    label      	"/typedElement"
-		    supplier   	"Logical View::java::JavaParameter"
-		    quidu      	"3654AD780280"
-		    client_cardinality 	(value cardinality "1"))))
-	(object Association "MethodThrows"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0045-005d9e6adec4:1")))
-	    quid       	"3810B61B0178"
-	    documentation 	"Target must be of kind EXCEPTIONTYPE"
-	    roles      	(list role_list
-		(object Role "javaExceptions"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0046-005d9e6adec4:1")))
-		    quid       	"3810B61E01C3"
-		    label      	"javaExceptions"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    is_navigable 	TRUE)
-		(object Role "method"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0047-005d9e6adec4:1")))
-		    quid       	"3810B61E0227"
-		    label      	"method"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271")))
-	(object Association "Contents"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0048-005d9e6adec4:1")))
-	    quid       	"3810E6080268"
-	    roles      	(list role_list
-		(object Role "containedBy"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0049-005d9e6adec4:1")))
-		    quid       	"3810E60E0144"
-		    label      	"containedBy"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_aggregate 	TRUE)
-		(object Role "contents"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-004a-005d9e6adec4:1")))
-		    quid       	"3810E60E0162"
-		    label      	"contents"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)))
-	(object Association "ClassImports"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-004b-005d9e6adec4:1")))
-	    quid       	"3829C4BF000D"
-	    roles      	(list role_list
-		(object Role "classImport"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-004c-005d9e6adec4:1")))
-		    quid       	"3829C4BF000E"
-		    label      	"classImport"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    Constraints 	"ordered"
-		    is_navigable 	TRUE)
-		(object Role "importedBy"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-004d-005d9e6adec4:1")))
-		    quid       	"3829C4BF000F"
-		    label      	"importedBy"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n"))))
-	(object Association "PackageImports"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-004e-005d9e6adec4:1")))
-	    quid       	"3829C4EC0207"
-	    roles      	(list role_list
-		(object Role "packageImports"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-004f-005d9e6adec4:1")))
-		    quid       	"3829C4EE00FB"
-		    label      	"packageImports"
-		    supplier   	"Logical View::java::JavaPackage"
-		    quidu      	"38108E0301D2"
-		    client_cardinality 	(value cardinality "0..n")
-		    Constraints 	"ordered"
-		    is_navigable 	TRUE)
-		(object Role "importedBy"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0050-005d9e6adec4:1")))
-		    quid       	"3829C4EE0105"
-		    label      	"importedBy"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n"))))
-	(object Association "$UNNAMED$1"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0051-005d9e6adec4:1")))
-	    quid       	"382A29BD0219"
-	    roles      	(list role_list
-		(object Role "fields"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0052-005d9e6adec4:1")))
-		    quid       	"382A29BE0350"
-		    label      	"fields"
-		    supplier   	"Logical View::java::Field"
-		    quidu      	"3654AF8F0280"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "javaClass"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0053-005d9e6adec4:1")))
-		    quid       	"382A29BE03BF"
-		    label      	"javaClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    is_navigable 	TRUE
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$2"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0054-005d9e6adec4:1")))
-	    quid       	"382A29C0017D"
-	    roles      	(list role_list
-		(object Role "methods"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0055-005d9e6adec4:1")))
-		    quid       	"382A29C10174"
-		    label      	"methods"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "javaClass"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0056-005d9e6adec4:1")))
-		    quid       	"382A29C1020A"
-		    label      	"javaClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    is_navigable 	TRUE
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$3"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0057-005d9e6adec4:1")))
-	    quid       	"392A9EB403C6"
-	    roles      	(list role_list
-		(object Role "/supertype"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0058-005d9e6adec4:1")))
-		    quid       	"392A9EB803B7"
-		    label      	"/supertype"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "1")
-		    is_navigable 	TRUE)
-		(object Role "/subtype"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0059-005d9e6adec4:1")))
-		    quid       	"392A9EB90098"
-		    label      	"/subtype"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n"))))
-	(object Association "$UNNAMED$4"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-005a-005d9e6adec4:1")))
-	    quid       	"392A9F0301AC"
-	    roles      	(list role_list
-		(object Role "/supertype"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-005b-005d9e6adec4:1")))
-		    quid       	"392A9F090328"
-		    label      	"/supertype"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    is_navigable 	TRUE)
-		(object Role "/subtype"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-005c-005d9e6adec4:1")))
-		    quid       	"392A9F0A001C"
-		    label      	"/subtype"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    is_navigable 	TRUE)))
-	(object Association "$UNNAMED$5"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-005d-005d9e6adec4:1")))
-	    quid       	"392AA09503E5"
-	    roles      	(list role_list
-		(object Role "initializers"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-005e-005d9e6adec4:1")))
-		    quid       	"392AA0970153"
-		    label      	"initializers"
-		    supplier   	"Logical View::java::Initializer"
-		    quidu      	"3654A5DC00BB"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "javaClass"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-005f-005d9e6adec4:1")))
-		    quid       	"392AA097015D"
-		    label      	"javaClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    is_navigable 	TRUE
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$6"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0060-005d9e6adec4:1")))
-	    quid       	"392AA21200C2"
-	    roles      	(list role_list
-		(object Role "declaredClasses"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0061-005d9e6adec4:1")))
-		    quid       	"392AA21701D8"
-		    label      	"declaredClasses"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    is_navigable 	TRUE)
-		(object Role "declaringClass"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0062-005d9e6adec4:1")))
-		    quid       	"392AA21702DC"
-		    label      	"declaringClass"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_navigable 	TRUE
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$7"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0063-005d9e6adec4:1")))
-	    quid       	"392AA2A701C1"
-	    stereotype 	"derived"
-	    roles      	(list role_list
-		(object Role "javaClasses"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0064-005d9e6adec4:1"))
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isVolatile"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isChangeable"
-			    value      	FALSE))
-		    quid       	"392AA2A80367"
-		    label      	"javaClasses"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    client_cardinality 	(value cardinality "0..n")
-		    is_navigable 	TRUE)
-		(object Role "javaPackage"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0065-005d9e6adec4:1"))
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isVolatile"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isChangeable"
-			    value      	FALSE))
-		    quid       	"392AA2A90083"
-		    label      	"javaPackage"
-		    supplier   	"Logical View::java::JavaPackage"
-		    quidu      	"38108E0301D2"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_navigable 	TRUE
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$8"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0066-005d9e6adec4:1")))
-	    quid       	"392AAC33036A"
-	    roles      	(list role_list
-		(object Role "source"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0067-005d9e6adec4:1")))
-		    quid       	"392AAC380140"
-		    label      	"source"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_navigable 	TRUE)
-		(object Role "initializer"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-0068-005d9e6adec4:1")))
-		    quid       	"392AAC380168"
-		    label      	"initializer"
-		    supplier   	"Logical View::java::Initializer"
-		    quidu      	"3654A5DC00BB")))
-	(object Association "$UNNAMED$9"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-0069-005d9e6adec4:1")))
-	    quid       	"392AAC5602A2"
-	    roles      	(list role_list
-		(object Role "initializer"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-006a-005d9e6adec4:1")))
-		    quid       	"392AAC5702DF"
-		    label      	"initializer"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150"
-		    client_cardinality 	(value cardinality "0..1")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "field"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c74525a0-8826-11e1-006b-005d9e6adec4:1")))
-		    quid       	"392AAC570307"
-		    label      	"field"
-		    supplier   	"Logical View::java::Field"
-		    quidu      	"3654AF8F0280"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$10"
-	    attributes 	(list Attribute_Set
-		(object Attribute
-		    tool       	"IDL"
-		    name       	"uuid"
-		    value      	(value Text "DCE:c74525a0-8826-11e1-006c-005d9e6adec4:1")))
-	    quid       	"392AACA501E7"
-	    roles      	(list role_list
-		(object Role "source"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c746ac40-8826-11e1-0000-005d9e6adec4:1")))
-		    quid       	"392AACA7017C"
-		    label      	"source"
-		    supplier   	"Logical View::java::Block"
-		    quidu      	"380F88370150"
-		    client_cardinality 	(value cardinality "0..1")
-		    is_navigable 	TRUE)
-		(object Role "method"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"IDL"
-			    name       	"uuid"
-			    value      	(value Text "DCE:c746ac40-8826-11e1-0001-005d9e6adec4:1")))
-		    quid       	"392AACA701B8"
-		    label      	"method"
-		    supplier   	"Logical View::java::Method"
-		    quidu      	"3654AE910271")))
-	(object Association "$UNNAMED$11"
-	    quid       	"3C62FBE00168"
-	    roles      	(list role_list
-		(object Role "events"
-		    quid       	"3C62FBE2008F"
-		    label      	"events"
-		    supplier   	"Logical View::java::JavaEvent"
-		    quidu      	"3C62FAF103C8"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$12"
-		    quid       	"3C62FBE20091"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$13"
-	    quid       	"3C8938770253"
-	    roles      	(list role_list
-		(object Role "allEvents"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE)
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isVolatile"
-			    value      	TRUE))
-		    quid       	"3C89387802CC"
-		    label      	"allEvents"
-		    supplier   	"Logical View::java::JavaEvent"
-		    quidu      	"3C62FAF103C8"
-		    client_cardinality 	(value cardinality "0..n")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$14"
-		    quid       	"3C89387802CE"
-		    supplier   	"Logical View::java::JavaClass"
-		    quidu      	"36549FCC00FA"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$15"
-	    quid       	"3DF4CAAD01A3"
-	    roles      	(list role_list
-		(object Role "componentType"
-		    quid       	"3DF4CAAE01EB"
-		    label      	"componentType"
-		    supplier   	"Logical View::ecore::EClassifier"
-		    quidu      	"3ACE4FEE0371"
-		    client_cardinality 	(value cardinality "1")
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$16"
-		    quid       	"3DF4CAAE01F5"
-		    supplier   	"Logical View::java::ArrayType"
-		    quidu      	"3A9D79ED01DF"))))
-    logical_presentations 	(list unit_reference_list
-	(object ClassDiagram "Ecore binding"
-	    quid       	"38109C0F009B"
-	    title      	"Ecore binding"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	4094
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::java::Field" @1
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(1104, 576)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@1
-			location   	(689, 368)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	830
-			justify    	0
-			label      	"Field")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AF8F0280"
-		    compartment 	(object Compartment
-			Parent_View 	@1
-			location   	(689, 424)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	8
-			max_width  	709)
-		    width      	848
-		    height     	438
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaPackage" @2
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(192, 480)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@2
-			location   	(31, 434)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	322
-			justify    	0
-			label      	"JavaPackage")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"38108E0301D2"
-		    width      	340
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::ecore::EPackage" @3
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(192, 144)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@3
-			location   	(103, 45)
-			nlines     	2
-			max_width  	178
-			justify    	0
-			label      	"EPackage")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3905C3F7000A"
-		    width      	196
-		    height     	222
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @4
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"399094D70046"
-		    client     	@2
-		    supplier   	@3
-		    line_style 	0)
-		(object ClassView "Class" "Logical View::ecore::EClass" @5
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1728, 1824)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@5
-			location   	(1465, 1615)
-			nlines     	2
-			max_width  	526
-			justify    	0
-			label      	"EClass")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3903D5BF000A"
-		    compartment 	(object Compartment
-			Parent_View 	@5
-			location   	(1465, 1715)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			anchor     	2
-			nlines     	6
-			max_width  	452)
-		    width      	544
-		    height     	440
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::ecore::EOperation" @6
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2320, 144)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@6
-			location   	(2231, 45)
-			nlines     	2
-			max_width  	178
-			justify    	0
-			label      	"EOperation")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3904DAA200A0"
-		    width      	196
-		    height     	222
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaDataType" @7
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(352, 1216)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@7
-			location   	(11, 1143)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	682
-			justify    	0
-			label      	"JavaDataType")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"395913340316"
-		    compartment 	(object Compartment
-			Parent_View 	@7
-			location   	(11, 1199)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	585)
-		    width      	700
-		    height     	168
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Method" @8
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(2336, 768)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@8
-			location   	(1736, 357)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1200
-			justify    	0
-			label      	"Method")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AE910271"
-		    compartment 	(object Compartment
-			Parent_View 	@8
-			location   	(1736, 413)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	17
-			max_width  	1027)
-		    width      	1218
-		    height     	844
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @9
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3990953803AD"
-		    client     	@8
-		    supplier   	@6
-		    line_style 	3
-		    origin_attachment 	(2376, 346)
-		    terminal_attachment 	(2376, 255))
-		(object ClassView "Class" "Logical View::java::JavaClass" @10
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(1312, 2864)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@10
-			location   	(330, 2273)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1964
-			justify    	0
-			label      	"JavaClass")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"36549FCC00FA"
-		    compartment 	(object Compartment
-			Parent_View 	@10
-			location   	(330, 2329)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	25
-			max_width  	1680)
-		    width      	1982
-		    height     	1204
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @11
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3990950000B3"
-		    client     	@10
-		    supplier   	@5
-		    line_style 	3
-		    origin_attachment 	(1594, 2262)
-		    terminal_attachment 	(1594, 2044))
-		(object ClassView "Class" "Logical View::java::JavaParameter" @12
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(1008, 1472)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@12
-			location   	(608, 1286)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	800
-			justify    	0
-			label      	"JavaParameter")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AD780280"
-		    compartment 	(object Compartment
-			Parent_View 	@12
-			location   	(608, 1342)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	7
-			max_width  	685)
-		    width      	818
-		    height     	394
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::ecore::EParameter" @13
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1008, 960)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@13
-			location   	(919, 861)
-			nlines     	2
-			max_width  	178
-			justify    	0
-			label      	"EParameter")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3903E6150104"
-		    width      	196
-		    height     	222
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @14
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3B7818B00186"
-		    client     	@12
-		    supplier   	@13
-		    line_style 	0)
-		(object ClassView "Class" "Logical View::ecore::EClass" @15
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(320, 816)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@15
-			location   	(56, 630)
-			nlines     	1
-			max_width  	528
-			justify    	0
-			label      	"EClass")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3903D5BF000A"
-		    compartment 	(object Compartment
-			Parent_View 	@15
-			location   	(56, 730)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			anchor     	2
-			nlines     	6
-			max_width  	452)
-		    width      	546
-		    height     	394
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @16
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3E5268E201B1"
-		    client     	@7
-		    supplier   	@15
-		    line_style 	0)
-		(object ClassView "Class" "Logical View::ecore::ETypedElement" @17
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1104, 112)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@17
-			location   	(916, 41)
-			nlines     	1
-			max_width  	376
-			justify    	0
-			label      	"ETypedElement")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3903D4F60398"
-		    width      	394
-		    height     	164
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @18
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400487F90334"
-		    client     	@1
-		    supplier   	@17
-		    line_style 	0)))
-	(object ClassDiagram "Polymorphism"
-	    quid       	"38109D000373"
-	    title      	"Polymorphism"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	0
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::java::JavaClass" @19
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(496, 576)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@19
-			location   	(365, 530)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	262
-			justify    	0
-			label      	"JavaClass")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"36549FCC00FA"
-		    width      	280
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "$UNNAMED$3" @20
-		    location   	(166, 537)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392A9EB403C6"
-		    roleview_list 	(list RoleViews
-			(object RoleView "/supertype" @21
-			    Parent_View 	@20
-			    location   	(-330, 217)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @22
-				Parent_View 	@21
-				location   	(234, 480)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	226
-				justify    	0
-				label      	"+/supertype"
-				pctDist    	0.419192
-				height     	38
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392A9EB803B7"
-			    client     	@20
-			    supplier   	@19
-			    vertices   	(list Points
-				(166, 537)
-				(166, 517)
-				(356, 517))
-			    line_style 	3
-			    origin_attachment 	(166, 537)
-			    terminal_attachment 	(356, 517)
-			    label      	(object SegLabel @23
-				Parent_View 	@21
-				location   	(334, 464)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "/subtype" @24
-			    Parent_View 	@20
-			    location   	(-330, 217)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @25
-				Parent_View 	@24
-				location   	(257, 582)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	188
-				justify    	0
-				label      	"+/subtype"
-				pctDist    	0.532468
-				height     	24
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392A9EB90098"
-			    client     	@20
-			    supplier   	@19
-			    vertices   	(list Points
-				(166, 537)
-				(166, 558)
-				(356, 558))
-			    line_style 	3
-			    origin_attachment 	(166, 537)
-			    terminal_attachment 	(356, 558)
-			    label      	(object SegLabel @26
-				Parent_View 	@24
-				location   	(334, 612)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1))))
-		(object ClassView "Class" "Logical View::java::JavaClass" @27
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(1392, 576)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@27
-			location   	(1261, 530)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	262
-			justify    	0
-			label      	"JavaClass")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"36549FCC00FA"
-		    width      	280
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "Implements" @28
-		    location   	(944, 521)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3654A0D70242"
-		    roleview_list 	(list RoleViews
-			(object RoleView "implementsInterfaces" @29
-			    Parent_View 	@28
-			    location   	(430, -54)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @30
-				Parent_View 	@29
-				location   	(839, 488)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	407
-				justify    	0
-				label      	"+implementsInterfaces"
-				pctDist    	-0.343558
-				height     	34
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3654A0DA0109"
-			    client     	@28
-			    supplier   	@27
-			    line_style 	3
-			    origin_attachment 	(944, 521)
-			    terminal_attachment 	(1252, 521)
-			    label      	(object SegLabel @31
-				Parent_View 	@29
-				location   	(1181, 485)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.773006
-				height     	37
-				orientation 	0))
-			(object RoleView "implementedBy" @32
-			    Parent_View 	@28
-			    location   	(430, -54)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @33
-				Parent_View 	@32
-				location   	(1087, 575)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	312
-				justify    	0
-				label      	"+implementedBy"
-				pctDist    	-0.470769
-				height     	54
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3654A0DA0138"
-			    client     	@28
-			    supplier   	@19
-			    line_style 	3
-			    origin_attachment 	(944, 521)
-			    terminal_attachment 	(636, 521)
-			    label      	(object SegLabel @34
-				Parent_View 	@32
-				location   	(684, 564)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.843230
-				height     	43
-				orientation 	0))))
-		(object AssociationViewNew "$UNNAMED$4" @35
-		    location   	(1750, 601)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392A9F0301AC"
-		    roleview_list 	(list RoleViews
-			(object RoleView "/supertype" @36
-			    Parent_View 	@35
-			    location   	(358, 265)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @37
-				Parent_View 	@36
-				location   	(1721, 640)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	226
-				justify    	0
-				label      	"+/supertype"
-				pctDist    	0.227273
-				height     	13
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392A9F090328"
-			    client     	@35
-			    supplier   	@27
-			    vertices   	(list Points
-				(1750, 601)
-				(1750, 627)
-				(1532, 627))
-			    line_style 	3
-			    origin_attachment 	(1750, 601)
-			    terminal_attachment 	(1532, 627)
-			    label      	(object SegLabel @38
-				Parent_View 	@36
-				location   	(1557, 574)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1))
-			(object RoleView "/subtype" @39
-			    Parent_View 	@35
-			    location   	(358, 265)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @40
-				Parent_View 	@39
-				location   	(1626, 553)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	188
-				justify    	0
-				label      	"+/subtype"
-				pctDist    	0.615970
-				height     	24
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392A9F0A001C"
-			    client     	@35
-			    supplier   	@27
-			    vertices   	(list Points
-				(1750, 601)
-				(1750, 576)
-				(1532, 576))
-			    line_style 	3
-			    origin_attachment 	(1750, 601)
-			    terminal_attachment 	(1532, 576)
-			    label      	(object SegLabel @41
-				Parent_View 	@39
-				location   	(1557, 630)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))))))
-	(object ClassDiagram "Main"
-	    quid       	"38109F92000B"
-	    title      	"Main"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	2760
-	    items      	(list diagram_item_list
-		(object NoteView @42
-		    location   	(848, 1840)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@42
-			location   	(551, 1718)
-			fill_color 	13434879
-			nlines     	4
-			max_width  	559
-			label      	"This should really be JavaClass and JavaDataType, eClassifier is their closest common ancestor.")
-		    line_color 	3342489
-		    fill_color 	8421631
-		    width      	619
-		    height     	256)
-		(object NoteView @43
-		    location   	(272, 320)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@43
-			location   	(107, 166)
-			fill_color 	13434879
-			nlines     	6
-			max_width  	295
-			label      	"The classes will be contained by the standard EPackage metaObjects relationship.")
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	355
-		    height     	320)
-		(object ClassView "Class" "Logical View::java::Field" @44
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(1776, 480)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@44
-			location   	(1680, 434)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	192
-			justify    	0
-			label      	"Field")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AF8F0280"
-		    width      	210
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Initializer" @45
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1568, 224)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@45
-			location   	(1363, 151)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	410
-			justify    	0
-			label      	"Initializer")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654A5DC00BB"
-		    compartment 	(object Compartment
-			Parent_View 	@45
-			location   	(1363, 207)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	345)
-		    width      	428
-		    height     	168
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaPackage" @46
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(608, 96)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@46
-			location   	(447, 50)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	322
-			justify    	0
-			label      	"JavaPackage")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"38108E0301D2"
-		    width      	340
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaParameter" @47
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    location   	(1744, 1584)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@47
-			location   	(1344, 1488)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	800
-			justify    	0
-			label      	"JavaParameter")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AD780280"
-		    compartment 	(object Compartment
-			Parent_View 	@47
-			location   	(1344, 1544)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	3
-			max_width  	678)
-		    width      	818
-		    height     	214
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Method" @48
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(1712, 992)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@48
-			location   	(1613, 946)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	198
-			justify    	0
-			label      	"Method")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AE910271"
-		    width      	216
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "MethodHas" @49
-		    location   	(1700, 1262)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3654AF0302CE"
-		    roleview_list 	(list RoleViews
-			(object RoleView "method" @50
-			    Parent_View 	@49
-			    location   	(308, 238)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3654AF080197"
-			    client     	@49
-			    supplier   	@48
-			    line_style 	3
-			    origin_attachment 	(1700, 1262)
-			    terminal_attachment 	(1700, 1049)
-			    label      	(object SegLabel @51
-				Parent_View 	@50
-				location   	(1633, 1097)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.781659
-				height     	68
-				orientation 	0))
-			(object RoleView "parameters" @52
-			    Parent_View 	@49
-			    location   	(308, 238)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @53
-				Parent_View 	@52
-				location   	(1837, 1433)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	235
-				justify    	0
-				label      	"+parameters"
-				pctDist    	0.803565
-				height     	137
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3654AF080196"
-			    client     	@49
-			    supplier   	@47
-			    line_style 	3
-			    origin_attachment 	(1700, 1262)
-			    terminal_attachment 	(1700, 1476)
-			    label      	(object SegLabel @54
-				Parent_View 	@52
-				location   	(1636, 1456)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.905128
-				height     	65
-				orientation 	1)
-			    label      	(object SegLabel @55
-				Parent_View 	@52
-				location   	(1592, 1397)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	3
-				anchor_loc 	1
-				nlines     	1
-				max_width  	159
-				justify    	0
-				label      	"{ordered}"
-				pctDist    	0.628821
-				height     	109
-				orientation 	1))))
-		(object ClassView "Class" "Logical View::java::JavaEvent" @56
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(2192, 656)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@56
-			location   	(2064, 607)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	256
-			justify    	0
-			label      	"JavaEvent")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3C62FAF103C8"
-		    width      	274
-		    height     	122
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaClass" @57
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    location   	(560, 672)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@57
-			location   	(374, 554)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	372
-			justify    	0
-			label      	"JavaClass")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"36549FCC00FA"
-		    compartment 	(object Compartment
-			Parent_View 	@57
-			location   	(374, 610)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	4
-			max_width  	313)
-		    width      	390
-		    height     	258
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "$UNNAMED$1" @58
-		    location   	(1213, 538)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"382A29BD0219"
-		    roleview_list 	(list RoleViews
-			(object RoleView "fields" @59
-			    Parent_View 	@58
-			    location   	(733, 282)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @60
-				Parent_View 	@59
-				location   	(1511, 513)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	192
-				justify    	0
-				label      	"+fields"
-				pctDist    	0.653017
-				height     	26
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"382A29BE0350"
-			    client     	@58
-			    supplier   	@44
-			    line_style 	3
-			    origin_attachment 	(1213, 538)
-			    terminal_attachment 	(1671, 538)
-			    label      	(object SegLabel @61
-				Parent_View 	@59
-				location   	(1624, 485)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "javaClass" @62
-			    Parent_View 	@58
-			    location   	(733, 282)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"382A29BE03BF"
-			    client     	@58
-			    supplier   	@57
-			    line_style 	3
-			    origin_attachment 	(1213, 538)
-			    terminal_attachment 	(755, 538))))
-		(object AssociationViewNew "$UNNAMED$5" @63
-		    location   	(916, 307)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392AA09503E5"
-		    roleview_list 	(list RoleViews
-			(object RoleView "initializers" @64
-			    Parent_View 	@63
-			    location   	(276, 99)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @65
-				Parent_View 	@64
-				location   	(1096, 216)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	212
-				justify    	0
-				label      	"+initializers"
-				pctDist    	0.410719
-				height     	92
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AA0970153"
-			    client     	@63
-			    supplier   	@45
-			    line_style 	3
-			    origin_attachment 	(916, 307)
-			    terminal_attachment 	(1354, 307)
-			    label      	(object SegLabel @66
-				Parent_View 	@64
-				location   	(1345, 368)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.979687
-				height     	61
-				orientation 	1))
-			(object RoleView "javaClass" @67
-			    Parent_View 	@63
-			    location   	(276, 99)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AA097015D"
-			    client     	@63
-			    supplier   	@57
-			    vertices   	(list Points
-				(916, 307)
-				(713, 307)
-				(713, 543))
-			    line_style 	3
-			    origin_attachment 	(916, 307)
-			    terminal_attachment 	(713, 543))))
-		(object AssociationViewNew "$UNNAMED$6" @68
-		    location   	(206, 642)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392AA21200C2"
-		    roleview_list 	(list RoleViews
-			(object RoleView "declaredClasses" @69
-			    Parent_View 	@68
-			    location   	(-578, 274)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @70
-				Parent_View 	@69
-				location   	(240, 582)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	325
-				justify    	0
-				label      	"+declaredClasses"
-				pctDist    	0.343195
-				height     	31
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AA21701D8"
-			    client     	@68
-			    supplier   	@57
-			    vertices   	(list Points
-				(206, 642)
-				(206, 612)
-				(365, 612))
-			    line_style 	3
-			    origin_attachment 	(206, 642)
-			    terminal_attachment 	(365, 612)
-			    label      	(object SegLabel @71
-				Parent_View 	@69
-				location   	(347, 556)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.902367
-				height     	57
-				orientation 	0))
-			(object RoleView "declaringClass" @72
-			    Parent_View 	@68
-			    location   	(-578, 274)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @73
-				Parent_View 	@72
-				location   	(258, 675)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	298
-				justify    	0
-				label      	"+declaringClass"
-				pctDist    	0.434286
-				height     	3
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AA21702DC"
-			    client     	@68
-			    supplier   	@57
-			    vertices   	(list Points
-				(206, 642)
-				(206, 672)
-				(365, 672))
-			    line_style 	3
-			    origin_attachment 	(206, 642)
-			    terminal_attachment 	(365, 672)
-			    label      	(object SegLabel @74
-				Parent_View 	@72
-				location   	(345, 726)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1))))
-		(object AssociationViewNew "$UNNAMED$7" @75
-		    location   	(603, 347)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	(object SegLabel @76
-			Parent_View 	@75
-			location   	(603, 228)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			anchor     	10
-			anchor_loc 	1
-			nlines     	1
-			max_width  	450
-			justify    	0
-			label      	"<<derived>>"
-			pctDist    	0.500000
-			height     	120
-			orientation 	0)
-		    line_color 	3342489
-		    quidu      	"392AA2A701C1"
-		    roleview_list 	(list RoleViews
-			(object RoleView "javaClasses" @77
-			    Parent_View 	@75
-			    location   	(27, 219)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @78
-				Parent_View 	@77
-				location   	(720, 419)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	248
-				justify    	0
-				label      	"+javaClasses"
-				pctDist    	0.367521
-				height     	117
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AA2A80367"
-			    client     	@75
-			    supplier   	@57
-			    line_style 	3
-			    origin_attachment 	(603, 347)
-			    terminal_attachment 	(603, 543)
-			    label      	(object SegLabel @79
-				Parent_View 	@77
-				location   	(657, 522)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "javaPackage" @80
-			    Parent_View 	@75
-			    location   	(27, 219)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @81
-				Parent_View 	@80
-				location   	(482, 179)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	263
-				justify    	0
-				label      	"+javaPackage"
-				pctDist    	0.862903
-				height     	122
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AA2A90083"
-			    client     	@75
-			    supplier   	@46
-			    line_style 	3
-			    origin_attachment 	(603, 347)
-			    terminal_attachment 	(603, 152)
-			    label      	(object SegLabel @82
-				Parent_View 	@80
-				location   	(657, 172)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1))))
-		(object AttachView "" @83
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@43
-		    supplier   	@75
-		    line_style 	0)
-		(object AssociationViewNew "$UNNAMED$0" @84
-		    location   	(616, 1524)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object SegLabel @85
-			Parent_View 	@84
-			location   	(616, 1465)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	TRUE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			hidden     	TRUE
-			anchor     	1
-			anchor_loc 	1
-			nlines     	1
-			max_width  	600
-			justify    	0
-			label      	""
-			pctDist    	0.500000
-			height     	60
-			orientation 	0)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3654B08801A5"
-		    roleview_list 	(list RoleViews
-			(object RoleView "/typedElement" @86
-			    Parent_View 	@84
-			    location   	(56, 948)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3654B091008C"
-			    client     	@84
-			    supplier   	@47
-			    vertices   	(list Points
-				(616, 1524)
-				(616, 1584)
-				(1335, 1584))
-			    line_style 	3
-			    origin_attachment 	(616, 1524)
-			    terminal_attachment 	(1335, 1584)
-			    label      	(object SegLabel @87
-				Parent_View 	@86
-				location   	(1256, 1531)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "/type" @88
-			    Parent_View 	@84
-			    location   	(56, 948)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @89
-				Parent_View 	@88
-				location   	(697, 1099)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	116
-				justify    	0
-				label      	"+/type"
-				pctDist    	0.588161
-				height     	81
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3654B091007D"
-			    client     	@84
-			    supplier   	@57
-			    line_style 	3
-			    origin_attachment 	(616, 1524)
-			    terminal_attachment 	(616, 801))))
-		(object AssociationViewNew "$UNNAMED$2" @90
-		    location   	(1088, 961)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"382A29C0017D"
-		    roleview_list 	(list RoleViews
-			(object RoleView "methods" @91
-			    Parent_View 	@90
-			    location   	(608, 705)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @92
-				Parent_View 	@91
-				location   	(1409, 889)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	192
-				justify    	0
-				label      	"+methods"
-				pctDist    	0.624023
-				height     	73
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"382A29C10174"
-			    client     	@90
-			    supplier   	@48
-			    line_style 	3
-			    origin_attachment 	(1088, 961)
-			    terminal_attachment 	(1604, 961)
-			    label      	(object SegLabel @93
-				Parent_View 	@91
-				location   	(1483, 1017)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.766040
-				height     	56
-				orientation 	1))
-			(object RoleView "javaClass" @94
-			    Parent_View 	@90
-			    location   	(608, 705)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"382A29C1020A"
-			    client     	@90
-			    supplier   	@57
-			    vertices   	(list Points
-				(1088, 961)
-				(732, 961)
-				(732, 801))
-			    line_style 	3
-			    origin_attachment 	(1088, 961)
-			    terminal_attachment 	(732, 801))))
-		(object AssociationViewNew "MethodThrows" @95
-		    location   	(1047, 981)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3810B61B0178"
-		    roleview_list 	(list RoleViews
-			(object RoleView "method" @96
-			    Parent_View 	@95
-			    location   	(487, 405)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3810B61E0227"
-			    client     	@95
-			    supplier   	@48
-			    line_style 	3
-			    origin_attachment 	(1047, 981)
-			    terminal_attachment 	(1604, 981))
-			(object RoleView "javaExceptions" @97
-			    Parent_View 	@95
-			    location   	(487, 405)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @98
-				Parent_View 	@97
-				location   	(733, 945)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	312
-				justify    	0
-				label      	"+javaExceptions"
-				pctDist    	0.563664
-				height     	37
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3810B61E01C3"
-			    client     	@95
-			    supplier   	@57
-			    vertices   	(list Points
-				(1047, 981)
-				(669, 981)
-				(669, 801))
-			    line_style 	3
-			    origin_attachment 	(1047, 981)
-			    terminal_attachment 	(669, 801)
-			    label      	(object SegLabel @99
-				Parent_View 	@97
-				location   	(723, 857)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1))))
-		(object AssociationViewNew "$UNNAMED$11" @100
-		    location   	(1541, 806)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3C62FBE00168"
-		    roleview_list 	(list RoleViews
-			(object RoleView "events" @101
-			    Parent_View 	@100
-			    location   	(981, 134)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @102
-				Parent_View 	@101
-				location   	(2169, 765)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	144
-				justify    	0
-				label      	"+events"
-				pctDist    	0.800000
-				height     	42
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3C62FBE2008F"
-			    client     	@100
-			    supplier   	@56
-			    vertices   	(list Points
-				(1541, 806)
-				(2238, 806)
-				(2238, 717))
-			    line_style 	3
-			    origin_attachment 	(1541, 806)
-			    terminal_attachment 	(2238, 717)
-			    label      	(object SegLabel @103
-				Parent_View 	@101
-				location   	(2292, 796)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1))
-			(object RoleView "$UNNAMED$12" @104
-			    Parent_View 	@100
-			    location   	(981, 134)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3C62FBE20091"
-			    client     	@100
-			    supplier   	@57
-			    line_style 	3
-			    origin_attachment 	(1541, 806)
-			    terminal_attachment 	(755, 806))))
-		(object AssociationViewNew "$UNNAMED$13" @105
-		    location   	(1405, 663)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3C8938770253"
-		    roleview_list 	(list RoleViews
-			(object RoleView "allEvents" @106
-			    Parent_View 	@105
-			    location   	(845, -9)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @107
-				Parent_View 	@106
-				location   	(1925, 622)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	193
-				justify    	0
-				label      	"+allEvents"
-				pctDist    	0.800000
-				height     	42
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3C89387802CC"
-			    client     	@105
-			    supplier   	@56
-			    line_style 	3
-			    origin_attachment 	(1405, 663)
-			    terminal_attachment 	(2055, 663)
-			    label      	(object SegLabel @108
-				Parent_View 	@106
-				location   	(1975, 702)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.876336
-				height     	39
-				orientation 	1))
-			(object RoleView "$UNNAMED$14" @109
-			    Parent_View 	@105
-			    location   	(845, -9)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3C89387802CE"
-			    client     	@105
-			    supplier   	@57
-			    line_style 	3
-			    origin_attachment 	(1405, 663)
-			    terminal_attachment 	(755, 663))))
-		(object ClassView "Class" "Logical View::ecore::EClassifier" @110
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(448, 2256)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@110
-			location   	(130, 2059)
-			nlines     	1
-			max_width  	636
-			justify    	0
-			label      	"EClassifier")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3ACE4FEE0371"
-		    compartment 	(object Compartment
-			Parent_View 	@110
-			location   	(130, 2162)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	TRUE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			anchor     	2
-			nlines     	6
-			max_width  	538)
-		    width      	654
-		    height     	418
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::ArrayType" @111
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    location   	(352, 1328)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@111
-			location   	(112, 1255)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	480
-			justify    	0
-			label      	"ArrayType")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3A9D79ED01DF"
-		    compartment 	(object Compartment
-			Parent_View 	@111
-			location   	(112, 1311)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	405)
-		    width      	498
-		    height     	168
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @112
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3A9D79FD010F"
-		    client     	@111
-		    supplier   	@57
-		    line_style 	3
-		    origin_attachment 	(431, 1243)
-		    terminal_attachment 	(431, 801))
-		(object AssociationViewNew "$UNNAMED$15" @113
-		    location   	(393, 1729)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3DF4CAAD01A3"
-		    roleview_list 	(list RoleViews
-			(object RoleView "componentType" @114
-			    Parent_View 	@113
-			    location   	(-55, 385)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @115
-				Parent_View 	@114
-				location   	(378, 1986)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	328
-				justify    	0
-				label      	"+componentType"
-				pctDist    	0.800000
-				height     	42
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3DF4CAAE01EB"
-			    client     	@113
-			    supplier   	@110
-			    line_style 	0
-			    label      	(object SegLabel @116
-				Parent_View 	@114
-				location   	(477, 2008)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "$UNNAMED$16" @117
-			    Parent_View 	@113
-			    location   	(-55, 385)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3DF4CAAE01F5"
-			    client     	@113
-			    supplier   	@111
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::ecore::EStructuralFeature" @118
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(2224, 224)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@118
-			location   	(2033, 145)
-			nlines     	1
-			max_width  	382
-			justify    	0
-			label      	"EStructuralFeature")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3903D59D0230"
-		    width      	400
-		    height     	182
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @119
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3DF4CE830390"
-		    client     	@56
-		    supplier   	@118
-		    line_style 	0)))
-	(object ClassDiagram "Imports"
-	    quid       	"3810A0DC015D"
-	    title      	"Imports"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	0
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::java::JavaClass" @120
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(320, 672)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@120
-			location   	(189, 626)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	262
-			justify    	0
-			label      	"JavaClass")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"36549FCC00FA"
-		    width      	280
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "ClassImports" @121
-		    location   	(643, 1115)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object SegLabel @122
-			Parent_View 	@121
-			location   	(677, 1040)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	TRUE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			anchor     	1
-			anchor_loc 	1
-			nlines     	1
-			max_width  	600
-			justify    	0
-			label      	"ClassImports"
-			pctDist    	1.066667
-			height     	76
-			orientation 	0)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3829C4BF000D"
-		    roleview_list 	(list RoleViews
-			(object RoleView "classImport" @123
-			    Parent_View 	@121
-			    location   	(227, 331)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @124
-				Parent_View 	@123
-				location   	(665, 671)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	240
-				justify    	0
-				label      	"+classImport"
-				pctDist    	0.727154
-				height     	2
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3829C4BF000E"
-			    client     	@121
-			    supplier   	@120
-			    vertices   	(list Points
-				(643, 1115)
-				(703, 1115)
-				(703, 672)
-				(460, 672))
-			    line_style 	3
-			    origin_attachment 	(643, 1115)
-			    terminal_attachment 	(460, 672)
-			    label      	(object SegLabel @125
-				Parent_View 	@123
-				location   	(525, 723)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.914676
-				height     	51
-				orientation 	0)
-			    label      	(object SegLabel @126
-				Parent_View 	@123
-				location   	(742, 737)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	3
-				anchor_loc 	1
-				nlines     	1
-				max_width  	159
-				justify    	0
-				label      	"{ordered}"
-				pctDist    	0.587467
-				height     	39
-				orientation 	1))
-			(object RoleView "importedBy" @127
-			    Parent_View 	@121
-			    location   	(227, 331)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @128
-				Parent_View 	@127
-				location   	(330, 936)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	240
-				justify    	0
-				label      	"+importedBy"
-				pctDist    	0.708040
-				height     	10
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3829C4BF000F"
-			    client     	@121
-			    supplier   	@120
-			    vertices   	(list Points
-				(643, 1115)
-				(320, 1115)
-				(320, 729))
-			    line_style 	3
-			    origin_attachment 	(643, 1115)
-			    terminal_attachment 	(320, 729)
-			    label      	(object SegLabel @129
-				Parent_View 	@127
-				location   	(280, 802)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.897611
-				height     	41
-				orientation 	0))))
-		(object ClassView "Class" "Logical View::java::JavaPackage" @130
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1408, 224)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@130
-			location   	(1247, 178)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	322
-			justify    	0
-			label      	"JavaPackage")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"38108E0301D2"
-		    width      	340
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "PackageImports" @131
-		    location   	(1023, 382)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object SegLabel @132
-			Parent_View 	@131
-			location   	(1038, 419)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	TRUE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			anchor     	1
-			anchor_loc 	1
-			nlines     	1
-			max_width  	600
-			justify    	0
-			label      	"PackageImports"
-			pctDist    	0.750000
-			height     	37
-			orientation 	1)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3829C4EC0207"
-		    roleview_list 	(list RoleViews
-			(object RoleView "importedBy" @133
-			    Parent_View 	@131
-			    location   	(-417, -306)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @134
-				Parent_View 	@133
-				location   	(648, 430)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	240
-				justify    	0
-				label      	"+importedBy"
-				pctDist    	0.646526
-				height     	41
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3829C4EE0105"
-			    client     	@131
-			    supplier   	@120
-			    vertices   	(list Points
-				(1023, 382)
-				(1023, 255)
-				(413, 614))
-			    line_style 	0
-			    label      	(object SegLabel @135
-				Parent_View 	@133
-				location   	(512, 618)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "packageImports" @136
-			    Parent_View 	@131
-			    location   	(-417, -306)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @137
-				Parent_View 	@136
-				location   	(1223, 579)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	312
-				justify    	0
-				label      	"+packageImports"
-				pctDist    	0.522472
-				height     	40
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3829C4EE00FB"
-			    client     	@131
-			    supplier   	@130
-			    vertices   	(list Points
-				(1023, 382)
-				(1023, 618)
-				(1265, 618)
-				(1386, 281))
-			    line_style 	0
-			    label      	(object SegLabel @138
-				Parent_View 	@136
-				location   	(1409, 378)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..n"
-				pctDist    	0.900000
-				height     	54
-				orientation 	1)
-			    label      	(object SegLabel @139
-				Parent_View 	@136
-				location   	(1424, 500)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	3
-				anchor_loc 	1
-				nlines     	1
-				max_width  	159
-				justify    	0
-				label      	"{ordered}"
-				pctDist    	0.769663
-				height     	109
-				orientation 	1))))))
-	(object ClassDiagram "Source code"
-	    quid       	"3810A13B0159"
-	    title      	"Source code"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	0
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::java::Comment" @140
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(592, 688)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@140
-			location   	(475, 642)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	234
-			justify    	0
-			label      	"Comment")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"380F889B02B8"
-		    width      	252
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Statement" @141
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1104, 688)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@141
-			location   	(983, 642)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	242
-			justify    	0
-			label      	"Statement")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"380F88B9025A"
-		    width      	260
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Initializer" @142
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(144, 288)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@142
-			location   	(33, 242)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	222
-			justify    	0
-			label      	"Initializer")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654A5DC00BB"
-		    width      	240
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Field" @143
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(256, 112)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@143
-			location   	(160, 66)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	192
-			justify    	0
-			label      	"Field")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AF8F0280"
-		    width      	210
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::Block" @144
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(864, 352)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@144
-			location   	(692, 256)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	344
-			justify    	0
-			label      	"Block")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"380F88370150"
-		    compartment 	(object Compartment
-			Parent_View 	@144
-			location   	(692, 312)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	3
-			max_width  	290)
-		    width      	362
-		    height     	214
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @145
-		    location   	(864, 580)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@144
-		    vertices   	(list Points
-			(864, 580)
-			(864, 459)))
-		(object InheritView "" @146
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"380F88D600A5"
-		    client     	@140
-		    supplier   	@144
-		    line_style 	3
-		    origin_attachment 	(581, 631)
-		    terminal_attachment 	(581, 580)
-		    drawSupplier 	@145)
-		(object InheritView "" @147
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"380F88DA0056"
-		    client     	@141
-		    supplier   	@144
-		    line_style 	3
-		    origin_attachment 	(1121, 630)
-		    terminal_attachment 	(1121, 580)
-		    drawSupplier 	@145)
-		(object AssociationViewNew "$UNNAMED$8" @148
-		    location   	(473, 300)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392AAC33036A"
-		    roleview_list 	(list RoleViews
-			(object RoleView "source" @149
-			    Parent_View 	@148
-			    location   	(153, -388)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @150
-				Parent_View 	@149
-				location   	(599, 267)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	145
-				justify    	0
-				label      	"+source"
-				pctDist    	0.599393
-				height     	34
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AAC380140"
-			    client     	@148
-			    supplier   	@144
-			    line_style 	3
-			    origin_attachment 	(473, 300)
-			    terminal_attachment 	(683, 300)
-			    label      	(object SegLabel @151
-				Parent_View 	@149
-				location   	(605, 334)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.635266
-				height     	34
-				orientation 	1))
-			(object RoleView "initializer" @152
-			    Parent_View 	@148
-			    location   	(153, -388)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AAC380168"
-			    client     	@148
-			    supplier   	@142
-			    line_style 	3
-			    origin_attachment 	(473, 300)
-			    terminal_attachment 	(264, 300))))
-		(object AssociationViewNew "$UNNAMED$9" @153
-		    location   	(671, 114)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object SegLabel @154
-			Parent_View 	@153
-			location   	(671, 55)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	TRUE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			hidden     	TRUE
-			anchor     	1
-			anchor_loc 	1
-			nlines     	1
-			max_width  	60
-			justify    	0
-			label      	""
-			pctDist    	0.500000
-			height     	60
-			orientation 	0)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392AAC5602A2"
-		    roleview_list 	(list RoleViews
-			(object RoleView "initializer" @155
-			    Parent_View 	@153
-			    location   	(319, -334)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @156
-				Parent_View 	@155
-				location   	(954, 210)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	195
-				justify    	0
-				label      	"+initializer"
-				pctDist    	0.891827
-				height     	104
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AAC5702DF"
-			    client     	@153
-			    supplier   	@144
-			    vertices   	(list Points
-				(671, 114)
-				(850, 114)
-				(850, 245))
-			    line_style 	3
-			    origin_attachment 	(671, 114)
-			    terminal_attachment 	(850, 245)
-			    label      	(object SegLabel @157
-				Parent_View 	@155
-				location   	(790, 218)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.913462
-				height     	61
-				orientation 	1))
-			(object RoleView "field" @158
-			    Parent_View 	@153
-			    location   	(319, -334)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AAC570307"
-			    client     	@153
-			    supplier   	@143
-			    line_style 	3
-			    origin_attachment 	(671, 114)
-			    terminal_attachment 	(361, 114))))
-		(object ClassView "Class" "Logical View::java::Method" @159
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(288, 496)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@159
-			location   	(190, 450)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	196
-			justify    	0
-			label      	"Method")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654AE910271"
-		    width      	214
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AssociationViewNew "$UNNAMED$10" @160
-		    location   	(596, 496)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"392AACA501E7"
-		    roleview_list 	(list RoleViews
-			(object RoleView "source" @161
-			    Parent_View 	@160
-			    location   	(276, -448)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @162
-				Parent_View 	@161
-				location   	(690, 463)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	145
-				justify    	0
-				label      	"+source"
-				pctDist    	0.474777
-				height     	34
-				orientation 	0)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AACA7017C"
-			    client     	@160
-			    supplier   	@144
-			    vertices   	(list Points
-				(596, 496)
-				(759, 496)
-				(759, 459))
-			    line_style 	3
-			    origin_attachment 	(596, 496)
-			    terminal_attachment 	(759, 459)
-			    label      	(object SegLabel @163
-				Parent_View 	@161
-				location   	(817, 477)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"0..1"
-				pctDist    	0.915367
-				height     	58
-				orientation 	1))
-			(object RoleView "method" @164
-			    Parent_View 	@160
-			    location   	(276, -448)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"392AACA701B8"
-			    client     	@160
-			    supplier   	@159
-			    line_style 	3
-			    origin_attachment 	(596, 496)
-			    terminal_attachment 	(395, 496))))))
-	(object ClassDiagram "Data Types"
-	    quid       	"3810A1CE02EB"
-	    title      	"Data Types"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	0
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::java::TypeKind" @165
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(240, 224)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@165
-			location   	(77, 84)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	326
-			justify    	0
-			label      	"TypeKind")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@165
-			location   	(77, 39)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	326
-			justify    	0
-			label      	"<<enumeration>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3654B46002BF"
-		    compartment 	(object Compartment
-			Parent_View 	@165
-			location   	(77, 140)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	5
-			max_width  	277)
-		    width      	344
-		    height     	392
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JavaVisibilityKind" @166
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(240, 640)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@166
-			location   	(68, 500)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	344
-			justify    	0
-			label      	"JavaVisibilityKind")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@166
-			location   	(68, 455)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	344
-			justify    	0
-			label      	"<<enumeration>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"382333BE032E"
-		    compartment 	(object Compartment
-			Parent_View 	@166
-			location   	(68, 556)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	5
-			max_width  	292)
-		    width      	362
-		    height     	392
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object NoteView @167
-		    location   	(1296, 208)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@167
-			location   	(887, 52)
-			fill_color 	13434879
-			nlines     	6
-			max_width  	783
-			label      	
-|The Java primitive types are instances of JavaDataType.  The common parent class with JavaClass is Classifier.  The primitive types can be obtained via a JavaURL("int"), which resolves to a reference like: "java:/#int"
-			)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	843
-		    height     	325)
-		(object ClassView "Class" "Logical View::java::JavaParameterKind" @168
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(256, 1088)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@168
-			location   	(63, 948)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	386
-			justify    	0
-			label      	"JavaParameterKind")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@168
-			location   	(63, 903)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	386
-			justify    	0
-			label      	"<<enumeration>>")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"391C1E8F0123"
-		    compartment 	(object Compartment
-			Parent_View 	@168
-			location   	(63, 1004)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	5
-			max_width  	207)
-		    width      	404
-		    height     	392
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object NoteView @169
-		    location   	(768, 1120)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@169
-			location   	(574, 1017)
-			fill_color 	13434879
-			nlines     	4
-			max_width  	352
-			label      	"Temporary enum for Java parameter kind until we get the base sorted out")
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	412
-		    height     	219)
-		(object ClassView "Class" "Logical View::java::JavaDataType" @170
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(1168, 1408)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@170
-			location   	(999, 1362)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	338
-			justify    	0
-			label      	"JavaDataType")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"395913340316"
-		    width      	356
-		    height     	114
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::ecore::EDataType" @171
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1088, 640)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@171
-			location   	(812, 511)
-			nlines     	2
-			max_width  	552
-			justify    	0
-			label      	"EDataType")
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	16777215
-		    quidu      	"3903D525033E"
-		    compartment 	(object Compartment
-			Parent_View 	@171
-			location   	(812, 611)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			anchor     	2
-			nlines     	2
-			max_width  	522)
-		    width      	570
-		    height     	282
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AttachView "" @172
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@169
-		    supplier   	@168
-		    line_style 	0)))
-	(object ClassDiagram "Java Types"
-	    quid       	"3B65B823020D"
-	    title      	"Java Types"
-	    documentation 	"This class diagram contains the Java Types that are not EMF classes but are referenced in this diagram."
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	478
-	    origin_y   	35
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::java::JTypeJavaHelpers" @173
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(912, 208)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@173
-			location   	(398, 154)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1028
-			justify    	0
-			label      	"JTypeJavaHelpers")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@173
-			location   	(398, 109)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	1028
-			justify    	0
-			label      	"<<datatype>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3B65ADE403A6"
-		    compartment 	(object Compartment
-			Parent_View 	@173
-			location   	(398, 210)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	873)
-		    width      	1046
-		    height     	220
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::java::JTypeList" @174
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(880, 576)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@174
-			location   	(628, 523)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	504
-			justify    	0
-			label      	"JTypeList")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@174
-			location   	(628, 478)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	504
-			justify    	0
-			label      	"<<datatype>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3B65B87602C1"
-		    compartment 	(object Compartment
-			Parent_View 	@174
-			location   	(628, 579)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	507)
-		    width      	522
-		    height     	218
-		    annotation 	8
-		    autoResize 	TRUE)))))
diff --git a/plugins/org.eclipse.jem/rose/instance.mdl b/plugins/org.eclipse.jem/rose/instance.mdl
deleted file mode 100644
index a9007e5..0000000
--- a/plugins/org.eclipse.jem/rose/instance.mdl
+++ /dev/null
@@ -1,8669 +0,0 @@
-
-(object Petal
-    version    	47
-    _written   	"Rose 8.0.0303.1400"
-    charSet    	0)
-
-(object Design "Logical View"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    attributes 	(list Attribute_Set
-	(object Attribute
-	    tool       	"Java"
-	    name       	"IDE"
-	    value      	"Internal Editor")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName3"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText3"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply3"
-	    value      	""))
-    quid       	"3A79EBA50331"
-    defaults   	(object defaults
-	rightMargin 	0.250000
-	leftMargin 	0.250000
-	topMargin  	0.250000
-	bottomMargin 	0.500000
-	pageOverlap 	0.250000
-	clipIconLabels 	TRUE
-	autoResize 	TRUE
-	snapToGrid 	FALSE
-	gridX      	16
-	gridY      	16
-	defaultFont 	(object Font
-	    size       	10
-	    face       	"Arial"
-	    bold       	FALSE
-	    italics    	FALSE
-	    underline  	FALSE
-	    strike     	FALSE
-	    color      	0
-	    default_color 	TRUE)
-	showMessageNum 	1
-	showClassOfObject 	TRUE
-	notation   	"Unified")
-    root_usecase_package 	(object Class_Category "Use Case View"
-	quid       	"3A7999AD0297"
-	exportControl 	"Public"
-	global     	TRUE
-	logical_models 	(list unit_reference_list)
-	logical_presentations 	(list unit_reference_list
-	    (object UseCaseDiagram "Main"
-		quid       	"3A7999B702F6"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    root_category 	(object Class_Category "Logical View"
-	quid       	"3A7999AD028E"
-	exportControl 	"Public"
-	global     	TRUE
-	subsystem  	"Component View"
-	quidu      	"3B86F172016F"
-	logical_models 	(list unit_reference_list
-	    (object Class_Category "instantiation"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.jem\\rose\\instantiation.cat"
-		quid       	"3B86F1720180")
-	    (object Class_Category "ecore"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.emf.ecore\\model\\org.eclipse.emf.Ecore.cat"
-		quid       	"39A5ED04004E"))
-	logical_presentations 	(list unit_reference_list
-	    (object ClassDiagram "Main"
-		quid       	"3B86F1720173"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list
-		    (object CategoryView "Logical View::instantiation" @1
-			location   	(334, 240)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@1
-			    location   	(190, 156)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"instantiation")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"3B86F1720180"
-			width      	300
-			height     	180)))
-	    (object ClassDiagram "Dependencies (Don't edit)"
-		quid       	"3B86F31F0281"
-		title      	"Dependencies (Don't edit)"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list
-		    (object NoteView @2
-			location   	(753, 685)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@2
-			    location   	(305, 539)
-			    fill_color 	13434879
-			    nlines     	6
-			    max_width  	860
-			    label      	"These are the dependencies. They are not to be edited. They must only be edited by their owner models.")
-			line_color 	3342489
-			fill_color 	8421631
-			width      	920
-			height     	305)
-		    (object CategoryView "Logical View::ecore" @3
-			location   	(263, 185)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@3
-			    location   	(119, 101)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"ecore")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"39A5ED04004E"
-			width      	300
-			height     	180)))))
-    root_subsystem 	(object SubSystem "Component View"
-	quid       	"3B86F172016F"
-	physical_models 	(list unit_reference_list)
-	physical_presentations 	(list unit_reference_list
-	    (object Module_Diagram "Main"
-		quid       	"3B86F1720176"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    process_structure 	(object Processes
-	quid       	"3B86F1720170"
-	ProcsNDevs 	(list
-	    (object Process_Diagram "Deployment View"
-		quid       	"3B86F1720172"
-		title      	"Deployment View"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    properties 	(object Properties
-	attributes 	(list Attribute_Set
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Const"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialValue"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Copyright"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RootPackage"
-			value      	"C++ Reverse Engineered")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialHeaderIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialBodyIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngRootDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngDirectoriesAsPackages"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"HeaderFileExtension"
-			value      	".h")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ImplementationFileExtension"
-			value      	".cpp")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewHeaderFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewImplementationFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalization"
-			value      	("FileCapitalizationSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectories"
-			value      	("CodeGenExtraDirectoriesSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"StripClassPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"UseTabs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"TabWidth"
-			value      	8)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"IndentWidth"
-			value      	4)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"AccessIndentation"
-			value      	-2)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRules"
-			value      	("ModelIdCommentRulesSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"PageWidth"
-			value      	80)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassMemberOrder"
-			value      	("MemberOrderSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"OneParameterPerLine"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NamespaceBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FunctionBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectoriesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Namespaces"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Packages"
-				value      	2)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalizationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Same as model"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Upper case"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case with underscores"
-				value      	3)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"BraceStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B1"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B2"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B3"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B4"
-				value      	4)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B5"
-				value      	5)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"MemberOrderSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Public First"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Private First"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Order by kind"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Unordered"
-				value      	4)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRulesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation only"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation and reverse engineering"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Never generate model IDs"
-				value      	3)))))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Param"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialCodeBody"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"GenerateFunctionBody"
-			value      	("GenerateFunctionBodySet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"GenerateFunctionBodySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Default"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"False"
-				value      	0)))))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ImplementationType"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"HeaderSourceFile"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"BodySourceFile"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"IsNamespace"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ANSI C++ Event Watcher"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ANSIConvert"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"propertyId"
-		value      	"838326200")
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SpecFileExtension"
-			value      	"1.ada")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SpecFileBackupExtension"
-			value      	"1.ad~")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SpecFileTemporaryExtension"
-			value      	"1.ad#")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"BodyFileExtension"
-			value      	"2.ada")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"BodyFileBackupExtension"
-			value      	"2.ad~")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"BodyFileTemporaryExtension"
-			value      	"2.ad#")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateBodies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DefaultCodeBody"
-			value      	"[statement]")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"UseFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Directory"
-			value      	"$ROSEADA83_SOURCE")))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassName"
-			value      	"Object")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassAccess"
-			value      	("ImplementationSet" 43))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplementationType"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsSubtype"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"PolymorphicUnit"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"HandleName"
-			value      	"Handle")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"HandleAccess"
-			value      	("ImplementationSet" 45))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Discriminant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Variant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"EnumerationLiteralPrefix"
-			value      	"A_")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"RecordFieldPrefix"
-			value      	"The_")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassParameterName"
-			value      	"This")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DefaultConstructorKind"
-			value      	("ConstructorKindSet" 199))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DefaultConstructorName"
-			value      	"Create")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyConstructorKind"
-			value      	("ConstructorKindSet" 199))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyConstructorName"
-			value      	"Copy")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DestructorName"
-			value      	"Free")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassEqualityOperation"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"HandleEqualityOperation"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineEquality"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsTask"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"LimitedPrivate"
-				value      	200)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ConstructorKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenericFormalParameters"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsSubunit"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SubprogramImplementation"
-			value      	("SubprogramImplementationSet" 2))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Renames"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassParameterMode"
-			value      	("ParameterModeSet" 203))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialCodeBody"
-			value      	"${default}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SubprogramImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Spec"
-				value      	224)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Body"
-				value      	2)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Renaming"
-				value      	222)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Separate"
-				value      	223)))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ParameterModeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"In"
-				value      	204)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Out"
-				value      	205)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"InOut"
-				value      	203)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"FunctionReturn"
-				value      	206)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"NameIfUnlabeled"
-			value      	"The_${supplier}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DataMemberName"
-			value      	"${relationship}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${relationship}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${relationship}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Variant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorType"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DataMemberName"
-			value      	"${attribute}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${attribute}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${attribute}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Variant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Representation"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${association}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${association}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateAssociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"AssociateName"
-			value      	"Associate")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineAssociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateDissociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DissociateName"
-			value      	"Dissociate")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineDissociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DataMemberName"
-			value      	"${target}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${target}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${target}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Directory"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"propertyId"
-		value      	"838326200")
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SpecFileExtension"
-			value      	"1.ada")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SpecFileBackupExtension"
-			value      	"1.ad~")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SpecFileTemporaryExtension"
-			value      	"1.ad#")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"BodyFileExtension"
-			value      	"2.ada")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"BodyFileBackupExtension"
-			value      	"2.ad~")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"BodyFileTemporaryExtension"
-			value      	"2.ad#")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"UseColonNotation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateBodies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DefaultCodeBody"
-			value      	"[statement]")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"UseFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Directory"
-			value      	"$ROSEADA95_SOURCE")))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeName"
-			value      	"Object")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeVisibility"
-			value      	("TypeVisibilitySet" 43))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeImplementation"
-			value      	("TypeImplementationSet" 208))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeControl"
-			value      	("TypeControlSet" 225))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeControlName"
-			value      	"Controlled_${type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeDefinition"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordImplementation"
-			value      	("RecordImplementationSet" 209))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordKindPackageName"
-			value      	"${class}_Record_Kinds")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsLimited"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsSubtype"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessType"
-			value      	("GenerateAccessTypeSet" 230))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessTypeName"
-			value      	"Handle")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessTypeVisibility"
-			value      	("TypeVisibilitySet" 45))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessTypeDefinition"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessClassWide"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"MaybeAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParameterizedImplementation"
-			value      	("ParameterizedImplementationSet" 11))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParentClassName"
-			value      	"Superclass")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"EnumerationLiteralPrefix"
-			value      	"A_")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldPrefix"
-			value      	"The_")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ArrayOfTypeName"
-			value      	"Array_Of_${type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessArrayOfTypeName"
-			value      	"Access_Array_Of_${type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ArrayOfAccessTypeName"
-			value      	"Array_Of_${access_type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessArrayOfAccessTypeName"
-			value      	"Access_Array_Of_${access_type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ArrayIndexDefinition"
-			value      	"Positive range <>")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameterName"
-			value      	"This")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateDefaultConstructor"
-			value      	("SubprogramKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DefaultConstructorName"
-			value      	"Create")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateCopyConstructor"
-			value      	("SubprogramKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CopyConstructorName"
-			value      	"Copy")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateDestructor"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DestructorName"
-			value      	"Free")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateTypeEquality"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeEqualityName"
-			value      	"${quote}=${quote}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineEquality"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Tagged"
-				value      	208)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Record"
-				value      	210)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Mixin"
-				value      	211)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Task"
-				value      	212)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"SingleType"
-				value      	209)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"MultipleTypes"
-				value      	213)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParameterizedImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Generic"
-				value      	11)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Unconstrained"
-				value      	214)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Private"
-				value      	43)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SubprogramKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeControlSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"None"
-				value      	225)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"InitializationOnly"
-				value      	226)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AssignmentFinalizationOnly"
-				value      	227)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"All"
-				value      	228)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Always"
-				value      	229)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Auto"
-				value      	230)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenericFormalParameters"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsPrivate"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsSubunit"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SubprogramImplementation"
-			value      	("SubprogramImplementationSet" 2))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Renames"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateOverriding"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameterMode"
-			value      	("ParameterModeSet" 203))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameterClassWide"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialCodeBody"
-			value      	"${default}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"EntryBarrierCondition"
-			value      	"True")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SubprogramImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Spec"
-				value      	224)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Body"
-				value      	2)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Abstract"
-				value      	221)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Renaming"
-				value      	222)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"RenamingAsBody"
-				value      	231)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Separate"
-				value      	223)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParameterModeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"In"
-				value      	204)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Out"
-				value      	205)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"InOut"
-				value      	203)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Access"
-				value      	220)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"NameIfUnlabeled"
-			value      	"The_${supplier}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementation"
-			value      	("RecordFieldImplementationSet" 216))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldName"
-			value      	"${relationship}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessGet"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${relationship}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessSet"
-			value      	("ProcedureKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${relationship}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementation"
-			value      	("ContainerImplementationSet" 217))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Component"
-				value      	216)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Discriminant"
-				value      	218)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AccessDiscriminant"
-				value      	219)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Array"
-				value      	217)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Generic"
-				value      	11)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementation"
-			value      	("RecordFieldImplementationSet" 216))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldName"
-			value      	"${attribute}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessGet"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${attribute}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessSet"
-			value      	("ProcedureKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${attribute}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Component"
-				value      	216)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Discriminant"
-				value      	218)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AccessDiscriminant"
-				value      	219)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${association}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${association}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAssociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AssociateName"
-			value      	"Associate")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineAssociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateDissociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DissociateName"
-			value      	"Dissociate")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineDissociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementation"
-			value      	("RecordFieldImplementationSet" 216))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldName"
-			value      	"${target}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessGet"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${target}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessSet"
-			value      	("ProcedureKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${target}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementation"
-			value      	("ContainerImplementationSet" 217))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Component"
-				value      	216)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Discriminant"
-				value      	218)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AccessDiscriminant"
-				value      	219)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Array"
-				value      	217)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Generic"
-				value      	11)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Directory"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Editor"
-			value      	("EditorType" 100))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"IncludePath"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"StopOnError"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"EditorType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"BuiltIn"
-				value      	100)
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"WindowsShell"
-				value      	101)))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"PathSeparator"
-			value      	"")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ArrayDimensions"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ConstValue"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ImplementationType"
-			value      	"")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Context"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"OperationIsOneWay"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ArrayDimensions"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CaseSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Order"
-			value      	"")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ArrayDimensions"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CaseSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"GenerateForwardReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Order"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"BoundedRoleType"
-			value      	("AssocTypeSet" 47))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"AssocTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Uses"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"GenerateForwardReference"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ClearCase"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"project"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ViewCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DomainCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SPPackageCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TriggerCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IndexCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"StoreProcedureCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PrimaryKeyCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForeignKeyCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"JoinCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpaceCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"cONTAINERCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TablePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ViewPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DomainPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TriggerPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IndexPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"StoreProcedurePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PrimaryKeyPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForeignKeyPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpacePrefix"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDatabase"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TargetDatabase"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Location"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsTableSpace"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpaceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDeault"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"BufferPool"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ExtentSize"
-			value      	1)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PrefetchSize"
-			value      	1)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PageSize"
-			value      	4)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ManagedBy"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ContainerList"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmSchema"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmDomainPackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSchema"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDomainPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRootSchema"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRootDomainPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSchemaPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DatabaseID"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DBMS"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsTable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsView"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDomain"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSPPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Synonymns"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpaceID"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceId"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"CorrelationName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SelectClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUpdateable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"CheckOption"
-			value      	"None")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSnapShot"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDistinct"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PersistToServer"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsPackage"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Ordinal"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsIdentity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"NullsAllowed"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Length"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Scale"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ColumnType"
-			value      	"Native")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForBitData"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValueType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceId"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"OID"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRelationship"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceId"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RIMethod"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentUpdateRule"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentUpdateRuleName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentDeleteRule"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentDeleteRuleName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildInsertRestrict"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildInsertRestrictName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildMultiplicity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildMultiplicityName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsConstraint"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsIndex"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsTrigger"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsStoredProcedure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsCluster"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpace"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"FillFactor"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"KeyList"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"CheckPredicate"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DeferalMode"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"InitialCheckTime"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TriggerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsInsertEvent"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUpdateEvent"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDeleteEvent"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefOldTable"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefNewTable"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefOldRow"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefNewRow"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRow"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"WhenClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Language"
-			value      	"SQL")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ProcType"
-			value      	"Procedure")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDeterministic"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParameterStyle"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ReturnedNull"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ExternalName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Scale"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForBitData"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValueType"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Parameter"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsInParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsOutParameter"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Ordinal"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Scale"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForBitData"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValueType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"OperationID"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Data Modeler Communicator"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"framework"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Java"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"RootDir"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UsePrefixes"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"AutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"NotShowRoseIDDlg"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ShowCodegenDlg"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateRoseID"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultReturnLine"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocDefaultAuthor"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocDefaultVersion"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocDefaultSince"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagName1"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagApply1"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagText1"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagName2"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagApply2"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagText2"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagName3"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagApply3"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagText3"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocNumAsterisks"
-			value      	0)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MaxNumChars"
-			value      	80)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Editor"
-			value      	("EditorType" 100))
-		    (object Attribute
-			tool       	"Java"
-			name       	"VM"
-			value      	("VMType" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"ClassPath"
-			value      	";D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\charsets.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\jce.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\jsse.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\rt.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\sunrsasign.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\dnsns.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\ldapsec.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\localedata.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\sunjce_provider.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\security\\local_policy.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\security\\US_export_policy.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\lib\\dt.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\lib\\htmlconverter.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\lib\\tools.jar")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReferenceClasspath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EditorType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"BuiltIn"
-				value      	100)
-			    (object Attribute
-				tool       	"Java"
-				name       	"WindowsShell"
-				value      	101)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"VMType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Sun"
-				value      	200)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"VAJavaWorkingFolder"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"InstanceVariablePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ClassVariablePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultAttributeDataType"
-			value      	"int")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultOperationReturnType"
-			value      	"void")
-		    (object Attribute
-			tool       	"Java"
-			name       	"NoClassCustomDlg"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GlobalImports"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"OpenBraceClassStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"OpenBraceMethodStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UseTabs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UseSpaces"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"SpacingItems"
-			value      	3)
-		    (object Attribute
-			tool       	"Java"
-			name       	"RoseDefaultCommentStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"AsteriskCommentStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavaCommentStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocAuthor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocSince"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"RemotePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"RemoteSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"HomePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"HomeSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"PrimaryKeyPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"PrimaryKeySuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBDTDLocation"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDTDLocation"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultEJBVersion"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultServletVersion"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultJ2EEJavadoc"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineJavaDocTags"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalHomePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalHomeSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"SourceControl"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCSelected"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCProjectSourceRoot"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCProjectName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCComment"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"Default_Servlet__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"Http_Servlet__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"Default_EJB__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"CmIdentification"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"CmIdentification"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Abstract"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Native"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Synchronized"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFullyQualifiedReturn"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReplaceExistingCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Transient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Volatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"PropertyType"
-			value      	("BeanProperty_Set" 71))
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanProperty_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Not A Property"
-				value      	71)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Simple"
-				value      	72)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bound"
-				value      	73)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Constrained"
-				value      	74)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"IndividualChangeMgt"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write"
-			value      	("Read/Write_Set" 81))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read & Write"
-				value      	81)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read Only"
-				value      	82)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Write Only"
-				value      	83)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFullyQualifiedTypes"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Transient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Volatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"PropertyType"
-			value      	("BeanProperty_Set" 71))
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanProperty_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Not A Property"
-				value      	71)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Simple"
-				value      	72)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bound"
-				value      	73)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Constrained"
-				value      	74)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"IndividualChangeMgt"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write"
-			value      	("Read/Write_Set" 81))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read & Write"
-				value      	81)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read Only"
-				value      	82)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Write Only"
-				value      	83)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFullyQualifiedTypes"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsNavigable"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"propertyId"
-		value      	"360000002")
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"DDLScriptFilename"
-			value      	"DDL1.SQL")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"DropClause"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"PrimaryKeyColumnName"
-			value      	"_ID")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"PrimaryKeyColumnType"
-			value      	"NUMBER(5,0)")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"SchemaNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"SchemaNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TableNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TypeNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TypeNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ViewNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ViewNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"VarrayNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"VarrayNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NestedTableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NestedTableNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ObjectTableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ObjectTableNameSuffix"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsSchema"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OID"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"WhereClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CheckConstraint"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypeLength"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypePrecision"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypeScale"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionOfREFS"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"MethodKind"
-			value      	("MethodKindSet" 1903))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OverloadID"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsReadNoDataState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsReadNoProcessState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsWriteNoDataState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsWriteNoProcessState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsSelfish"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerType"
-			value      	("TriggerTypeSet" 1801))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerEvent"
-			value      	("TriggerEventSet" 1601))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerText"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerReferencingNames"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerForEach"
-			value      	("TriggerForEachSet" 1701))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerWhenClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"MethodKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"MapMethod"
-				value      	1901)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"OrderMethod"
-				value      	1902)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Function"
-				value      	1903)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Procedure"
-				value      	1904)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Operator"
-				value      	1905)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Constructor"
-				value      	1906)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Destructor"
-				value      	1907)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Trigger"
-				value      	1908)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Calculated"
-				value      	1909)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"AFTER"
-				value      	1801)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"BEFORE"
-				value      	1802)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSTEAD OF"
-				value      	1803)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerForEachSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"ROW"
-				value      	1701)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"STATEMENT"
-				value      	1702)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerEventSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT"
-				value      	1601)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"UPDATE"
-				value      	1602)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"DELETE"
-				value      	1603)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR UPDATE"
-				value      	1604)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR DELETE"
-				value      	1605)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"UPDATE OR DELETE"
-				value      	1606)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR UPDATE OR DELETE"
-				value      	1607)))))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NullsAllowed"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Precision"
-			value      	"2")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Scale"
-			value      	"6")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsIndex"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsPrimaryKey"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CompositeUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CheckConstraint"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ComponentTest"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"RequisitePro"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"cg"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerAnnotations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"UseMSVC"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AlwaysKeepOrphanedCode"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"compiler2.1__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerAnnotations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue(sizeof($targetClass))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue(sizeof($targetClass),$limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue(sizeof($targetClass),$limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference($limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference($limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue(sizeof($targetClass))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue(sizeof($targetClass))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AlwaysKeepOrphanedCode"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"compiler3.0__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerAnnotations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AlwaysKeepOrphanedCode"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ImplementationType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ClassKey"
-			value      	"class")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"PutBodiesInSpec"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDefaultConstructor"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DefaultConstructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExplicitDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateCopyConstructor"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyConstructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExplicitCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDestructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DestructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DestructorKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssignmentOperation"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssignmentVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssignmentKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssignmentOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEqualityOperations"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"EqualityVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"EqualityKind"
-			value      	("FriendKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineEqualityOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateRelationalOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"RelationalVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"RelationalKind"
-			value      	("FriendKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineRelationalOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateStorageMgmtOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StorageMgmtVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineStorageMgmtOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSubscriptOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSubscriptOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDereferenceOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDereferenceOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateIndirectionOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineIndirectionOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateStreamOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StreamVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineStreamOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ThreeKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"KindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FriendKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"DeclareAndDefine"
-				value      	199)
-			    (object Attribute
-				tool       	"cg"
-				name       	"DeclareOnly"
-				value      	205)
-			    (object Attribute
-				tool       	"cg"
-				name       	"DoNotDeclare"
-				value      	206)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"VisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExtensionlessFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeFormat"
-			value      	(value Text 
-|// $package
-|#include "$file"
-|
-			))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludePrecompiledHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeOrder"
-			value      	"AMIR")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyle"
-			value      	("InliningStyleSet" 207))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"InClassDeclaration"
-				value      	208)
-			    (object Attribute
-				tool       	"cg"
-				name       	"FollowingClassDeclaration"
-				value      	207)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"TypesDefined"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeClosure"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExtensionlessFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeFormat"
-			value      	(value Text 
-|// $package
-|#include "$file"
-|
-			))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludePrecompiledHeader"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeOrder"
-			value      	"AMIR")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyle"
-			value      	("InliningStyleSet" 207))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"InClassDeclaration"
-				value      	208)
-			    (object Attribute
-				tool       	"cg"
-				name       	"FollowingClassDeclaration"
-				value      	207)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"TypesDefined"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeClosure"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationKind"
-			value      	("OperationKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAbstractBody"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateFriendBody"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateFriendDecl"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SpecialDeclReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsConst"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsExplicit"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CCRegion"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"BodyAnnotations"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"Ordered"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$supplier")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HasRelTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$targetClass")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"InstanceArguments"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerGet"
-			value      	"$data.get($keys)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerSet"
-			value      	"$data.set($keys,$value)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedContainer"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassContainer"
-			value      	"$supplier *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassInitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetSetByReference"
-			value      	("QualifiedGetSetByReferenceSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetSetByReferenceSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_GetSetByReference"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateQualifiedGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineQualifiedGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateQualifiedSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedSetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedSetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineQualifiedSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberName"
-			value      	"$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssocClassGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassSetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassSetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssocClassSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassForwardReferenceOnly"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtAttributeVisibility"
-				value      	211)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CCRegion"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Uses"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"BodyReferenceOnly"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DirectoryIsOnSearchList"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"PrecompiledHeader"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"IsNamespace"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Indent"
-			value      	2)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Version"
-			value      	"5.0")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCClassTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCClassTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Interface_Part"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Connection_Part"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Class_Factory"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CObjectFunctionality"
-			value      	("CObjectFunctionalitySet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CObjectFunctionalitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dynamic"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dyncreate"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Serial"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOverrideGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDataGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DATA_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateFieldGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_FIELD_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMessageGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMessageMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MESSAGE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEFactory"
-			value      	("OLEFactorySet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEFactorySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Built_in"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Simple"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Licensed"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEName"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEClassID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOLECtlType"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLECtlType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOLETypeLib"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibMajor"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibMinor"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GeneratePropPageIDs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEPropPageIDs"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDispatchMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockProperties"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockFunctions"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DispatchDefValue"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDispIdEnum"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISP_ID_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInterfaceMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"INTERFACE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"InitInterface"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateEventMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockEvents"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateEventSinkMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PropNotifySinks"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateConnectionMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CONNECTION_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"ConnectionPointIID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"InheritanceType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLECommands"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MFCDeclares"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MFCImplements"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"ATL_Declares"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateCOMMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"COM_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateConnectionPointMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CONNECTION_POINT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMsgMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GeneratePropertyMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PROPERTY_MAP_Entries"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCOperationTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCOperationTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Virtual_Override"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Message_Handler"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dispatch_Handler"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Event_Firing_Function"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Event_Sink_Handler"
-				value      	5)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Std_OLE_Method"
-				value      	6)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Command_Parser"
-				value      	7)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Get_Function"
-				value      	8)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Set_Function"
-				value      	9)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Notify_Function"
-				value      	10)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Macro_Generated_Function"
-				value      	11)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MESSAGE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"BodyImage"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateIncludesGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_INCLUDES_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInsertLocation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateIncludesGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_INCLUDES_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInsertLocation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Rose Model Integrator"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Rose Web Publisher"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"SoDA"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"TopLink"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"COM"
-		name       	"propertyId"
-		value      	"783606378")
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"TypeKinds"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"COM"
-				name       	"enum"
-				value      	100)
-			    (object Attribute
-				tool       	"COM"
-				name       	"record"
-				value      	101)
-			    (object Attribute
-				tool       	"COM"
-				name       	"module"
-				value      	102)
-			    (object Attribute
-				tool       	"COM"
-				name       	"interface"
-				value      	103)
-			    (object Attribute
-				tool       	"COM"
-				name       	"dispinterface"
-				value      	104)
-			    (object Attribute
-				tool       	"COM"
-				name       	"coclass"
-				value      	105)
-			    (object Attribute
-				tool       	"COM"
-				name       	"alias"
-				value      	106)
-			    (object Attribute
-				tool       	"COM"
-				name       	"union"
-				value      	107)
-			    (object Attribute
-				tool       	"COM"
-				name       	"max"
-				value      	108)
-			    (object Attribute
-				tool       	"COM"
-				name       	"(none)"
-				value      	109)))
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"kind"
-			value      	("TypeKinds" 109))
-		    (object Attribute
-			tool       	"COM"
-			name       	"uuid"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"version"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpcontext"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"dllname"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"alias"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"id"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"id"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"filename"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"library"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"uuid"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"version"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpfile"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpcontext"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"lcid"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Param"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"propertyId"
-		value      	"783606378")
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateModel"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"InstancingSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Private"
-				value      	221)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"PublicNotCreatable"
-				value      	213)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"SingleUse"
-				value      	214)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"GlobalSingleUse"
-				value      	215)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"MultiUse"
-				value      	219)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"GlobalMultiUse"
-				value      	220)))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"BaseSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"(none)"
-				value      	222)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"0"
-				value      	223)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"1"
-				value      	224)))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionBase"
-			value      	("BaseSet" 222))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionExplicit"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionCompare"
-			value      	("CompareSet" 202))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Instancing"
-			value      	("InstancingSet" 219))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"CompareSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"(none)"
-				value      	202)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Binary"
-				value      	203)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Text"
-				value      	204)))))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"LibraryName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"AliasName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"IsStatic"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProcedureID"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ReplaceExistingBody"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"DefaultBody"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"New"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"WithEvents"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProcedureID"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"PropertyName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Subscript"
-			value      	"")))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"New"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"WithEvents"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"FullName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProcedureID"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"PropertyName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Subscript"
-			value      	"")))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImplementsDelegation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"FullName"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Param"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ByVal"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ByRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Optional"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ParamArray"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProjectFile"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateModel"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImportReferences"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"QuickImport"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImportBinary"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"VisualStudio"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Web Modeler"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Editor"
-			value      	("EditorType" 100))
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"StopOnError"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"EditorType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"XML_DTD"
-				name       	"BuiltIn"
-				value      	100)
-			    (object Attribute
-				tool       	"XML_DTD"
-				name       	"WindowsShell"
-				value      	101)))))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Entity_SystemID"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Entity_PublicID"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"NotationValue"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"InternalValue"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"ParameterEntity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"ExternalEntity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Notation_SystemID"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Notation_PublicID"
-			value      	"")))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"DefaultDeclType"
-			value      	"")))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Assign All"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"ComponentPath"
-			value      	"")))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngRootDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RootPackage"
-			value      	"C++ Reverse Engineered")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngDirectoriesAsPackages"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"HeaderFileExtension"
-			value      	".h")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ImplementationFileExtension"
-			value      	".cpp")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewHeaderFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewImplementationFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalization"
-			value      	("FileCapitalizationSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectories"
-			value      	("CodeGenExtraDirectoriesSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"StripClassPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"UseTabs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"TabWidth"
-			value      	8)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"IndentWidth"
-			value      	4)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"AccessIndentation"
-			value      	-2)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRules"
-			value      	("ModelIdCommentRulesSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"PageWidth"
-			value      	80)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassMemberOrder"
-			value      	("MemberOrderSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"OneParameterPerLine"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NamespaceBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FunctionBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Copyright"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialHeaderIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialBodyIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectoriesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Namespaces"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Packages"
-				value      	2)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalizationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Same as model"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Upper case"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case with underscores"
-				value      	3)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"BraceStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B1"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B2"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B3"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B4"
-				value      	4)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B5"
-				value      	5)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"MemberOrderSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Public First"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Private First"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Order by kind"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Unordered"
-				value      	4)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRulesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation only"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation and reverse engineering"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Never generate model IDs"
-				value      	3)))))
-	    (object Attribute
-		tool       	"Deploy"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Version Control"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"classifierName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"constraints"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlContentKind"
-			value      	("ContentKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"ContentKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Empty"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Mixed"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"ElementOnly"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"operationName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"attributeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isID"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"visibility"
-			value      	("VisibilityKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"VisibilityKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"None"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only unsettable"
-				value      	4)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write unsettable"
-				value      	5)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlNamespace"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlFeatureKind"
-			value      	("FeatureKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"FeatureKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Attribute"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Element"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"referenceName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isResolveProxies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"visibility"
-			value      	("VisibilityKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"VisibilityKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"None"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only unsettable"
-				value      	4)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write unsettable"
-				value      	5)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlNamespace"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlFeatureKind"
-			value      	("FeatureKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"FeatureKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Attribute"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Element"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"propertyId"
-		value      	"809135969"))
-	quid       	"3B86F1720171"))
diff --git a/plugins/org.eclipse.jem/rose/instantiation.cat b/plugins/org.eclipse.jem/rose/instantiation.cat
deleted file mode 100644
index 00ad0d2..0000000
--- a/plugins/org.eclipse.jem/rose/instantiation.cat
+++ /dev/null
@@ -1,2953 +0,0 @@
-
-(object Petal
-    version    	47
-    _written   	"Rose 8.0.0303.1400"
-    charSet    	0)
-
-(object Class_Category "instantiation"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    attributes 	(list Attribute_Set
-	(object Attribute
-	    tool       	"Ecore"
-	    name       	"basePackage"
-	    value      	(value Text "org.eclipse.jem.internal")))
-    quid       	"3B86F1720180"
-    documentation 	"Java Instantiation Package"
-    exportControl 	"Public"
-    logical_models 	(list unit_reference_list
-	(object Class "IJavaDataTypeInstance"
-	    quid       	"3B8AB17802B1"
-	    stereotype 	"Interface"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3E529562014E"
-		    supplier   	"Logical View::instantiation::IJavaInstance"
-		    quidu      	"3E51575A02D4"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "org.eclipse.jem.internal.instantiation.base.IJavaDataTypeInstance"
-		    quid       	"3B8AB19100C2"
-		    stereotype 	"javaclass")))
-	(object Class "IJavaInstance"
-	    quid       	"3E51575A02D4"
-	    stereotype 	"Interface"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "org.eclipse.jem.internal.instantiation.base.IJavaInstance"
-		    quid       	"3E51577802B9"
-		    stereotype 	"javaclass")))
-	(object Class "IJavaObjectInstance"
-	    quid       	"3B782D790296"
-	    documentation 	"This interface is the instance of an java object in the java model."
-	    stereotype 	"Interface"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3E5157DA03DD"
-		    supplier   	"Logical View::instantiation::IJavaInstance"
-		    quidu      	"3E51575A02D4"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "org.eclipse.jem.internal.instantiation.base.IJavaObjectInstance"
-		    quid       	"3B78301801C9"
-		    stereotype 	"javaclass")))
-	(object Class "JavaAllocation"
-	    quid       	"3FD9E6900061"
-	    documentation 	
-|This class is the abstract base class of the allocation class. It is the value of the "allocation" property on a Java Object so that the actual allocation can be controlled. For example, there could be one for just init string, or one for serialized.
-	    
-	    abstract   	TRUE)
-	(object Class "InitStringAllocation"
-	    quid       	"3FD9EAF9001E"
-	    documentation 	"This is used when the allocation string can be parsed by the remote vm. It uses the allocString."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3FD9EB7502DA"
-		    supplier   	"Logical View::instantiation::JavaAllocation"
-		    quidu      	"3FD9E6900061"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "initString"
-		    quid       	"3FFDE1DE032E"
-		    documentation 	"This is the initialization string for this object."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "ImplicitAllocation"
-	    quid       	"3FD9EC140242"
-	    documentation 	"This class is for an implicit allocation where the object comes from the feature of another object. It is the live Java value from the remote vm."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"3FD9EC4700E7"
-		    supplier   	"Logical View::instantiation::JavaAllocation"
-		    quidu      	"3FD9E6900061")))
-	(object Class "ParseTreeAllocation"
-	    quid       	"40082C910005"
-	    documentation 	"Allocations via Parse Trees."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40082CB701D6"
-		    supplier   	"Logical View::instantiation::JavaAllocation"
-		    quidu      	"3FD9E6900061")))
-	(object Class "PTExpression"
-	    quid       	"40082D0A01CB"
-	    abstract   	TRUE)
-	(object Class "PTArrayAccess"
-	    quid       	"40082E140250"
-	    documentation 	
-|Array access. e.g. x[3]. 
-|
-|Unlike AST, the entire expression of type x[3][4] will be done in one expression rather than having a separate ArrayAccess for each dimension. This is just a simplification. This can only be used if it is a simple array access where it is of the form {expression}[expression][expression].
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40082E6F01F7"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "array"
-		    quid       	"40082E8E0237"
-		    documentation 	"The expression representing the array to access."
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "indexes"
-		    quid       	"40082E9B007D"
-		    documentation 	"The expressions representing the indexes of the access."
-		    stereotype 	"1..*"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTArrayCreation"
-	    quid       	"40083712025A"
-	    documentation 	
-|Array Creation expression, e.g. new int[3] or new java.langString[][] {{"a"}, {"b"}}
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400837210049"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "type"
-		    quid       	"400837E902BD"
-		    documentation 	"The fully-qualified type, e.g. int[][] or java.lang.String[], including the number of dimension brackets."
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "dimensions"
-		    quid       	"4008389501E8"
-		    documentation 	"The list of expressions for the dimensions. You can have [3][4][] but [][33] is invalid. So for each dimension that has an expression, there will be an entry in the list, in the correct order. When you reach the empty dimensions, the list will end too. "
-		    stereotype 	"0..*"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "initializer"
-		    quid       	"4008397C0231"
-		    documentation 	"This is the initializer, if any, for this array. E.g. new int[] {2,3}. It is the {2,3}."
-		    type       	"PTArrayInitializer"
-		    quidu      	"40083968014C"
-		    exportControl 	"Public")))
-	(object Class "PTArrayInitializer"
-	    quid       	"40083968014C"
-	    documentation 	"Array initialization expression. This is the entire expression, e.g. {2, 3}, or {{2,3}, 4}. In the second case, the {2,3} will be an ArrayInitializer contained within the expressions list for the top ArrayInitializer."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400839790038"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "expressions"
-		    quid       	"40083A5700EB"
-		    documentation 	"This isthe list of expressions within the initializer, e.g. {2, 3}, or {{2,3}, 4}. In the first case it will be two NumberLiterals. In the second case, the {2,3} will be an ArrayInitializer, followed by a NumberLiteral."
-		    stereotype 	"0..*"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTBooleanLiteral"
-	    quid       	"40083AE70247"
-	    documentation 	"This represents a primitive boolean literal, i.e. true or false directly in the code."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40083B1D0000"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "booleanValue"
-		    quid       	"40083B3D001A"
-		    documentation 	"The value of the literal."
-		    type       	"boolean"
-		    exportControl 	"Public")))
-	(object Class "PTCastExpression"
-	    quid       	"40083B6F0058"
-	    documentation 	"Cast expression, e.g. (short) 10"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40083BD60309"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "type"
-		    quid       	"40083B9600F4"
-		    documentation 	"This is the fully-qualified type of the cast, e.g. int or java.lang.String"
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "expression"
-		    quid       	"40083BB6033F"
-		    documentation 	"The expression being casted."
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTCharacterLiteral"
-	    quid       	"40084DF10277"
-	    documentation 	"This represents a primitive character expression, e.g. 'a' or '\\r'."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40084E1301EA"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "escapedValue"
-		    quid       	"40084E39014E"
-		    documentation 	"This is the escaped character. In other words the literal exactly as it is in the java file. E.g. 'a' or '\\r'. Including the surrounding single quotes themselves."
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "charValue"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE))
-		    quid       	"40084EB702CC"
-		    documentation 	"The actual primitive character without the quotes. Escape are evaluated and turned into their character value. This is a transient field. If not set when created when queried it will create it. Typically it will be set when created from an AST node since the node already has evaluated it."
-		    type       	"char"
-		    exportControl 	"Public")))
-	(object Class "PTClassInstanceCreation"
-	    quid       	"40084F40026F"
-	    documentation 	
-|Class instance creation expression. E.g. new String("a")
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40084F4C02F8"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "type"
-		    quid       	"40084FAD0294"
-		    documentation 	
-|This is the type of the class. E.g. java.lang.String. This should be fully-qualified for allocation purposes. It should also be in reflection format, i.e. if X is an inner class of j.Y, then the type here should be "j.Y$X". 
-		    
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "arguments"
-		    quid       	"4008515E0138"
-		    documentation 	"The arguments to the constructor."
-		    stereotype 	"0..*"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTConditionalExpression"
-	    quid       	"400851FB026A"
-	    documentation 	"The test Expresson, e.g. (x=3) ? 1 : 2"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40085274012E"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "condition"
-		    quid       	"4008521D02AF"
-		    documentation 	"The condition expression."
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "true"
-		    quid       	"400852410333"
-		    documentation 	"The true expression"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "false"
-		    quid       	"4008525F0296"
-		    documentation 	"The false expression."
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTFieldAccess"
-	    quid       	"400852DF0204"
-	    documentation 	"Access a field expression, e.g. java.awt.Color.red"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"4008535D0241"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "receiver"
-		    quid       	"40085313012C"
-		    documentation 	"The expression representing the object that the field is in, e.g. java.awt.Color."
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "field"
-		    quid       	"4008534500AC"
-		    documentation 	"The name of the field being accessed, e.g. red."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTInfixExpression"
-	    quid       	"4008538B0143"
-	    documentation 	"An expression with an operator that has two operands, e.g. 3 + 4."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400855700032"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "leftOperand"
-		    quid       	"400853AC0000"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "operator"
-		    quid       	"400853B600D7"
-		    documentation 	"The operator, e.g. +"
-		    type       	"PTInfixOperator"
-		    quidu      	"400853E10359"
-		    exportControl 	"Public")
-		(object ClassAttribute "rightOperand"
-		    quid       	"4008540D0186"
-		    documentation 	
-|The right expression. i.e. 4 of "3 + 4"
-		    
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "extendedOperands"
-		    quid       	"40085511039C"
-		    documentation 	"Used when there are a series of infix operations of the same operator, e.g. 1 + 2 + 3 + 4. 1 and 2 will go into left and right, while {3, 4} will go into the extended operands. "
-		    stereotype 	"0..*"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTInfixOperator"
-	    quid       	"400853E10359"
-	    documentation 	"Enumerator for the operator on an InfixExpression."
-	    stereotype 	"enumeration"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "TIMES"
-		    quid       	"400856830240"
-		    documentation 	"* operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "DIVIDE"
-		    quid       	"4008568E01E2"
-		    documentation 	"/ operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "REMAINDER"
-		    quid       	"4008569202BA"
-		    documentation 	"% operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "PLUS"
-		    quid       	"40085697039D"
-		    documentation 	"+ operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "MINUS"
-		    quid       	"4008569C01D8"
-		    documentation 	"- operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "LEFT_SHIFT"
-		    quid       	"400856B50274"
-		    documentation 	"<< operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "RIGHT_SHIFT_SIGNED"
-		    quid       	"400856BA00CD"
-		    documentation 	">> operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "RIGHT_SHIFT_UNSIGNED"
-		    quid       	"400856C3038D"
-		    documentation 	">>> operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "LESS"
-		    quid       	"400856CC03CC"
-		    documentation 	"<  operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "GREATER"
-		    quid       	"400856D9001D"
-		    documentation 	"> operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "LESS_EQUALS"
-		    quid       	"400856DD004B"
-		    documentation 	"<= operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "GREATER_EQUALS"
-		    quid       	"400856E5029B"
-		    documentation 	">= operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "EQUALS"
-		    quid       	"400856EC0273"
-		    documentation 	"== operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "NOT_EQUALS"
-		    quid       	"400856F9039E"
-		    documentation 	"!= operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "XOR"
-		    quid       	"400857010328"
-		    documentation 	"^ operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "AND"
-		    quid       	"40085712034A"
-		    documentation 	"& operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "OR"
-		    quid       	"4008570402FA"
-		    documentation 	"|  operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "CONDITIONAL_AND"
-		    quid       	"400857160075"
-		    documentation 	"&& operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "CONDITIONAL_OR"
-		    quid       	"4008572602BD"
-		    documentation 	"|| operator"
-		    exportControl 	"Public")))
-	(object Class "PTInstanceof"
-	    quid       	"400857D303A2"
-	    documentation 	"Instanceof expression, e.g. x instanceof java.lang.String"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"4008589103AF"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "operand"
-		    quid       	"400858070234"
-		    documentation 	"The value to test, e.g. x in x instanceof java.lang.String"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "type"
-		    quid       	"4008582A0220"
-		    documentation 	"The type of the instance test, e.g. java.lang.String. It must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTMethodInvocation"
-	    quid       	"400858B6018B"
-	    documentation 	"MethodInvocation expression, e.g. x.getY(3)"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40085B9D0067"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "receiver"
-		    quid       	"40085B0A01EC"
-		    documentation 	
-|Who the method is invoked against. This may be not set, which means "this". It may also be a Name, which would mean a class like "java.lang.String"
-		    
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")
-		(object ClassAttribute "name"
-		    quid       	"40085B6100D9"
-		    documentation 	"The name of the method being invoked."
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "arguments"
-		    quid       	"40085B6902ED"
-		    documentation 	"The list of arguments, if any, to the method."
-		    stereotype 	"0..*"
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTName"
-	    quid       	"400858EA0280"
-	    documentation 	
-|This represents a name. This can happen for the receiver of a method invocation, e.g. x.getY() or java.lang.String.valueOf(10). In these cases you would have a name of "x" or "java.lang.String".
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40085BA100DB"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "name"
-		    quid       	"400C110401BE"
-		    documentation 	"The name, which can be a type or a variable. If it is a type, then  it must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTNullLiteral"
-	    quid       	"40085BBF0020"
-	    documentation 	
-|Represents the expression "null"
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40085BD402F1"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB")))
-	(object Class "PTNumberLiteral"
-	    quid       	"40085C40035B"
-	    documentation 	"Represent a number primitive literal, e.g. 10. One optimization that will be performed is that if an expression is of the form +number or -number, it will be converted from a PrefixExpression with a NumberLiteral to just a NumberLiteral. This will simplify the model."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40085CEF0244"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "token"
-		    quid       	"40085CAA024F"
-		    documentation 	"The token value, e.g. 10, 10d, or -10.75"
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTParenthesizedExpression"
-	    quid       	"40085CF9007C"
-	    documentation 	"An expression within parenthesis, e.g. (x+3)"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40085F4E03E1"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "expression"
-		    quid       	"40085F22012B"
-		    documentation 	
-|The expression wrapped by the parenthesis, e.g. (x+3) then the expression is "x+3"
-		    
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTPrefixExpression"
-	    quid       	"40085FAD008B"
-	    documentation 	
-|A one operand operator, where the operator comes before the operand, e.g. - (x+3). In AST, even -3 is modeled as a PrefixExpression of operator "-" and expression of NumberLiteral(3). But we optimize this away and just use a NumberLiteral(-3) directly instead.
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400862DC01D7"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "operator"
-		    quid       	"400860BC0199"
-		    documentation 	"The operator of this expression."
-		    type       	"PTPrefixOperator"
-		    quidu      	"4008602400D2"
-		    exportControl 	"Public")
-		(object ClassAttribute "expression"
-		    quid       	"400860C50065"
-		    documentation 	"The expression that the operator is applied to."
-		    type       	"PTExpression"
-		    quidu      	"40082D0A01CB"
-		    exportControl 	"Public")))
-	(object Class "PTPrefixOperator"
-	    quid       	"4008602400D2"
-	    documentation 	"The prefix expression operator. We are not modeling ++ and --."
-	    stereotype 	"enumeration"
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "PLUS"
-		    quid       	"4008606F01B6"
-		    documentation 	"+ operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "MINUS"
-		    quid       	"4008607203B9"
-		    documentation 	"- operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "COMPLEMENT"
-		    quid       	"4008607800AB"
-		    documentation 	"~ operator"
-		    exportControl 	"Public")
-		(object ClassAttribute "NOT"
-		    quid       	"4008607D0148"
-		    documentation 	"! operator"
-		    exportControl 	"Public")))
-	(object Class "PTStringLiteral"
-	    quid       	"400861E2000B"
-	    documentation 	
-|Representation of a string literal, e.g. "asdf".
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400862D70338"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "escapedValue"
-		    quid       	"400861FC01CB"
-		    documentation 	
-|This is the escaped string. In other words the literal exactly as it is in the java file. E.g. "ab" or "c\r". Including the surrounding quotes themselves.
-		    
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "literalValue"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE))
-		    quid       	"4008620A00BD"
-		    documentation 	"The actual string without the quotes. Escape are evaluated and turned into their character value. This is a transient field. If not set when created when queried it will create it. Typically it will be set when created from an AST node since the node already has evaluated it."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTThisLiteral"
-	    quid       	"400863A700CB"
-	    documentation 	
-|Represents "this", e.g. this.getX() will be a MethodInvocation with the receiver being a ThisLiteral. We can't handle the format XYZ.this because that is for inner classes and we don't support that right now.
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"40086418019F"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB")))
-	(object Class "PTTypeLiteral"
-	    quid       	"400864950181"
-	    documentation 	"This represents a literal of the form j.XYZ.class. For instance in a method invocation x.getX(jXYZ.class) the argument will be a TypeLiteral."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"4008654C0008"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "type"
-		    quid       	"400864D7037B"
-		    documentation 	"The type of the literal.  It must be fully-qualified. If it is an inner class, it needs to be in reflection format, i.e. Y is inner class of j.X, then a reference to Y must be j.X$Y."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTInvalidExpression"
-	    quid       	"400865AF0209"
-	    documentation 	"This is used when we have some expression we just can't evaluate for our purposes. It allows us to tell the evaluation what is actually wrong. It should be placed as the root expression to prevent processing much of the tree and then finally fail."
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"400866F50258"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "message"
-		    quid       	"400866E40299"
-		    documentation 	"A message as to why it is invalid."
-		    type       	"String"
-		    exportControl 	"Public")))
-	(object Class "PTInstanceReference"
-	    quid       	"4017DB1802B3"
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"4017DB4A0341"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB")))
-	(object Class "PTAnonymousClassDeclaration"
-	    quid       	"43627C140396"
-	    documentation 	
-|An anonymous class declaration. Currently we only store the 
-|entire declaration as a string, including the "new AClass() {...}".
-	    
-	    superclasses 	(list inheritance_relationship_list
-		(object Inheritance_Relationship
-		    quid       	"43627D4E00D0"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"))
-	    class_attributes 	(list class_attribute_list
-		(object ClassAttribute "declaration"
-		    quid       	"43627D690147"
-		    documentation 	"The declaration text."
-		    type       	"String"
-		    exportControl 	"Public")
-		(object ClassAttribute "imports"
-		    attributes 	(list Attribute_Set
-			(object Attribute
-			    tool       	"Ecore"
-			    name       	"isTransient"
-			    value      	TRUE))
-		    quid       	"436289E5034B"
-		    documentation 	"This is the imports needed in the main class by this declaration. This is a transient attribute. It is not serialized, nor is it parsed into from existing code. Its only purpose is to help code generation on a brand new declaration to know what imports should be added to the main class."
-		    stereotype 	"0..*"
-		    type       	"String"
-		    exportControl 	"Implementation")))
-	(object Association "$UNNAMED$0"
-	    quid       	"3FD9ED7103D5"
-	    documentation 	"The parent who is to give up the value."
-	    roles      	(list role_list
-		(object Role "parent"
-		    quid       	"3FD9ED720390"
-		    label      	"parent"
-		    supplier   	"Logical View::ecore::EObject"
-		    quidu      	"3C4F1C860123"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$1"
-		    quid       	"3FD9ED72039A"
-		    supplier   	"Logical View::instantiation::ImplicitAllocation"
-		    quidu      	"3FD9EC140242")))
-	(object Association "$UNNAMED$2"
-	    quid       	"3FD9EDD00088"
-	    documentation 	"The feature that will be used to query the live value."
-	    roles      	(list role_list
-		(object Role "feature"
-		    quid       	"3FD9EDD10148"
-		    label      	"feature"
-		    supplier   	"Logical View::ecore::EStructuralFeature"
-		    quidu      	"3903D59D0230"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Reference"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$3"
-		    quid       	"3FD9EDD10152"
-		    supplier   	"Logical View::instantiation::ImplicitAllocation"
-		    quidu      	"3FD9EC140242")))
-	(object Association "$UNNAMED$4"
-	    quid       	"400834CE001B"
-	    documentation 	"The root expression of the parse tree. The result of it is the allocation."
-	    roles      	(list role_list
-		(object Role "expression"
-		    quid       	"400834CF02E4"
-		    label      	"expression"
-		    supplier   	"Logical View::instantiation::PTExpression"
-		    quidu      	"40082D0A01CB"
-		    client_cardinality 	(value cardinality "1")
-		    Containment 	"By Value"
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$5"
-		    quid       	"400834CF02E6"
-		    supplier   	"Logical View::instantiation::ParseTreeAllocation"
-		    quidu      	"40082C910005"
-		    Containment 	"By Value"
-		    is_aggregate 	TRUE)))
-	(object Association "$UNNAMED$6"
-	    quid       	"4017DBE30138"
-	    roles      	(list role_list
-		(object Role "reference"
-		    quid       	"4017DBE60006"
-		    label      	"reference"
-		    supplier   	"Logical View::instantiation::IJavaInstance"
-		    quidu      	"3E51575A02D4"
-		    client_cardinality 	(value cardinality "1")
-		    is_navigable 	TRUE)
-		(object Role "$UNNAMED$7"
-		    quid       	"4017DBE60164"
-		    supplier   	"Logical View::instantiation::PTInstanceReference"
-		    quidu      	"4017DB1802B3"
-		    Containment 	"By Reference"))))
-    logical_presentations 	(list unit_reference_list
-	(object ClassDiagram "Main"
-	    quid       	"3B782D1B034F"
-	    title      	"Main"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	0
-	    items      	(list diagram_item_list
-		(object NoteView @1
-		    location   	(747, 1008)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@1
-			location   	(342, 854)
-			fill_color 	13434879
-			nlines     	6
-			max_width  	775
-			label      	"This is used as the EClassifier when you want a code-generated class to point to an instance of a IJavaObjectInstance implementer. (Which is an instance of a java model java object).")
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	835
-		    height     	320)
-		(object ClassView "Class" "Logical View::instantiation::IJavaDataTypeInstance" @2
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2659, 664)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@2
-			location   	(1777, 605)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1764
-			justify    	0
-			label      	"IJavaDataTypeInstance")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@2
-			location   	(1777, 555)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	1764
-			justify    	0
-			label      	"<<Interface>>")
-		    icon       	"Interface"
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3B8AB17802B1"
-		    compartment 	(object Compartment
-			Parent_View 	@2
-			location   	(1777, 666)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	1512)
-		    width      	1782
-		    height     	242
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object NoteView @3
-		    location   	(2378, 1053)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@3
-			location   	(1970, 889)
-			fill_color 	13434879
-			nlines     	7
-			max_width  	780
-			label      	"This is used as the EClassifier when you want a code-generated class to point to an instance of an IJavaDataTypeInstance implementer. (Which is an instance of a java model java primitive).")
-		    line_color 	3342489
-		    fill_color 	13434879
-		    width      	840
-		    height     	340)
-		(object AttachView "" @4
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@2
-		    supplier   	@3
-		    line_style 	0)
-		(object ClassView "Class" "Logical View::instantiation::IJavaInstance" @5
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1584, 166)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@5
-			location   	(804, 85)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	1560
-			justify    	0
-			label      	"IJavaInstance")
-		    icon       	"Interface"
-		    icon_style 	"None"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3E51575A02D4"
-		    compartment 	(object Compartment
-			Parent_View 	@5
-			location   	(804, 146)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	1340)
-		    width      	1578
-		    height     	186
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @6
-		    location   	(1584, 455)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@5
-		    vertices   	(list Points
-			(1584, 455)
-			(1584, 259)))
-		(object ClassView "Class" "Logical View::instantiation::IJavaObjectInstance" @7
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    ShowOperationSignature 	TRUE
-		    location   	(858, 666)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@7
-			location   	(627, 614)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	480
-			justify    	0
-			label      	"IJavaObjectInstance")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@7
-			location   	(627, 564)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	462
-			justify    	0
-			label      	"<<Interface>>")
-		    icon       	"Interface"
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3B782D790296"
-		    compartment 	(object Compartment
-			Parent_View 	@7
-			location   	(627, 675)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	1459)
-		    width      	480
-		    height     	228
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object AttachView "" @8
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    client     	@1
-		    supplier   	@7
-		    line_style 	0)
-		(object InheritView "" @9
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3E5157DA03DD"
-		    client     	@7
-		    supplier   	@5
-		    line_style 	3
-		    origin_attachment 	(795, 552)
-		    terminal_attachment 	(795, 455)
-		    drawSupplier 	@6)
-		(object InheritView "" @10
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3E529562014E"
-		    client     	@2
-		    supplier   	@5
-		    line_style 	3
-		    origin_attachment 	(2659, 543)
-		    terminal_attachment 	(2659, 455)
-		    drawSupplier 	@6)))
-	(object ClassDiagram "Java Constructors"
-	    quid       	"3FD9E66D007F"
-	    title      	"Java Constructors"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	0
-	    origin_y   	0
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::instantiation::JavaAllocation" @11
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1073, 120)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@11
-			location   	(902, 69)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	342
-			justify    	0
-			label      	"JavaAllocation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3FD9E6900061"
-		    width      	360
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::InitStringAllocation" @12
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(553, 495)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@12
-			location   	(329, 414)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	448
-			justify    	0
-			label      	"InitStringAllocation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3FD9EAF9001E"
-		    width      	466
-		    height     	186
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @13
-		    location   	(1073, 323)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@11
-		    vertices   	(list Points
-			(1073, 323)
-			(1073, 183)))
-		(object InheritView "" @14
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3FD9EB7502DA"
-		    client     	@12
-		    supplier   	@11
-		    line_style 	3
-		    origin_attachment 	(668, 401)
-		    terminal_attachment 	(668, 323)
-		    drawSupplier 	@13)
-		(object ClassView "Class" "Logical View::ecore::EObject" @15
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(1751, 942)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@15
-			location   	(1645, 896)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	212
-			justify    	0
-			label      	"EObject")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"3C4F1C860123"
-		    width      	230
-		    height     	117
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::ecore::EStructuralFeature" @16
-		    ShowCompartmentStereotypes 	TRUE
-		    location   	(2142, 927)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@16
-			location   	(1918, 881)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	448
-			justify    	0
-			label      	"EStructuralFeature")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	16776960
-		    quidu      	"3903D59D0230"
-		    width      	466
-		    height     	117
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::ImplicitAllocation" @17
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2018, 510)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@17
-			location   	(1819, 458)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	398
-			justify    	0
-			label      	"ImplicitAllocation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3FD9EC140242"
-		    width      	416
-		    height     	128
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @18
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3FD9EC4700E7"
-		    client     	@17
-		    supplier   	@11
-		    line_style 	3
-		    origin_attachment 	(2023, 446)
-		    terminal_attachment 	(2023, 323)
-		    drawSupplier 	@13)
-		(object AssociationViewNew "$UNNAMED$0" @19
-		    location   	(1881, 728)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3FD9ED7103D5"
-		    roleview_list 	(list RoleViews
-			(object RoleView "parent" @20
-			    Parent_View 	@19
-			    location   	(716, 228)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @21
-				Parent_View 	@20
-				location   	(1727, 844)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	137
-				justify    	0
-				label      	"+parent"
-				pctDist    	0.991224
-				height     	72
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3FD9ED720390"
-			    client     	@19
-			    supplier   	@15
-			    line_style 	0
-			    label      	(object SegLabel @22
-				Parent_View 	@20
-				location   	(1871, 794)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.337817
-				height     	26
-				orientation 	0))
-			(object RoleView "$UNNAMED$1" @23
-			    Parent_View 	@19
-			    location   	(716, 228)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3FD9ED72039A"
-			    client     	@19
-			    supplier   	@17
-			    line_style 	0)))
-		(object AssociationViewNew "$UNNAMED$2" @24
-		    location   	(2080, 721)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"3FD9EDD00088"
-		    roleview_list 	(list RoleViews
-			(object RoleView "feature" @25
-			    Parent_View 	@24
-			    location   	(915, 221)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @26
-				Parent_View 	@25
-				location   	(2028, 766)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	159
-				justify    	0
-				label      	"+feature"
-				pctDist    	0.181346
-				height     	64
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3FD9EDD10148"
-			    client     	@24
-			    supplier   	@16
-			    line_style 	0
-			    label      	(object SegLabel @27
-				Parent_View 	@25
-				location   	(2172, 839)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "$UNNAMED$3" @28
-			    Parent_View 	@24
-			    location   	(915, 221)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"3FD9EDD10152"
-			    client     	@24
-			    supplier   	@17
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::instantiation::PTExpression" @29
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1264, 776)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@29
-			location   	(1095, 725)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	338
-			justify    	0
-			label      	"PTExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	12615935
-		    quidu      	"40082D0A01CB"
-		    width      	356
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::ParseTreeAllocation" @30
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1265, 495)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@30
-			location   	(1032, 443)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	466
-			justify    	0
-			label      	"ParseTreeAllocation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40082C910005"
-		    width      	484
-		    height     	128
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @31
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40082CB701D6"
-		    client     	@30
-		    supplier   	@11
-		    line_style 	3
-		    origin_attachment 	(1265, 431)
-		    terminal_attachment 	(1265, 323)
-		    drawSupplier 	@13)
-		(object AssociationViewNew "$UNNAMED$4" @32
-		    location   	(1264, 635)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400834CE001B"
-		    roleview_list 	(list RoleViews
-			(object RoleView "expression" @33
-			    Parent_View 	@32
-			    location   	(-1, 140)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @34
-				Parent_View 	@33
-				location   	(1111, 672)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	220
-				justify    	0
-				label      	"+expression"
-				pctDist    	0.492537
-				height     	154
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"400834CF02E4"
-			    client     	@32
-			    supplier   	@29
-			    line_style 	0
-			    label      	(object SegLabel @35
-				Parent_View 	@33
-				location   	(1307, 679)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.567164
-				height     	43
-				orientation 	0))
-			(object RoleView "$UNNAMED$5" @36
-			    Parent_View 	@32
-			    location   	(-1, 140)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"400834CF02E6"
-			    client     	@32
-			    supplier   	@30
-			    line_style 	0)))))
-	(object ClassDiagram "Parse Tree Expressions"
-	    quid       	"40082CC20146"
-	    title      	"Parse Tree Expressions"
-	    zoom       	100
-	    max_height 	28350
-	    max_width  	21600
-	    origin_x   	25
-	    origin_y   	5768
-	    items      	(list diagram_item_list
-		(object ClassView "Class" "Logical View::instantiation::PTExpression" @37
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1348, 124)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@37
-			location   	(1179, 73)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	338
-			justify    	0
-			label      	"PTExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40082D0A01CB"
-		    width      	356
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTArrayAccess" @38
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2235, 544)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@38
-			location   	(1848, 413)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	774
-			justify    	0
-			label      	"PTArrayAccess")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40082E140250"
-		    width      	792
-		    height     	286
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTArrayCreation" @39
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(434, 519)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@39
-			location   	(9, 363)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	850
-			justify    	0
-			label      	"PTArrayCreation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40083712025A"
-		    width      	868
-		    height     	336
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTArrayInitializer" @40
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1361, 519)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@40
-			location   	(929, 438)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	864
-			justify    	0
-			label      	"PTArrayInitializer")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40083968014C"
-		    width      	882
-		    height     	186
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTBooleanLiteral" @41
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(997, 870)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@41
-			location   	(719, 790)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	556
-			justify    	0
-			label      	"PTBooleanLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40083AE70247"
-		    width      	574
-		    height     	184
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTCastExpression" @42
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1791, 889)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@42
-			location   	(1474, 758)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	634
-			justify    	0
-			label      	"PTCastExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40083B6F0058"
-		    width      	652
-		    height     	286
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @43
-		    location   	(1348, 330)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@37
-		    vertices   	(list Points
-			(1348, 330)
-			(1348, 187)))
-		(object InheritView "" @44
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400839790038"
-		    client     	@40
-		    supplier   	@37
-		    line_style 	3
-		    origin_attachment 	(1381, 425)
-		    terminal_attachment 	(1381, 330)
-		    drawSupplier 	@43)
-		(object InheritView "" @45
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40083B1D0000"
-		    client     	@41
-		    supplier   	@37
-		    line_style 	3
-		    origin_attachment 	(918, 778)
-		    terminal_attachment 	(918, 330)
-		    drawSupplier 	@43)
-		(object InheritView "" @46
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40083BD60309"
-		    client     	@42
-		    supplier   	@37
-		    line_style 	3
-		    origin_attachment 	(1791, 746)
-		    terminal_attachment 	(1791, 330)
-		    drawSupplier 	@43)
-		(object InheritView "" @47
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40082E6F01F7"
-		    client     	@38
-		    supplier   	@37
-		    line_style 	3
-		    origin_attachment 	(2235, 401)
-		    terminal_attachment 	(2235, 330)
-		    drawSupplier 	@43)
-		(object ClassView "Class" "Logical View::instantiation::PTExpression" @48
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1372, 1095)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@48
-			location   	(1203, 1044)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	338
-			justify    	0
-			label      	"PTExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	12615935
-		    quidu      	"40082D0A01CB"
-		    width      	356
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTCharacterLiteral" @49
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(430, 1438)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@49
-			location   	(164, 1332)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	532
-			justify    	0
-			label      	"PTCharacterLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40084DF10277"
-		    width      	550
-		    height     	236
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @50
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400837210049"
-		    client     	@39
-		    supplier   	@37
-		    line_style 	3
-		    origin_attachment 	(561, 351)
-		    terminal_attachment 	(561, 330)
-		    drawSupplier 	@43)
-		(object ClassView "Class" "Logical View::instantiation::PTClassInstanceCreation" @51
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1346, 1464)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@51
-			location   	(930, 1333)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	832
-			justify    	0
-			label      	"PTClassInstanceCreation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40084F40026F"
-		    width      	850
-		    height     	286
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @52
-		    location   	(1372, 1260)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@48
-		    vertices   	(list Points
-			(1372, 1260)
-			(1372, 1158)))
-		(object InheritView "" @53
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40084E1301EA"
-		    client     	@49
-		    supplier   	@48
-		    line_style 	3
-		    origin_attachment 	(564, 1319)
-		    terminal_attachment 	(564, 1260)
-		    drawSupplier 	@52)
-		(object InheritView "" @54
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40084F4C02F8"
-		    client     	@51
-		    supplier   	@48
-		    line_style 	3
-		    origin_attachment 	(1267, 1320)
-		    terminal_attachment 	(1267, 1260)
-		    drawSupplier 	@52)
-		(object ClassView "Class" "Logical View::instantiation::PTConditionalExpression" @55
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2169, 1481)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@55
-			location   	(1872, 1325)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	594
-			justify    	0
-			label      	"PTConditionalExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400851FB026A"
-		    width      	612
-		    height     	336
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @56
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40085274012E"
-		    client     	@55
-		    supplier   	@48
-		    line_style 	3
-		    origin_attachment 	(2168, 1313)
-		    terminal_attachment 	(2168, 1260)
-		    drawSupplier 	@52)
-		(object ClassView "Class" "Logical View::instantiation::PTFieldAccess" @57
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(761, 1794)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@57
-			location   	(479, 1663)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	564
-			justify    	0
-			label      	"PTFieldAccess")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400852DF0204"
-		    width      	582
-		    height     	286
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @58
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"4008535D0241"
-		    client     	@57
-		    supplier   	@48
-		    line_style 	3
-		    origin_attachment 	(760, 1651)
-		    terminal_attachment 	(760, 1260)
-		    drawSupplier 	@52)
-		(object ClassView "Class" "Logical View::instantiation::PTInfixExpression" @59
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1790, 1845)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@59
-			location   	(1286, 1664)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	1008
-			justify    	0
-			label      	"PTInfixExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"4008538B0143"
-		    width      	1026
-		    height     	386
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTInfixOperator" @60
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2660, 2207)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@60
-			location   	(2345, 1699)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	630
-			justify    	0
-			label      	"PTInfixOperator")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@60
-			location   	(2345, 1649)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	630
-			justify    	0
-			label      	"<<enumeration>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400853E10359"
-		    width      	648
-		    height     	1140
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @61
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400855700032"
-		    client     	@59
-		    supplier   	@48
-		    line_style 	3
-		    origin_attachment 	(1789, 1652)
-		    terminal_attachment 	(1789, 1260)
-		    drawSupplier 	@52)
-		(object ClassView "Class" "Logical View::instantiation::PTExpression" @62
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1272, 2853)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@62
-			location   	(1103, 2802)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	338
-			justify    	0
-			label      	"PTExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	12615935
-		    quidu      	"40082D0A01CB"
-		    width      	356
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTInstanceof" @63
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(371, 3255)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@63
-			location   	(85, 3124)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	572
-			justify    	0
-			label      	"PTInstanceof")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400857D303A2"
-		    compartment 	(object Compartment
-			Parent_View 	@63
-			location   	(85, 3185)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	3
-			max_width  	493)
-		    width      	590
-		    height     	286
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTMethodInvocation" @64
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1246, 3258)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@64
-			location   	(860, 3117)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	772
-			justify    	0
-			label      	"PTMethodInvocation")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400858B6018B"
-		    compartment 	(object Compartment
-			Parent_View 	@64
-			location   	(860, 3178)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	4
-			max_width  	715)
-		    width      	790
-		    height     	304
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTName" @65
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1962, 3212)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@65
-			location   	(1809, 3121)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	307
-			justify    	0
-			label      	"PTName")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400858EA0280"
-		    compartment 	(object Compartment
-			Parent_View 	@65
-			location   	(1809, 3182)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	2
-			max_width  	303)
-		    width      	325
-		    height     	205
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @66
-		    location   	(1272, 3061)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@62
-		    vertices   	(list Points
-			(1272, 3061)
-			(1272, 2916)))
-		(object InheritView "" @67
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"4008589103AF"
-		    client     	@63
-		    supplier   	@62
-		    line_style 	3
-		    origin_attachment 	(474, 3112)
-		    terminal_attachment 	(474, 3061)
-		    drawSupplier 	@66)
-		(object InheritView "" @68
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40085B9D0067"
-		    client     	@64
-		    supplier   	@62
-		    line_style 	3
-		    origin_attachment 	(1245, 3106)
-		    terminal_attachment 	(1245, 3061)
-		    drawSupplier 	@66)
-		(object InheritView "" @69
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40085BA100DB"
-		    client     	@65
-		    supplier   	@62
-		    line_style 	3
-		    origin_attachment 	(1905, 3110)
-		    terminal_attachment 	(1905, 3061)
-		    drawSupplier 	@66)
-		(object ClassView "Class" "Logical View::instantiation::PTNullLiteral" @70
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2328, 3195)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@70
-			location   	(2170, 3143)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	316
-			justify    	0
-			label      	"PTNullLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40085BBF0020"
-		    width      	334
-		    height     	128
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @71
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40085BD402F1"
-		    client     	@70
-		    supplier   	@62
-		    line_style 	3
-		    origin_attachment 	(2297, 3131)
-		    terminal_attachment 	(2297, 3061)
-		    drawSupplier 	@66)
-		(object ClassView "Class" "Logical View::instantiation::PTExpression" @72
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1243, 3867)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	TRUE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@72
-			location   	(1074, 3816)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	338
-			justify    	0
-			label      	"PTExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	12615935
-		    quidu      	"40082D0A01CB"
-		    width      	356
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTNumberLiteral" @73
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(802, 3583)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@73
-			location   	(619, 3489)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	367
-			justify    	0
-			label      	"PTNumberLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40085C40035B"
-		    compartment 	(object Compartment
-			Parent_View 	@73
-			location   	(619, 3550)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	2
-			max_width  	303)
-		    width      	385
-		    height     	210
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @74
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40085CEF0244"
-		    client     	@73
-		    supplier   	@62
-		    line_style 	3
-		    origin_attachment 	(730, 3478)
-		    terminal_attachment 	(730, 3061)
-		    drawSupplier 	@66)
-		(object ClassView "Class" "Logical View::instantiation::PTParenthesizedExpression" @75
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1679, 3609)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@75
-			location   	(1381, 3513)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	596
-			justify    	0
-			label      	"PTParenthesizedExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40085CF9007C"
-		    compartment 	(object Compartment
-			Parent_View 	@75
-			location   	(1381, 3574)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	2
-			max_width  	546)
-		    width      	614
-		    height     	214
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @76
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40085F4E03E1"
-		    client     	@75
-		    supplier   	@62
-		    line_style 	3
-		    origin_attachment 	(1677, 3502)
-		    terminal_attachment 	(1677, 3061)
-		    drawSupplier 	@66)
-		(object ClassView "Class" "Logical View::instantiation::PTPrefixExpression" @77
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(330, 4221)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@77
-			location   	(9, 4090)
-			fill_color 	13434879
-			nlines     	2
-			max_width  	642
-			justify    	0
-			label      	"PTPrefixExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"40085FAD008B"
-		    compartment 	(object Compartment
-			Parent_View 	@77
-			location   	(9, 4151)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	3
-			max_width  	553)
-		    width      	660
-		    height     	286
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTPrefixOperator" @78
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(233, 4602)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@78
-			location   	(34, 4468)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	398
-			justify    	0
-			label      	"PTPrefixOperator")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@78
-			location   	(34, 4418)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	398
-			justify    	0
-			label      	"<<enumeration>>")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"4008602400D2"
-		    compartment 	(object Compartment
-			Parent_View 	@78
-			location   	(34, 4529)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	16777215
-			anchor     	2
-			nlines     	5
-			max_width  	343)
-		    width      	416
-		    height     	392
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTStringLiteral" @79
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1025, 4196)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@79
-			location   	(849, 4092)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	352
-			justify    	0
-			label      	"PTStringLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400861E2000B"
-		    compartment 	(object Compartment
-			Parent_View 	@79
-			location   	(849, 4153)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	3
-			max_width  	459)
-		    width      	370
-		    height     	230
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritTreeView "" @80
-		    location   	(1243, 4020)
-		    line_color 	3342489
-		    fill_color 	13434879
-		    supplier   	@72
-		    vertices   	(list Points
-			(1243, 4020)
-			(1243, 3930)))
-		(object InheritView "" @81
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400862D70338"
-		    client     	@79
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(1008, 4081)
-		    terminal_attachment 	(1008, 4020)
-		    drawSupplier 	@80)
-		(object InheritView "" @82
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400862DC01D7"
-		    client     	@77
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(297, 4078)
-		    terminal_attachment 	(297, 4020)
-		    drawSupplier 	@80)
-		(object ClassView "Class" "Logical View::instantiation::PTThisLiteral" @83
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1655, 4180)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@83
-			location   	(1494, 4129)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	322
-			justify    	0
-			label      	"PTThisLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400863A700CB"
-		    width      	340
-		    height     	126
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @84
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"40086418019F"
-		    client     	@83
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(1627, 4117)
-		    terminal_attachment 	(1627, 4020)
-		    drawSupplier 	@80)
-		(object ClassView "Class" "Logical View::instantiation::PTTypeLiteral" @85
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2256, 4201)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@85
-			location   	(2093, 4106)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	327
-			justify    	0
-			label      	"PTTypeLiteral")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400864950181"
-		    compartment 	(object Compartment
-			Parent_View 	@85
-			location   	(2093, 4167)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	2
-			max_width  	281)
-		    width      	345
-		    height     	215
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @86
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"4008654C0008"
-		    client     	@85
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(2197, 4093)
-		    terminal_attachment 	(2197, 4020)
-		    drawSupplier 	@80)
-		(object ClassView "Class" "Logical View::instantiation::PTInvalidExpression" @87
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(1457, 4545)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@87
-			location   	(1279, 4449)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	357
-			justify    	0
-			label      	"PTInvalidExpression")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"400865AF0209"
-		    compartment 	(object Compartment
-			Parent_View 	@87
-			location   	(1279, 4510)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	2
-			max_width  	368)
-		    width      	375
-		    height     	215
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @88
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"400866F50258"
-		    client     	@87
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(1413, 4438)
-		    terminal_attachment 	(1413, 4020)
-		    drawSupplier 	@80)
-		(object ClassView "Class" "Logical View::instantiation::IJavaInstance" @89
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2301, 4917)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@89
-			location   	(2137, 4887)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	328
-			justify    	0
-			label      	"IJavaInstance")
-		    stereotype 	(object ItemLabel
-			Parent_View 	@89
-			location   	(2137, 4837)
-			fill_color 	13434879
-			anchor     	10
-			nlines     	1
-			max_width  	328
-			justify    	0
-			label      	"<<Interface>>")
-		    icon       	"Interface"
-		    icon_style 	"Label"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"3E51575A02D4"
-		    width      	346
-		    height     	184
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object ClassView "Class" "Logical View::instantiation::PTInstanceReference" @90
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(2005, 4509)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@90
-			location   	(1805, 4393)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	401
-			justify    	0
-			label      	"PTInstanceReference")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"4017DB1802B3"
-		    width      	419
-		    height     	257
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @91
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"4017DB4A0341"
-		    client     	@90
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(1943, 4381)
-		    terminal_attachment 	(1943, 4020)
-		    drawSupplier 	@80)
-		(object AssociationViewNew "$UNNAMED$6" @92
-		    location   	(2165, 4730)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"4017DBE30138"
-		    roleview_list 	(list RoleViews
-			(object RoleView "reference" @93
-			    Parent_View 	@92
-			    location   	(227, 259)
-			    font       	(object Font
-				size       	10
-				face       	"Arial"
-				bold       	FALSE
-				italics    	FALSE
-				underline  	FALSE
-				strike     	FALSE
-				color      	0
-				default_color 	TRUE)
-			    label      	(object SegLabel @94
-				Parent_View 	@93
-				location   	(2120, 4797)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	1
-				anchor_loc 	1
-				nlines     	1
-				max_width  	189
-				justify    	0
-				label      	"+reference"
-				pctDist    	0.231960
-				height     	77
-				orientation 	1)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"4017DBE60006"
-			    client     	@92
-			    supplier   	@89
-			    line_style 	0
-			    label      	(object SegLabel @95
-				Parent_View 	@93
-				location   	(2270, 4783)
-				font       	(object Font
-				    size       	10
-				    face       	"Arial"
-				    bold       	FALSE
-				    italics    	FALSE
-				    underline  	FALSE
-				    strike     	FALSE
-				    color      	0
-				    default_color 	TRUE)
-				anchor     	2
-				anchor_loc 	1
-				nlines     	1
-				max_width  	15
-				justify    	0
-				label      	"1"
-				pctDist    	0.900000
-				height     	54
-				orientation 	0))
-			(object RoleView "$UNNAMED$7" @96
-			    Parent_View 	@92
-			    location   	(227, 259)
-			    stereotype 	TRUE
-			    line_color 	3342489
-			    quidu      	"4017DBE60164"
-			    client     	@92
-			    supplier   	@90
-			    line_style 	0)))
-		(object ClassView "Class" "Logical View::instantiation::PTAnonymousClassDeclaration" @97
-		    ShowCompartmentStereotypes 	TRUE
-		    IncludeAttribute 	TRUE
-		    IncludeOperation 	TRUE
-		    location   	(852, 4577)
-		    font       	(object Font
-			size       	10
-			face       	"Arial"
-			bold       	FALSE
-			italics    	FALSE
-			underline  	FALSE
-			strike     	FALSE
-			color      	0
-			default_color 	TRUE)
-		    label      	(object ItemLabel
-			Parent_View 	@97
-			location   	(495, 4471)
-			fill_color 	13434879
-			nlines     	1
-			max_width  	714
-			justify    	0
-			label      	"PTAnonymousClassDeclaration")
-		    icon_style 	"Icon"
-		    line_color 	3342489
-		    fill_color 	13434879
-		    quidu      	"43627C140396"
-		    compartment 	(object Compartment
-			Parent_View 	@97
-			location   	(495, 4532)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			icon_style 	"Icon"
-			fill_color 	13434879
-			anchor     	2
-			nlines     	3
-			max_width  	503)
-		    width      	732
-		    height     	236
-		    annotation 	8
-		    autoResize 	TRUE)
-		(object InheritView "" @98
-		    stereotype 	TRUE
-		    line_color 	3342489
-		    quidu      	"43627D4E00D0"
-		    client     	@97
-		    supplier   	@72
-		    line_style 	3
-		    origin_attachment 	(677, 4459)
-		    terminal_attachment 	(677, 4020)
-		    drawSupplier 	@80)))))
diff --git a/plugins/org.eclipse.jem/rose/javaModel.mdl b/plugins/org.eclipse.jem/rose/javaModel.mdl
deleted file mode 100644
index 5efb92d..0000000
--- a/plugins/org.eclipse.jem/rose/javaModel.mdl
+++ /dev/null
@@ -1,8819 +0,0 @@
-
-(object Petal
-    version    	47
-    _written   	"Rose 8.0.0303.1400"
-    charSet    	0)
-
-(object Design "Logical View"
-    is_unit    	TRUE
-    is_loaded  	TRUE
-    attributes 	(list Attribute_Set
-	(object Attribute
-	    tool       	"Java"
-	    name       	"IDE"
-	    value      	"Internal Editor")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply1"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply2"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagName3"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagText3"
-	    value      	"")
-	(object Attribute
-	    tool       	"Java"
-	    name       	"UserDefineTagApply3"
-	    value      	""))
-    quid       	"39EDFBE003B4"
-    defaults   	(object defaults
-	rightMargin 	0.250000
-	leftMargin 	0.250000
-	topMargin  	0.250000
-	bottomMargin 	0.500000
-	pageOverlap 	0.250000
-	clipIconLabels 	TRUE
-	autoResize 	TRUE
-	snapToGrid 	TRUE
-	gridX      	16
-	gridY      	16
-	defaultFont 	(object Font
-	    size       	10
-	    face       	"Arial"
-	    bold       	FALSE
-	    italics    	FALSE
-	    underline  	FALSE
-	    strike     	FALSE
-	    color      	0
-	    default_color 	TRUE)
-	showMessageNum 	1
-	showClassOfObject 	TRUE
-	notation   	"Unified")
-    root_usecase_package 	(object Class_Category "Use Case View"
-	quid       	"39EDFBE003B6"
-	exportControl 	"Public"
-	global     	TRUE
-	logical_models 	(list unit_reference_list)
-	logical_presentations 	(list unit_reference_list
-	    (object UseCaseDiagram "Main"
-		quid       	"39EDFBE2008D"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    root_category 	(object Class_Category "Logical View"
-	quid       	"39EDFBE003B5"
-	exportControl 	"Public"
-	global     	TRUE
-	subsystem  	"Component View"
-	quidu      	"39EDFBE003B7"
-	logical_models 	(list unit_reference_list
-	    (object Class_Category "java"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.jem\\rose\\edocjava2.cat"
-		quid       	"36549F2C004E")
-	    (object Class_Category "ecore"
-		is_unit    	TRUE
-		is_loaded  	FALSE
-		file_name  	"$WorkspaceRoot\\org.eclipse.emf.ecore\\model\\org.eclipse.emf.Ecore.cat"
-		quid       	"39A5ED04004E"))
-	logical_presentations 	(list unit_reference_list
-	    (object ClassDiagram "Main"
-		quid       	"39EDFBE2008E"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list
-		    (object CategoryView "Logical View::java" @1
-			location   	(784, 528)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@1
-			    location   	(630, 493)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	308
-			    justify    	0
-			    label      	"java")
-			stereotype 	(object ItemLabel
-			    Parent_View 	@1
-			    location   	(630, 443)
-			    fill_color 	13434879
-			    anchor     	10
-			    nlines     	1
-			    max_width  	308
-			    justify    	0
-			    label      	"<<metamodel>>")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"36549F2C004E"
-			width      	320
-			height     	182)
-		    (object CategoryView "Logical View::ecore" @2
-			location   	(304, 544)
-			font       	(object Font
-			    size       	10
-			    face       	"Arial"
-			    bold       	FALSE
-			    italics    	FALSE
-			    underline  	FALSE
-			    strike     	FALSE
-			    color      	0
-			    default_color 	TRUE)
-			label      	(object ItemLabel
-			    Parent_View 	@2
-			    location   	(160, 460)
-			    fill_color 	13434879
-			    nlines     	2
-			    max_width  	288
-			    justify    	0
-			    label      	"ecore")
-			icon_style 	"Icon"
-			line_color 	3342489
-			fill_color 	13434879
-			quidu      	"39A5ED04004E"
-			width      	300
-			height     	180)))))
-    root_subsystem 	(object SubSystem "Component View"
-	quid       	"39EDFBE003B7"
-	physical_models 	(list unit_reference_list)
-	physical_presentations 	(list unit_reference_list
-	    (object Module_Diagram "Main"
-		quid       	"39EDFBE2008C"
-		title      	"Main"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    process_structure 	(object Processes
-	quid       	"39EDFBE003B8"
-	ProcsNDevs 	(list
-	    (object Process_Diagram "Deployment View"
-		quid       	"39EDFBE003BA"
-		title      	"Deployment View"
-		zoom       	100
-		max_height 	28350
-		max_width  	21600
-		origin_x   	0
-		origin_y   	0
-		items      	(list diagram_item_list))))
-    properties 	(object Properties
-	attributes 	(list Attribute_Set
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"roseId"
-		value      	"753117540")
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"propertyId"
-		value      	"809135969")
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsURI"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"prefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"packageName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"basePackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"nsPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"attributeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isID"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"visibility"
-			value      	("VisibilityKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"VisibilityKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"None"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only unsettable"
-				value      	4)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write unsettable"
-				value      	5)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlNamespace"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlFeatureKind"
-			value      	("FeatureKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"FeatureKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Attribute"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Element"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isTransient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isChangeable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnsettable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isResolveProxies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"referenceName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"visibility"
-			value      	("VisibilityKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"VisibilityKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"None"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-only unsettable"
-				value      	4)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Read-write unsettable"
-				value      	5)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlNamespace"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlFeatureKind"
-			value      	("FeatureKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"FeatureKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Attribute"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Element"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Const"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialValue"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Copyright"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RootPackage"
-			value      	"C++ Reverse Engineered")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialHeaderIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialBodyIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngRootDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngDirectoriesAsPackages"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"HeaderFileExtension"
-			value      	".h")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ImplementationFileExtension"
-			value      	".cpp")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewHeaderFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewImplementationFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalization"
-			value      	("FileCapitalizationSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectories"
-			value      	("CodeGenExtraDirectoriesSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"StripClassPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"UseTabs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"TabWidth"
-			value      	8)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"IndentWidth"
-			value      	4)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"AccessIndentation"
-			value      	-2)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRules"
-			value      	("ModelIdCommentRulesSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"PageWidth"
-			value      	80)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassMemberOrder"
-			value      	("MemberOrderSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"OneParameterPerLine"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NamespaceBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FunctionBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectoriesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Namespaces"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Packages"
-				value      	2)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalizationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Same as model"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Upper case"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case with underscores"
-				value      	3)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"BraceStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B1"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B2"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B3"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B4"
-				value      	4)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B5"
-				value      	5)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"MemberOrderSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Public First"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Private First"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Order by kind"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Unordered"
-				value      	4)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRulesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation only"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation and reverse engineering"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Never generate model IDs"
-				value      	3)))))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Param"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialCodeBody"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"GenerateFunctionBody"
-			value      	("GenerateFunctionBodySet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"GenerateFunctionBodySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Default"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"False"
-				value      	0)))))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ImplementationType"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"HeaderSourceFile"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"BodySourceFile"
-			value      	"")))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"IsNamespace"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ANSI C++ Event Watcher"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ANSIConvert"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"propertyId"
-		value      	"838326200")
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SpecFileExtension"
-			value      	"1.ada")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SpecFileBackupExtension"
-			value      	"1.ad~")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SpecFileTemporaryExtension"
-			value      	"1.ad#")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"BodyFileExtension"
-			value      	"2.ada")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"BodyFileBackupExtension"
-			value      	"2.ad~")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"BodyFileTemporaryExtension"
-			value      	"2.ad#")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateBodies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DefaultCodeBody"
-			value      	"[statement]")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"UseFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Directory"
-			value      	"$ROSEADA83_SOURCE")))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassName"
-			value      	"Object")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassAccess"
-			value      	("ImplementationSet" 43))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplementationType"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsSubtype"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"PolymorphicUnit"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"HandleName"
-			value      	"Handle")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"HandleAccess"
-			value      	("ImplementationSet" 45))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Discriminant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Variant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"EnumerationLiteralPrefix"
-			value      	"A_")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"RecordFieldPrefix"
-			value      	"The_")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassParameterName"
-			value      	"This")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DefaultConstructorKind"
-			value      	("ConstructorKindSet" 199))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DefaultConstructorName"
-			value      	"Create")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyConstructorKind"
-			value      	("ConstructorKindSet" 199))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyConstructorName"
-			value      	"Copy")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DestructorName"
-			value      	"Free")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassEqualityOperation"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"HandleEqualityOperation"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineEquality"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsTask"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"LimitedPrivate"
-				value      	200)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ConstructorKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenericFormalParameters"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsSubunit"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SubprogramImplementation"
-			value      	("SubprogramImplementationSet" 2))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Renames"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ClassParameterMode"
-			value      	("ParameterModeSet" 203))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialCodeBody"
-			value      	"${default}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SubprogramImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Spec"
-				value      	224)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Body"
-				value      	2)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Renaming"
-				value      	222)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Separate"
-				value      	223)))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ParameterModeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"In"
-				value      	204)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Out"
-				value      	205)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"InOut"
-				value      	203)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"FunctionReturn"
-				value      	206)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"NameIfUnlabeled"
-			value      	"The_${supplier}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DataMemberName"
-			value      	"${relationship}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${relationship}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${relationship}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Variant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorType"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DataMemberName"
-			value      	"${attribute}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${attribute}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${attribute}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Variant"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Representation"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${association}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${association}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateAssociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"AssociateName"
-			value      	"Associate")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineAssociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GenerateDissociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DissociateName"
-			value      	"Dissociate")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineDissociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"DataMemberName"
-			value      	"${target}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"GetName"
-			value      	"Get_${target}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SetName"
-			value      	"Set_${target}")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada83"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada83"
-			name       	"Directory"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"Ada83"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"propertyId"
-		value      	"838326200")
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SpecFileExtension"
-			value      	"1.ada")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SpecFileBackupExtension"
-			value      	"1.ad~")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SpecFileTemporaryExtension"
-			value      	"1.ad#")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"BodyFileExtension"
-			value      	"2.ada")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"BodyFileBackupExtension"
-			value      	"2.ad~")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"BodyFileTemporaryExtension"
-			value      	"2.ad#")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"UseColonNotation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateBodies"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DefaultCodeBody"
-			value      	"[statement]")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"UseFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Directory"
-			value      	"$ROSEADA95_SOURCE")))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeName"
-			value      	"Object")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeVisibility"
-			value      	("TypeVisibilitySet" 43))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeImplementation"
-			value      	("TypeImplementationSet" 208))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeControl"
-			value      	("TypeControlSet" 225))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeControlName"
-			value      	"Controlled_${type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeDefinition"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordImplementation"
-			value      	("RecordImplementationSet" 209))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordKindPackageName"
-			value      	"${class}_Record_Kinds")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsLimited"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsSubtype"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessType"
-			value      	("GenerateAccessTypeSet" 230))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessTypeName"
-			value      	"Handle")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessTypeVisibility"
-			value      	("TypeVisibilitySet" 45))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessTypeDefinition"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessClassWide"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"MaybeAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParameterizedImplementation"
-			value      	("ParameterizedImplementationSet" 11))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParentClassName"
-			value      	"Superclass")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"EnumerationLiteralPrefix"
-			value      	"A_")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldPrefix"
-			value      	"The_")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ArrayOfTypeName"
-			value      	"Array_Of_${type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessArrayOfTypeName"
-			value      	"Access_Array_Of_${type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ArrayOfAccessTypeName"
-			value      	"Array_Of_${access_type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AccessArrayOfAccessTypeName"
-			value      	"Access_Array_Of_${access_type}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ArrayIndexDefinition"
-			value      	"Positive range <>")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessorOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateStandardOperations"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameterName"
-			value      	"This")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateDefaultConstructor"
-			value      	("SubprogramKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DefaultConstructorName"
-			value      	"Create")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateCopyConstructor"
-			value      	("SubprogramKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CopyConstructorName"
-			value      	"Copy")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateDestructor"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DestructorName"
-			value      	"Free")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateTypeEquality"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeEqualityName"
-			value      	"${quote}=${quote}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineEquality"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Tagged"
-				value      	208)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Record"
-				value      	210)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Mixin"
-				value      	211)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Task"
-				value      	212)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"SingleType"
-				value      	209)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"MultipleTypes"
-				value      	213)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParameterizedImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Generic"
-				value      	11)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Unconstrained"
-				value      	214)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Private"
-				value      	43)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SubprogramKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"TypeControlSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"None"
-				value      	225)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"InitializationOnly"
-				value      	226)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AssignmentFinalizationOnly"
-				value      	227)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"All"
-				value      	228)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Always"
-				value      	229)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Auto"
-				value      	230)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenericFormalParameters"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsPrivate"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FileName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AdditionalWiths"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsSubunit"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SubprogramImplementation"
-			value      	("SubprogramImplementationSet" 2))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Renames"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateOverriding"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameterMode"
-			value      	("ParameterModeSet" 203))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ImplicitParameterClassWide"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialCodeBody"
-			value      	"${default}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"EntryBarrierCondition"
-			value      	"True")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SubprogramImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Spec"
-				value      	224)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Body"
-				value      	2)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Abstract"
-				value      	221)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Renaming"
-				value      	222)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"RenamingAsBody"
-				value      	231)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Separate"
-				value      	223)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ParameterModeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"In"
-				value      	204)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Out"
-				value      	205)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"InOut"
-				value      	203)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Access"
-				value      	220)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"NameIfUnlabeled"
-			value      	"The_${supplier}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementation"
-			value      	("RecordFieldImplementationSet" 216))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldName"
-			value      	"${relationship}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessGet"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${relationship}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessSet"
-			value      	("ProcedureKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${relationship}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementation"
-			value      	("ContainerImplementationSet" 217))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Component"
-				value      	216)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Discriminant"
-				value      	218)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AccessDiscriminant"
-				value      	219)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Array"
-				value      	217)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Generic"
-				value      	11)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementation"
-			value      	("RecordFieldImplementationSet" 216))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldName"
-			value      	"${attribute}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessGet"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${attribute}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessSet"
-			value      	("ProcedureKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${attribute}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Representation"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Component"
-				value      	216)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Discriminant"
-				value      	218)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AccessDiscriminant"
-				value      	219)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${association}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${association}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAssociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"AssociateName"
-			value      	"Associate")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineAssociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateDissociate"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"DissociateName"
-			value      	"Dissociate")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineDissociate"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"NameIfUnlabeled"
-			value      	"The_${targetClass}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementation"
-			value      	("RecordFieldImplementationSet" 216))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldName"
-			value      	"${target}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateGet"
-			value      	("FunctionKindSet" 199))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessGet"
-			value      	("FunctionKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GetName"
-			value      	"Get_${target}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateSet"
-			value      	("ProcedureKindSet" 202))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"GenerateAccessSet"
-			value      	("ProcedureKindSet" 201))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SetName"
-			value      	"Set_${target}")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsAliased"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"IsConstant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementation"
-			value      	("ContainerImplementationSet" 217))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerGeneric"
-			value      	"List")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerDeclarations"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ProcedureKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Procedure"
-				value      	202)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"RecordFieldImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Component"
-				value      	216)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Discriminant"
-				value      	218)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"AccessDiscriminant"
-				value      	219)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"ContainerImplementationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Array"
-				value      	217)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Generic"
-				value      	11)))
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"FunctionKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"Function"
-				value      	199)
-			    (object Attribute
-				tool       	"Ada95"
-				name       	"DoNotCreate"
-				value      	201)))))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ada95"
-			name       	"Directory"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"Ada95"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Editor"
-			value      	("EditorType" 100))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"IncludePath"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"StopOnError"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"EditorType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"BuiltIn"
-				value      	100)
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"WindowsShell"
-				value      	101)))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"PathSeparator"
-			value      	"")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ArrayDimensions"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ConstValue"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ImplementationType"
-			value      	"")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Context"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"OperationIsOneWay"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ArrayDimensions"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CaseSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Order"
-			value      	"")))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"ArrayDimensions"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"CaseSpecifier"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"GenerateForwardReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"IsReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"Order"
-			value      	"")
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"BoundedRoleType"
-			value      	("AssocTypeSet" 47))
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"AssocTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"CORBA"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"default__Uses"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"CORBA"
-			name       	"GenerateForwardReference"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"CORBA"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ClearCase"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"project"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ViewCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DomainCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SPPackageCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TriggerCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IndexCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"StoreProcedureCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PrimaryKeyCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForeignKeyCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"JoinCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpaceCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"cONTAINERCounter"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TablePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ViewPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DomainPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TriggerPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IndexPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"StoreProcedurePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PrimaryKeyPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForeignKeyPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpacePrefix"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDatabase"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TargetDatabase"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Location"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsTableSpace"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpaceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDeault"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"BufferPool"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ExtentSize"
-			value      	1)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PrefetchSize"
-			value      	1)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PageSize"
-			value      	4)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ManagedBy"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ContainerList"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmSchema"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmDomainPackage"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSchema"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDomainPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRootSchema"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRootDomainPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSchemaPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DatabaseID"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DBMS"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsTable"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsView"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDomain"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSPPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Synonymns"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpaceID"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceId"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"CorrelationName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SelectClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUpdateable"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"CheckOption"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsSnapShot"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDistinct"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"PersistToServer"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsPackage"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpace"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUpdatable"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Ordinal"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsIdentity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"NullsAllowed"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Length"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Scale"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ColumnType"
-			value      	"Native")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForBitData"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValueType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceId"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"OID"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRelationship"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceId"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"SourceType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RIMethod"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentUpdateRule"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentUpdateRuleName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentDeleteRule"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParentDeleteRuleName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildInsertRestrict"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildInsertRestrictName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildMultiplicity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ChildMultiplicityName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintName"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsConstraint"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ConstraintType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsIndex"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsTrigger"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsStoredProcedure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsCluster"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TableSpace"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"FillFactor"
-			value      	0)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"KeyList"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"CheckPredicate"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DeferalMode"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"InitialCheckTime"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"TriggerType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsInsertEvent"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsUpdateEvent"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDeleteEvent"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefOldTable"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefNewTable"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefOldRow"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"RefNewRow"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsRow"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"WhenClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Language"
-			value      	"SQL")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ProcType"
-			value      	"Procedure")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsDeterministic"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ParameterStyle"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ReturnedNull"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ExternalName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Scale"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForBitData"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValueType"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"default__Parameter"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"dmItem"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DMName"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsInParameter"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"IsOutParameter"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Ordinal"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"Scale"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"ForBitData"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValueType"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"DefaultValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Data Modeler"
-			name       	"OperationID"
-			value      	"")))
-	    (object Attribute
-		tool       	"Data Modeler"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Data Modeler Communicator"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Java"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"RootDir"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UsePrefixes"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"AutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"NotShowRoseIDDlg"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ShowCodegenDlg"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateRoseID"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultReturnLine"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocDefaultAuthor"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocDefaultVersion"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocDefaultSince"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagName1"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagApply1"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagText1"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagName2"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagApply2"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagText2"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagName3"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagApply3"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineTagText3"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocNumAsterisks"
-			value      	0)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MaxNumChars"
-			value      	80)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Editor"
-			value      	("EditorType" 100))
-		    (object Attribute
-			tool       	"Java"
-			name       	"VM"
-			value      	("VMType" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"ClassPath"
-			value      	";D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\charsets.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\jce.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\jsse.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\rt.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\sunrsasign.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\dnsns.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\ldapsec.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\localedata.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\ext\\sunjce_provider.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\security\\local_policy.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\jre\\lib\\security\\US_export_policy.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\lib\\dt.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\lib\\htmlconverter.jar;D:\\Program Files\\Sun\\jdk1.4.2_02\\lib\\tools.jar")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReferenceClasspath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EditorType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"BuiltIn"
-				value      	100)
-			    (object Attribute
-				tool       	"Java"
-				name       	"WindowsShell"
-				value      	101)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"VMType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Sun"
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Microsoft"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"IBM"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"VAJavaWorkingFolder"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"InstanceVariablePrefix"
-			value      	"m_")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ClassVariablePrefix"
-			value      	"s_")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultAttributeDataType"
-			value      	"int")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultOperationReturnType"
-			value      	"void")
-		    (object Attribute
-			tool       	"Java"
-			name       	"NoClassCustomDlg"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GlobalImports"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"OpenBraceClassStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"OpenBraceMethodStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UseTabs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UseSpaces"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"SpacingItems"
-			value      	3)
-		    (object Attribute
-			tool       	"Java"
-			name       	"RoseDefaultCommentStyle"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"AsteriskCommentStyle"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavaCommentStyle"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocAuthor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocSince"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"JavadocVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"RemotePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"RemoteSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"HomePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"HomeSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"PrimaryKeyPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"PrimaryKeySuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBDTDLocation"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDTDLocation"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultEJBVersion"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DefaultServletVersion"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultJ2EEJavadoc"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"UserDefineJavaDocTags"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalHomePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"LocalHomeSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"SourceControl"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCSelected"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCProjectSourceRoot"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCProjectName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"SCCComment"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"BMP_Extend_CMP"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"Default_Servlet__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"BMP_Extend_CMP"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"Http_Servlet__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"BMP_Extend_CMP"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"Default_EJB__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Generate_XML_DD"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCmpField"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBEnvironmentProperties"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBCnxFactory"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReferences"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBNameInJAR"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType"
-			value      	("EJBSessionType_Set" 200))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	200)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateless"
-				value      	201)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Stateful"
-				value      	202)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType"
-			value      	("EJBTransactionType_Set" 211))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBTransactionType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	211)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	212)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType"
-			value      	("EJBPersistenceType_Set" 220))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBPersistenceType_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	""
-				value      	220)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bean"
-				value      	221)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Container"
-				value      	222)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBReentrant"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBSessionSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion"
-			value      	("EJBVersion_Set" 230))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBVersion_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"2.0"
-				value      	230)
-			    (object Attribute
-				tool       	"Java"
-				name       	"1.x"
-				value      	231)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"EJBXMLFilePath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateDefaultConstructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ConstructorIs"
-			value      	("Ctor_Set" 62))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Ctor_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"public"
-				value      	62)
-			    (object Attribute
-				tool       	"Java"
-				name       	"protected"
-				value      	63)
-			    (object Attribute
-				tool       	"Java"
-				name       	"private"
-				value      	64)
-			    (object Attribute
-				tool       	"Java"
-				name       	"package"
-				value      	65)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFinalizer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateStaticInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateInstanceInitializer"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DisableAutoSync"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletName"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContextRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsSingleThread"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletInitParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIsSecure"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcher"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestDispatcherPath"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherInclude"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"DispatcherForward"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletSecurityRoles"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletgetInfo"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttribute"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestAttributesNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestAttributes"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameter"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletRequestParameterNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForRequestParameters"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeader"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletHeaderNames"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForHeaders"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletIntHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletDateHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletCookie"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"MethodForCookie"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletContentType"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateHTML"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"BMP_Extend_CMP"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReadOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ServletXMLFilePath"
-			value      	"")))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"CmIdentification"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"CmIdentification"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Java"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Abstract"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Static"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Native"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Synchronized"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFullyQualifiedReturn"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"ReplaceExistingCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Strictfp"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Transient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Volatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"PropertyType"
-			value      	("BeanProperty_Set" 71))
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanProperty_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Not A Property"
-				value      	71)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Simple"
-				value      	72)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bound"
-				value      	73)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Constrained"
-				value      	74)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"IndividualChangeMgt"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write"
-			value      	("Read/Write_Set" 81))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read & Write"
-				value      	81)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read Only"
-				value      	82)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Write Only"
-				value      	83)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFullyQualifiedTypes"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Java"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"InitialValue"
-			value      	"")
-		    (object Attribute
-			tool       	"Java"
-			name       	"Final"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Transient"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Volatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"PropertyType"
-			value      	("BeanProperty_Set" 71))
-		    (object Attribute
-			tool       	"Java"
-			name       	"BeanProperty_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Not A Property"
-				value      	71)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Simple"
-				value      	72)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Bound"
-				value      	73)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Constrained"
-				value      	74)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"IndividualChangeMgt"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write"
-			value      	("Read/Write_Set" 81))
-		    (object Attribute
-			tool       	"Java"
-			name       	"Read/Write_Set"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read & Write"
-				value      	81)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Read Only"
-				value      	82)
-			    (object Attribute
-				tool       	"Java"
-				name       	"Write Only"
-				value      	83)))
-		    (object Attribute
-			tool       	"Java"
-			name       	"GenerateFullyQualifiedTypes"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Java"
-			name       	"IsNavigable"
-			value      	TRUE)))
-	    (object Attribute
-		tool       	"Java"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"propertyId"
-		value      	"360000002")
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"DDLScriptFilename"
-			value      	"DDL1.SQL")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"DropClause"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"PrimaryKeyColumnName"
-			value      	"_ID")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"PrimaryKeyColumnType"
-			value      	"NUMBER(5,0)")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"SchemaNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"SchemaNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TableNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TypeNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TypeNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ViewNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ViewNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"VarrayNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"VarrayNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NestedTableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NestedTableNameSuffix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ObjectTableNamePrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"ObjectTableNameSuffix"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsSchema"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OID"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"WhereClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CheckConstraint"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypeLength"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypePrecision"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionTypeScale"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CollectionOfREFS"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"MethodKind"
-			value      	("MethodKindSet" 1903))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OverloadID"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsReadNoDataState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsReadNoProcessState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsWriteNoDataState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsWriteNoProcessState"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsSelfish"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerType"
-			value      	("TriggerTypeSet" 1801))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerEvent"
-			value      	("TriggerEventSet" 1601))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerText"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerReferencingNames"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerForEach"
-			value      	("TriggerForEachSet" 1701))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerWhenClause"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"MethodKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"MapMethod"
-				value      	1901)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"OrderMethod"
-				value      	1902)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Function"
-				value      	1903)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Procedure"
-				value      	1904)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Operator"
-				value      	1905)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Constructor"
-				value      	1906)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Destructor"
-				value      	1907)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Trigger"
-				value      	1908)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"Calculated"
-				value      	1909)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"AFTER"
-				value      	1801)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"BEFORE"
-				value      	1802)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSTEAD OF"
-				value      	1803)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerForEachSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"ROW"
-				value      	1701)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"STATEMENT"
-				value      	1702)))
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"TriggerEventSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT"
-				value      	1601)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"UPDATE"
-				value      	1602)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"DELETE"
-				value      	1603)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR UPDATE"
-				value      	1604)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR DELETE"
-				value      	1605)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"UPDATE OR DELETE"
-				value      	1606)
-			    (object Attribute
-				tool       	"Oracle8"
-				name       	"INSERT OR UPDATE OR DELETE"
-				value      	1607)))))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"OrderNumber"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"NullsAllowed"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Length"
-			value      	"")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Precision"
-			value      	"2")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"Scale"
-			value      	"6")
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsIndex"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"IsPrimaryKey"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CompositeUnique"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Oracle8"
-			name       	"CheckConstraint"
-			value      	"")))
-	    (object Attribute
-		tool       	"Oracle8"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"ComponentTest"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"RequisitePro"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"cg"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerAnnotations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"UseMSVC"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CommentWidth"
-			value      	60)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AlwaysKeepOrphanedCode"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"compiler2.1__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerAnnotations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue(sizeof($targetClass))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue(sizeof($targetClass),$limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue(sizeof($targetClass),$limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference($limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference($limit)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue(sizeof($targetClass))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue(sizeof($targetClass))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference(sizeof($qualtype), sizeof($qualcont))")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AlwaysKeepOrphanedCode"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"compiler3.0__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerAnnotations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowGenerateOverNewerVersion"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileExtension"
-			value      	"h")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileBackupExtension"
-			value      	"h~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"HeaderFileTemporaryExtension"
-			value      	"h#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileExtension"
-			value      	"cpp")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileBackupExtension"
-			value      	"cp~")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeFileTemporaryExtension"
-			value      	"cp#")
-		    (object Attribute
-			tool       	"cg"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StopOnError"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ErrorLimit"
-			value      	30)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"$ROSECPP_SOURCE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BooleanType"
-			value      	"int")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowTemplates"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExplicitInstantiations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowProtectedInheritance"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByValueContainer"
-			value      	"$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OneByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByValueContainer"
-			value      	"OptionalByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OptionalByReferenceContainer"
-			value      	"$targetClass *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByValueContainer"
-			value      	"$targetClass[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedFixedByReferenceContainer"
-			value      	"$targetClass *[$limit]")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByValueContainer"
-			value      	"BoundedListByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByValueContainer"
-			value      	"BoundedSetByValue<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"BoundedByReferenceContainer"
-			value      	"BoundedListByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedBoundedByReferenceContainer"
-			value      	"BoundedSetByReference<$targetClass,$limit>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByValueContainer"
-			value      	"UnboundedListByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByValueContainer"
-			value      	"UnboundedSetByValue<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnboundedByReferenceContainer"
-			value      	"UnboundedListByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedUnboundedByReferenceContainer"
-			value      	"UnboundedSetByReference<$targetClass>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByValueContainer"
-			value      	"AssociationByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByValueContainer"
-			value      	"DictionaryByValue<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedByReferenceContainer"
-			value      	"AssociationByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"UnorderedQualifiedByReferenceContainer"
-			value      	"DictionaryByReference<$qualtype, $qualcont>")
-		    (object Attribute
-			tool       	"cg"
-			name       	"PathSeparator"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileNameFormat"
-			value      	"128vx_b")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AlwaysKeepOrphanedCode"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ImplementationType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ClassKey"
-			value      	"class")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"PutBodiesInSpec"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDefaultConstructor"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DefaultConstructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExplicitDefaultConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateCopyConstructor"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyConstructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExplicitCopyConstructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDestructor"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DestructorVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DestructorKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDestructor"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssignmentOperation"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssignmentVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssignmentKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssignmentOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEqualityOperations"
-			value      	("GenerateSet" 199))
-		    (object Attribute
-			tool       	"cg"
-			name       	"EqualityVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"EqualityKind"
-			value      	("FriendKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineEqualityOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateRelationalOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"RelationalVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"RelationalKind"
-			value      	("FriendKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineRelationalOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateStorageMgmtOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StorageMgmtVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineStorageMgmtOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSubscriptOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"SubscriptResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSubscriptOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDereferenceOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DereferenceResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineDereferenceOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateIndirectionOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionKind"
-			value      	("ThreeKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IndirectionResultType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineIndirectionOperation"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateStreamOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"StreamVisibility"
-			value      	("VisibilitySet" 45))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineStreamOperations"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ThreeKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"KindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FriendKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"DeclareAndDefine"
-				value      	199)
-			    (object Attribute
-				tool       	"cg"
-				name       	"DeclareOnly"
-				value      	205)
-			    (object Attribute
-				tool       	"cg"
-				name       	"DoNotDeclare"
-				value      	206)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"VisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExtensionlessFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InclusionProtectionSymbol"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeFormat"
-			value      	(value Text 
-|// $package
-|#include "$file"
-|
-			))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludePrecompiledHeader"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeOrder"
-			value      	"AMIR")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyle"
-			value      	("InliningStyleSet" 207))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"InClassDeclaration"
-				value      	208)
-			    (object Attribute
-				tool       	"cg"
-				name       	"FollowingClassDeclaration"
-				value      	207)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"TypesDefined"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeClosure"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CmIdentification"
-			value      	(value Text "  %X% %Q% %Z% %W%"))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CopyrightNotice"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"FileName"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AllowExtensionlessFileName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeFormat"
-			value      	(value Text 
-|// $package
-|#include "$file"
-|
-			))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeBySimpleName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludePrecompiledHeader"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeOrder"
-			value      	"AMIR")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AdditionalIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyle"
-			value      	("InliningStyleSet" 207))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InliningStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"InClassDeclaration"
-				value      	208)
-			    (object Attribute
-				tool       	"cg"
-				name       	"FollowingClassDeclaration"
-				value      	207)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"TypesDefined"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"IncludeClosure"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationKind"
-			value      	("OperationKindSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationKindSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAbstractBody"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateFriendBody"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateFriendDecl"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SpecialDeclReturnType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsConst"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"OperationIsExplicit"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Inline"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"EntryCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ExitCode"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"CCRegion"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"BodyAnnotations"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"Ordered"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$supplier")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$relationship")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SelectorName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SelectorType"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"HasRelTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Association"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$targetClass")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"InstanceArguments"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"NameIfUnlabeled"
-			value      	"the_$targetClass")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"InitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerClass"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerGet"
-			value      	"$data.get($keys)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"ContainerSet"
-			value      	"$data.set($keys,$value)")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedContainer"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassContainer"
-			value      	"$supplier *")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassInitialValue"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetSetByReference"
-			value      	("QualifiedGetSetByReferenceSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetSetByReferenceSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_GetSetByReference"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateQualifiedGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedGetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineQualifiedGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateQualifiedSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedSetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"QualifiedSetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineQualifiedSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberName"
-			value      	"$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtRelationshipVisibility"
-				value      	210)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassDataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetName"
-			value      	"get_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassGetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssocClassGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateAssocClassSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassSetName"
-			value      	"set_$target")
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassSetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineAssocClassSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocClassForwardReferenceOnly"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"AssocTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Array"
-				value      	24)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Sequence"
-				value      	47)))))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateDataMember"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberName"
-			value      	"$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibility"
-			value      	("DataMemberVisibilitySet" 14))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberVisibilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Public"
-				value      	45)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Protected"
-				value      	44)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Private"
-				value      	43)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Implementation"
-				value      	14)
-			    (object Attribute
-				tool       	"cg"
-				name       	"AtAttributeVisibility"
-				value      	211)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutability"
-			value      	("DataMemberMutabilitySet" 0))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberMutabilitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unrestricted"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Mutable"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Const"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberIsVolatile"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"DataMemberFieldSize"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateGetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateSetOperation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetName"
-			value      	"get_$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetName"
-			value      	"set_$attribute")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKinds"
-			value      	("GetSetKindsSet" 200))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetKindsSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"Common"
-				value      	200)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Virtual"
-				value      	201)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Abstract"
-				value      	202)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Static"
-				value      	203)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Friend"
-				value      	204)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetIsConst"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConst"
-			value      	("GetResultIsConstSet" 2))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetResultIsConstSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"False"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"True"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Same_As_Function"
-				value      	2)))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GetSetByReference"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineGet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"SetReturnsValue"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"InlineSet"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CCRegion"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Uses"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"ForwardReferenceOnly"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"BodyReferenceOnly"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Subsystem"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"Directory"
-			value      	"AUTO GENERATE")
-		    (object Attribute
-			tool       	"cg"
-			name       	"DirectoryIsOnSearchList"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"PrecompiledHeader"
-			value      	"")))
-	    (object Attribute
-		tool       	"cg"
-		name       	"default__Category"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"cg"
-			name       	"IsNamespace"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"cg"
-			name       	"Indent"
-			value      	2)
-		    (object Attribute
-			tool       	"cg"
-			name       	"CodeName"
-			value      	"")
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegions"
-			value      	("GenerateEmptyRegionSet" 3))
-		    (object Attribute
-			tool       	"cg"
-			name       	"GenerateEmptyRegionSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"cg"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Preserved"
-				value      	1)
-			    (object Attribute
-				tool       	"cg"
-				name       	"Unpreserved"
-				value      	2)
-			    (object Attribute
-				tool       	"cg"
-				name       	"All"
-				value      	3)))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Version"
-			value      	"5.0")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCClassTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCClassTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Interface_Part"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Connection_Part"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Class_Factory"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CObjectFunctionality"
-			value      	("CObjectFunctionalitySet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CObjectFunctionalitySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dynamic"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dyncreate"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Serial"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOverrideGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDataGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DATA_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateFieldGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_FIELD_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMessageGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMessageMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MESSAGE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEFactory"
-			value      	("OLEFactorySet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEFactorySet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Built_in"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Simple"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Licensed"
-				value      	3)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEName"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEClassID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOLECtlType"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLECtlType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateOLETypeLib"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibMajor"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLETypeLibMinor"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GeneratePropPageIDs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLEPropPageIDs"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDispatchMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockProperties"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockFunctions"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DispatchDefValue"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateDispIdEnum"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISP_ID_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInterfaceMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"INTERFACE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"InitInterface"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateEventMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockEvents"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateEventSinkMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PropNotifySinks"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateConnectionMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CONNECTION_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"ConnectionPointIID"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"InheritanceType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"OLECommands"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MFCDeclares"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MFCImplements"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"ATL_Declares"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateCOMMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"COM_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateConnectionPointMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CONNECTION_POINT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateMsgMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GeneratePropertyMap"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PROPERTY_MAP_Entries"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCOperationTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCOperationTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Virtual_Override"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Message_Handler"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dispatch_Handler"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Event_Firing_Function"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Event_Sink_Handler"
-				value      	5)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Std_OLE_Method"
-				value      	6)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Command_Parser"
-				value      	7)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Get_Function"
-				value      	8)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Set_Function"
-				value      	9)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Property_Notify_Function"
-				value      	10)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Macro_Generated_Function"
-				value      	11)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_MSG_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MESSAGE_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENT_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"EVENTSINK_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"BodyImage"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Has"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"Type"
-			value      	("MSVCAttributeTypeSet" 0))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"MSVCAttributeTypeSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Normal"
-				value      	0)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Member_Property"
-				value      	1)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Get_Set_Property"
-				value      	2)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Dialog_Data"
-				value      	3)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Field_Data"
-				value      	4)
-			    (object Attribute
-				tool       	"MSVC"
-				name       	"Stock_Property"
-				value      	5)))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DISPATCH_MAP_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"DeclSpec"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"PointerBase"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"CallType"
-			value      	"")
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"StockPropertyImplementation"
-			value      	"")))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateIncludesGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_INCLUDES_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInsertLocation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"MSVC"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateIncludesGroup"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"AFX_INCLUDES_Entries"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"MSVC"
-			name       	"GenerateInsertLocation"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"cg"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Rose Model Integrator"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Rose Web Publisher"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"SoDA"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"TopLink"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"COM"
-		name       	"propertyId"
-		value      	"783606378")
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"TypeKinds"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"COM"
-				name       	"enum"
-				value      	100)
-			    (object Attribute
-				tool       	"COM"
-				name       	"record"
-				value      	101)
-			    (object Attribute
-				tool       	"COM"
-				name       	"module"
-				value      	102)
-			    (object Attribute
-				tool       	"COM"
-				name       	"interface"
-				value      	103)
-			    (object Attribute
-				tool       	"COM"
-				name       	"dispinterface"
-				value      	104)
-			    (object Attribute
-				tool       	"COM"
-				name       	"coclass"
-				value      	105)
-			    (object Attribute
-				tool       	"COM"
-				name       	"alias"
-				value      	106)
-			    (object Attribute
-				tool       	"COM"
-				name       	"union"
-				value      	107)
-			    (object Attribute
-				tool       	"COM"
-				name       	"max"
-				value      	108)
-			    (object Attribute
-				tool       	"COM"
-				name       	"(none)"
-				value      	109)))
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"kind"
-			value      	("TypeKinds" 109))
-		    (object Attribute
-			tool       	"COM"
-			name       	"uuid"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"version"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpcontext"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"dllname"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"alias"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"id"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"id"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"Generate"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"COM"
-			name       	"filename"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"library"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"uuid"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"version"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpstring"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpfile"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"helpcontext"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"lcid"
-			value      	"")
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"default__Param"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"COM"
-			name       	"attributes"
-			value      	"")))
-	    (object Attribute
-		tool       	"COM"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"propertyId"
-		value      	"783606378")
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateModel"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"InstancingSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Private"
-				value      	221)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"PublicNotCreatable"
-				value      	213)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"SingleUse"
-				value      	214)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"GlobalSingleUse"
-				value      	215)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"MultiUse"
-				value      	219)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"GlobalMultiUse"
-				value      	220)))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"BaseSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"(none)"
-				value      	222)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"0"
-				value      	223)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"1"
-				value      	224)))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionBase"
-			value      	("BaseSet" 222))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionExplicit"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"OptionCompare"
-			value      	("CompareSet" 202))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Instancing"
-			value      	("InstancingSet" 219))
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"CompareSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"(none)"
-				value      	202)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Binary"
-				value      	203)
-			    (object Attribute
-				tool       	"Visual Basic"
-				name       	"Text"
-				value      	204)))))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"LibraryName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"AliasName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"IsStatic"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProcedureID"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ReplaceExistingBody"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"DefaultBody"
-			value      	(value Text ""))))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"New"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"WithEvents"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProcedureID"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"PropertyName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Subscript"
-			value      	"")))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Role"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"New"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"WithEvents"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"FullName"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProcedureID"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"PropertyName"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Subscript"
-			value      	"")))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Inherit"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImplementsDelegation"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"FullName"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Param"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ByVal"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ByRef"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"Optional"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ParamArray"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ProjectFile"
-			value      	"")
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateCode"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"UpdateModel"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImportReferences"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"QuickImport"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Visual Basic"
-			name       	"ImportBinary"
-			value      	FALSE)))
-	    (object Attribute
-		tool       	"Visual Basic"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"VisualStudio"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Web Modeler"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"propertyId"
-		value      	"809135966")
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Project"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"CreateMissingDirectories"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Editor"
-			value      	("EditorType" 100))
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"StopOnError"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"EditorType"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"XML_DTD"
-				name       	"BuiltIn"
-				value      	100)
-			    (object Attribute
-				tool       	"XML_DTD"
-				name       	"WindowsShell"
-				value      	101)))))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Entity_SystemID"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Entity_PublicID"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"NotationValue"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"InternalValue"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"ParameterEntity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"ExternalEntity"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Notation_SystemID"
-			value      	"")
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Notation_PublicID"
-			value      	"")))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Attribute"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"DefaultDeclType"
-			value      	"")))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"default__Module-Spec"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"Assign All"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"XML_DTD"
-			name       	"ComponentPath"
-			value      	"")))
-	    (object Attribute
-		tool       	"XML_DTD"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"framework"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"R2Editor"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Version Control"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Cplusplus"
-		name       	"default__Module-Body"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Synchronize"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngRootDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RootPackage"
-			value      	"C++ Reverse Engineered")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"RevEngDirectoriesAsPackages"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"HeaderFileExtension"
-			value      	".h")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ImplementationFileExtension"
-			value      	".cpp")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewHeaderFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NewImplementationFileDirectory"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalization"
-			value      	("FileCapitalizationSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectories"
-			value      	("CodeGenExtraDirectoriesSet" 0))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"StripClassPrefix"
-			value      	"")
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"UseTabs"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"TabWidth"
-			value      	8)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"IndentWidth"
-			value      	4)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"AccessIndentation"
-			value      	-2)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRules"
-			value      	("ModelIdCommentRulesSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"PageWidth"
-			value      	80)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassMemberOrder"
-			value      	("MemberOrderSet" 1))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"OneParameterPerLine"
-			value      	FALSE)
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"NamespaceBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ClassBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FunctionBraceStyle"
-			value      	("BraceStyleSet" 2))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"Copyright"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialHeaderIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"InitialBodyIncludes"
-			value      	(value Text ""))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"CodeGenExtraDirectoriesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"None"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Namespaces"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Packages"
-				value      	2)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"FileCapitalizationSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Same as model"
-				value      	0)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Upper case"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Lower case with underscores"
-				value      	3)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"BraceStyleSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B1"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B2"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B3"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B4"
-				value      	4)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"B5"
-				value      	5)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"MemberOrderSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Public First"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Private First"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Order by kind"
-				value      	3)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Unordered"
-				value      	4)))
-		    (object Attribute
-			tool       	"Cplusplus"
-			name       	"ModelIdCommentRulesSet"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation only"
-				value      	1)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Code generation and reverse engineering"
-				value      	2)
-			    (object Attribute
-				tool       	"Cplusplus"
-				name       	"Never generate model IDs"
-				value      	3)))))
-	    (object Attribute
-		tool       	"Deploy"
-		name       	"HiddenTool"
-		value      	FALSE)
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Class"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"classifierName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"constraints"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"xmlContentKind"
-			value      	("ContentKind" 0))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"ContentKind"
-			value      	(list Attribute_Set
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Unspecified"
-				value      	0)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Empty"
-				value      	1)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Simple"
-				value      	2)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"Mixed"
-				value      	3)
-			    (object Attribute
-				tool       	"Ecore"
-				name       	"ElementOnly"
-				value      	4)))
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	"")))
-	    (object Attribute
-		tool       	"Ecore"
-		name       	"default__Operation"
-		value      	(list Attribute_Set
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"operationName"
-			value      	"")
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"isUnique"
-			value      	TRUE)
-		    (object Attribute
-			tool       	"Ecore"
-			name       	"annotation"
-			value      	""))))
-	quid       	"39EDFBE003B9"))
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/.cvsignore b/plugins/org.eclipse.jst.common.annotations.controller/.cvsignore
index 9910b2d..ee6c033 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/.cvsignore
+++ b/plugins/org.eclipse.jst.common.annotations.controller/.cvsignore
@@ -2,3 +2,5 @@
 temp.folder
 build.xml
 controller.jar
+@dot
+src.zip
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/controller/AnnotationsControllerManager.java b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/controller/AnnotationsControllerManager.java
index f58124e..ed63da7 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/controller/AnnotationsControllerManager.java
+++ b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/controller/AnnotationsControllerManager.java
@@ -69,7 +69,7 @@
 
 		public Descriptor(IConfigurationElement aConfigElement) {
 			super();
-			Assert.isLegal(ANNOTATIONS_CONTROLLER.equals(aConfigElement.getName()), AnnotationsControllerResources.getString("AnnotationsControllerManager_ERROR_0")); //$NON-NLS-1$
+			Assert.isLegal(ANNOTATIONS_CONTROLLER.equals(aConfigElement.getName()), AnnotationsControllerResources.AnnotationsControllerManager_ERROR_0); //$NON-NLS-1$
 			configElement = aConfigElement;
 			ID = configElement.getAttribute(ATT_ID);
 			builderID = configElement.getAttribute(BUILDER_ID);
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationTagRegistry.java b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationTagRegistry.java
index eccc145..89d232b 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationTagRegistry.java
+++ b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationTagRegistry.java
@@ -31,6 +31,7 @@
 import org.eclipse.core.runtime.IExtensionRegistry;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.osgi.util.NLS;
 import org.osgi.framework.Bundle;
 
 /**
@@ -219,7 +220,7 @@
 				} else {
 					// Unlikely, unless annotation extension spec changes
 					// without changes here.
-					System.err.println(AnnotationsControllerResources.getString("AnnotationTagRegistry.9") + use); //$NON-NLS-1$
+					System.err.println(AnnotationsControllerResources.AnnotationTagRegistry_9 + use); //$NON-NLS-1$
 					return null;
 				}
 
@@ -229,7 +230,7 @@
 					if (elemUniqueArray[0].getAttribute("scope") != null) //$NON-NLS-1$
 						tas.getUnique().setScope(TagAttribSpec.uniqueScopeFromString(elemUniqueArray[0].getAttribute("scope"))); //$NON-NLS-1$
 					if (elemUniqueArray.length > 1) {
-						Logger.getLogger().logError(AnnotationsControllerResources.getString("TagAttribSpec.2") + elemUniqueArray.length); //$NON-NLS-1$
+						Logger.getLogger().logError(AnnotationsControllerResources.TagAttribSpec_2 + elemUniqueArray.length); //$NON-NLS-1$
 					}
 				} else {
 					tas.clearUnique();
@@ -310,7 +311,7 @@
 				tagName = elem.getAttribute("tagName"); //$NON-NLS-1$
 				scope = elem.getAttribute("scope"); //$NON-NLS-1$
 				if (isNullOrEmpty(tagSet) || isNullOrEmpty(tagName) || isNullOrEmpty(scope)) {
-					Logger.getLogger().log(AnnotationsControllerResources.getString("AnnotationTagRegistry.10", new Object[]{identifier})); //$NON-NLS-1$ //$NON-NLS-2$
+					Logger.getLogger().log(NLS.bind(AnnotationsControllerResources.AnnotationTagRegistry_10, new Object[]{identifier})); //$NON-NLS-1$ //$NON-NLS-2$
 					continue;
 				}
 				fullTagName = tagSet + "." + tagName; //$NON-NLS-1$
@@ -321,7 +322,7 @@
 				 * There should only ever be one AnnotationTagInfo tag for any one annotation tag.
 				 */
 				if (tagAttribs.containsKey(key)) {
-					Logger.getLogger().log(AnnotationsControllerResources.getString("AnnotationTagRegistry.0") + tagName + "'."); //$NON-NLS-1$ //$NON-NLS-2$
+					Logger.getLogger().log(AnnotationsControllerResources.AnnotationTagRegistry_0 + tagName + "'."); //$NON-NLS-1$ //$NON-NLS-2$
 				} else {
 					tagInf.bundle = bundle;
 					tagAttribs.put(key, tagInf);
@@ -504,7 +505,7 @@
 		try {
 			AnnotationTagRegistry.init();
 		} catch (CoreException e) {
-			Logger.getLogger().logError(AnnotationsControllerResources.getString("AnnotationTagRegistry_ERROR_1")); //$NON-NLS-1$
+			Logger.getLogger().logError(AnnotationsControllerResources.AnnotationTagRegistry_ERROR_1); //$NON-NLS-1$
 			Logger.getLogger().logError(e);
 		}
 	}
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationsControllerResources.java b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationsControllerResources.java
index f357d90..a143c59 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationsControllerResources.java
+++ b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/AnnotationsControllerResources.java
@@ -17,48 +17,31 @@
 
 package org.eclipse.jst.common.internal.annotations.registry;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-/**
- * @author kkatyal
- * 
- * To change the template for this generated type comment go to Window - Preferences - Java - Code
- * Generation - Code and Comments
- */
-public class AnnotationsControllerResources {
-
+public class AnnotationsControllerResources extends NLS {
 	private static final String BUNDLE_NAME = "annotationcontroller";//$NON-NLS-1$
-	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);
 
-	/**
-	 *  
-	 */
 	private AnnotationsControllerResources() {
-		// Default constructor
+		// Do not instantiate
 	}
 
-	/**
-	 * @param key
-	 * @return
-	 */
-	public static String getString(String key) {
-		try {
-			return RESOURCE_BUNDLE.getString(key);
-		} catch (MissingResourceException e) {
-			return '!' + key + '!';
-		}
+	public static String TagSpec_3;
+	public static String TagSpec_4;
+	public static String TagSpec_5;
+	public static String TagSpec_6;
+	public static String TagAttribSpec_1;
+	public static String TagAttribSpec_2;
+	public static String AnnotationTagParser_0;
+	public static String AnnotationTagParser_1;
+	public static String AnnotationTagRegistry_0;
+	public static String AnnotationTagRegistry_9;
+	public static String AnnotationTagRegistry_10;
+	public static String AnnotationTagRegistry_11;
+	public static String AnnotationsControllerManager_ERROR_0;
+	public static String AnnotationTagRegistry_ERROR_1;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, AnnotationsControllerResources.class);
 	}
-
-	public static String getString(String key, Object[] args) {
-		try {
-			RESOURCE_BUNDLE.getString(key);
-		} catch (MissingResourceException e) {
-			return '!' + key + '!';
-		}
-
-		return MessageFormat.format(key, args);
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagAttribSpec.java b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagAttribSpec.java
index 7b63590..6d99c21 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagAttribSpec.java
+++ b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagAttribSpec.java
@@ -188,7 +188,7 @@
 	 */
 	public void setAttribName(String name) throws IllegalArgumentException {
 		if (name == null) {
-			throw new IllegalArgumentException(AnnotationsCoreResources.getString("TagAttribSpec.6")); //$NON-NLS-1$
+			throw new IllegalArgumentException(AnnotationsCoreResources.TagAttribSpec_6); 
 		}
 		attribName = name;
 	}
@@ -291,7 +291,7 @@
 			if (scopeStr.equalsIgnoreCase("method"))return TagAttribSpec.Unique.METHOD; //$NON-NLS-1$
 			if (scopeStr.equalsIgnoreCase("field"))return TagAttribSpec.Unique.FIELD; //$NON-NLS-1$
 		}
-		Logger.getLogger().logError(AnnotationsControllerResources.getString("TagAttribSpec.1") + scopeStr); //$NON-NLS-1$
+		Logger.getLogger().logError(AnnotationsControllerResources.TagAttribSpec_1 + scopeStr); //$NON-NLS-1$
 		return TagAttribSpec.Unique.MODULE;
 	}
 
@@ -308,7 +308,7 @@
 			case TagAttribSpec.Unique.FIELD :
 				return "field"; //$NON-NLS-1$
 			default :
-				Logger.getLogger().logError(AnnotationsControllerResources.getString("TagAttribSpec.1") + scope); //$NON-NLS-1$
+				Logger.getLogger().logError(AnnotationsControllerResources.TagAttribSpec_1 + scope); //$NON-NLS-1$
 				return "unknown value"; //$NON-NLS-1$
 
 		}
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagSpec.java b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagSpec.java
index 70ee727..e36caca 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagSpec.java
+++ b/plugins/org.eclipse.jst.common.annotations.controller/controller/org/eclipse/jst/common/internal/annotations/registry/TagSpec.java
@@ -103,10 +103,10 @@
 				// Should be impossible unless the annotation-taghandler.exsd or
 				// calling code changes.
 				//TODO: Logging
-				throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.wst.common.internal.annotations.controller", IStatus.OK, AnnotationsControllerResources.getString("TagSpec.3") + s, null)); //$NON-NLS-1$ //$NON-NLS-2$
+				throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.wst.common.internal.annotations.controller", IStatus.OK, AnnotationsControllerResources.TagSpec_3 + s, null)); //$NON-NLS-1$ //$NON-NLS-2$
 			}
 		}
-		throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.wst.common.internal.annotations.controller", IStatus.OK, AnnotationsControllerResources.getString("TagSpec.4"), null)); //$NON-NLS-1$ //$NON-NLS-2$
+		throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.wst.common.internal.annotations.controller", IStatus.OK, AnnotationsControllerResources.TagSpec_4, null)); //$NON-NLS-1$ //$NON-NLS-2$
 
 	}
 
@@ -117,7 +117,7 @@
 			} else if (s.equalsIgnoreCase("*")) { //$NON-NLS-1$
 				return TagSpec.Multiplicity.MANY;
 			}
-			throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.wst.common.internal.annotations.controller", IStatus.OK, AnnotationsControllerResources.getString("TagSpec.4"), null)); //$NON-NLS-1$ //$NON-NLS-2$
+			throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.wst.common.internal.annotations.controller", IStatus.OK, AnnotationsControllerResources.TagSpec_4, null)); //$NON-NLS-1$ //$NON-NLS-2$
 		}
 		//Return default
 		return TagSpec.Multiplicity.ONE;
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/property_files/annotationcontroller.properties b/plugins/org.eclipse.jst.common.annotations.controller/property_files/annotationcontroller.properties
index 390e773..a2631de 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/property_files/annotationcontroller.properties
+++ b/plugins/org.eclipse.jst.common.annotations.controller/property_files/annotationcontroller.properties
@@ -8,16 +8,17 @@
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-TagSpec.3=Unknown tag scope:
-TagSpec.4=Null tag scope.
-TagSpec.5=Unknown tag multiplicity:
-TagSpec.6=Null tag multiplicity.
-TagAttribSpec.1=Unknown 'unique' scope value:
-TagAttribSpec.1=More than one 'unique' tag defined:
-AnnotationTagParser.0=Null event handler.
-AnnotationTagParser.1=
-AnnotationTagRegistry.0=More than one 'AnnotationTagInfo' tag for the tag '
-AnnotationTagRegistry.9=parseTagAttribs: unknown 'use' value:
-AnnotationTagRegistry.10=Incomplete element AnnotationTagInfo in plugin {0}
-AnnotationTagRegistry.11=parseTagAttribs: unknown 'isJavaTypeIdentifier' value:
+TagSpec_3=Unknown tag scope:
+TagSpec_4=Null tag scope.
+TagSpec_5=Unknown tag multiplicity:
+TagSpec_6=Null tag multiplicity.
+TagAttribSpec_1=Unknown 'unique' scope value:
+TagAttribSpec_2=More than one 'unique' tag defined:
+AnnotationTagParser_0=Null event handler.
+AnnotationTagParser_1=
+AnnotationTagRegistry_0=More than one 'AnnotationTagInfo' tag for the tag '
+AnnotationTagRegistry_9=parseTagAttribs: unknown 'use' value:
+AnnotationTagRegistry_10=Incomplete element AnnotationTagInfo in plugin {0}
+AnnotationTagRegistry_11=parseTagAttribs: unknown 'isJavaTypeIdentifier' value:
 AnnotationsControllerManager_ERROR_0=IWAE0001E Invalid IConfigurationElement used to create AnnotationsControllerRegistry.Descriptor.
+AnnotationTagRegistry_ERROR_1=
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation-tag-info.exsd b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation-tag-info.exsd
index 3bdae47..75cebf8 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation-tag-info.exsd
+++ b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation-tag-info.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.common.annotations.controller">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.common.annotations.controller" id="XAnnotationTagInfo" name="Annotation Tag Info"/>
+         <meta.schema plugin="org.eclipse.jst.common.annotations.controller" id="AnnotationTagInfo" name="Annotation Tag Info"/>
       </appInfo>
       <documentation>
          Describes the tags contained by a tag set and the tag&apos;s attributes.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -47,7 +47,7 @@
          <attribute name="tagSet" type="string" use="required">
             <annotation>
                <documentation>
-                  Name of the tag set this tag comes underneath.  ( for instance, if we&apos;re defining the &lt;code&gt;@ejb.bean&lt;/code&gt;
+                  Name of the tag set this tag comes underneath.  ( for instance, if we&apos;re defining the &lt;code&gt;@ejb.bean&lt;/code&gt;
 tag, then the tag set would be &lt;code&gt;ejb&lt;/code&gt;. )  The tag set must have been defined using the annotation.tagset extension point.
                </documentation>
             </annotation>
@@ -94,8 +94,8 @@
          <attribute name="description" type="string">
             <annotation>
                <documentation>
-                  Optional description.  May be a description string, or a
-key to localized text for the description in the declaring plugin&apos;s resource bundle. No default if this is
+                  Optional description.  May be a description string, or a
+key to localized text for the description in the declaring plugin&apos;s resource bundle. No default if this is
 not specified.
                </documentation>
             </annotation>
@@ -208,7 +208,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -217,7 +217,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -226,7 +226,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -235,7 +235,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -244,7 +244,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation.tagset.exsd b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation.tagset.exsd
index 4f459be..9faf3c1 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation.tagset.exsd
+++ b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotation.tagset.exsd
@@ -3,13 +3,13 @@
 <schema targetNamespace="org.eclipse.jst.common.annotations.controller">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.common.annotations.controller" id="pXAnnotationTagset" name="Annotations Tag Set"/>
+         <meta.schema plugin="org.eclipse.jst.common.annotations.controller" id="AnnotationTagSet" name="Annotations Tag Set"/>
       </appInfo>
       <documentation>
-         Allows clients to define a tag set for an annotation 
-tag.  A tag set named X would contain all of the tags that
-look like &lt;code&gt;@X.tag&lt;/code&gt;.  So the &lt;code&gt;ejb&lt;/code&gt;
-tag set would contain the &lt;code&gt;@ejb.bean&lt;/code&gt; tag, 
+         Allows clients to define a tag set for an annotation 
+tag.  A tag set named X would contain all of the tags that
+look like &lt;code&gt;@X.tag&lt;/code&gt;.  So the &lt;code&gt;ejb&lt;/code&gt;
+tag set would contain the &lt;code&gt;@ejb.bean&lt;/code&gt; tag, 
 the &lt;code&gt;@ejb.persistence&lt;/code&gt; tag, the &lt;code&gt;@ejb.pk&lt;/code&gt; tag, etc...
       </documentation>
    </annotation>
@@ -22,21 +22,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -55,8 +55,8 @@
          <attribute name="displayName" type="string">
             <annotation>
                <documentation>
-                  The text of the display name for the tag, or a resource
-key pointing to the localized display name inside of the
+                  The text of the display name for the tag, or a resource
+key pointing to the localized display name inside of the
 declaring plugin&apos;s resource bundle.
                </documentation>
             </annotation>
@@ -64,7 +64,7 @@
          <attribute name="description" type="string">
             <annotation>
                <documentation>
-                  A description of the tag set.  Can be the text of the 
+                  A description of the tag set.  Can be the text of the 
 description, or a key for the declaring plugin&apos;s resource bundle that points to the localized text for the tag set description.
                </documentation>
             </annotation>
@@ -91,7 +91,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -100,7 +100,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -109,7 +109,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -118,7 +118,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -127,7 +127,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationTagDynamicInitializer.exsd b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationTagDynamicInitializer.exsd
index 1f999e1..3eab09e 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationTagDynamicInitializer.exsd
+++ b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationTagDynamicInitializer.exsd
@@ -1,9 +1,9 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <!-- Schema file written by PDE -->
-<schema targetNamespace="com.ibm.wtp.annotations.controller">
+<schema targetNamespace="org.eclipse.jst.common.annotations.controller">
 <annotation>
       <appInfo>
-         <meta.schema plugin="com.ibm.wtp.annotations.controller" id="annotationTagDynamicInitializer" name="annotationTagDynamicInitializer"/>
+         <meta.schema plugin="org.eclipse.jst.common.annotations.controller" id="annotationTagDynamicInitializer" name="Annotation Tag Dynamic Initializer"/>
       </appInfo>
       <documentation>
          This extension point is used to allow for clients to define their annotation tags dynamically.  This means that it is not necessary to statically define annotation tags using the tag-info extension point.  The extensions for this point will be called just after initializing the static annotation tags from the tag-info extension point.
@@ -18,21 +18,21 @@
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
                <appInfo>
                   <meta.attribute translatable="true"/>
@@ -59,7 +59,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -68,7 +68,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -77,7 +77,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -86,7 +86,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -95,7 +95,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationsController.exsd b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationsController.exsd
index ea98e87..a7c5daa 100644
--- a/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationsController.exsd
+++ b/plugins/org.eclipse.jst.common.annotations.controller/schema/annotationsController.exsd
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -70,7 +70,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -79,7 +79,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -88,7 +88,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -97,7 +97,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -106,7 +106,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.common.annotations.core/.cvsignore b/plugins/org.eclipse.jst.common.annotations.core/.cvsignore
index d3fa362..abd5a75 100644
--- a/plugins/org.eclipse.jst.common.annotations.core/.cvsignore
+++ b/plugins/org.eclipse.jst.common.annotations.core/.cvsignore
@@ -2,3 +2,5 @@
 temp.folder
 annotations-core.jar
 build.xml
+@dot
+src.zip
diff --git a/plugins/org.eclipse.jst.common.annotations.core/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.common.annotations.core/META-INF/MANIFEST.MF
index 00c8a6a..d758a4c 100644
--- a/plugins/org.eclipse.jst.common.annotations.core/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.common.annotations.core/META-INF/MANIFEST.MF
@@ -8,4 +8,5 @@
 Export-Package: .,
  org.eclipse.jst.common.internal.annotations.core
 Require-Bundle: org.eclipse.emf.ecore,
- org.eclipse.wst.common.emf
+ org.eclipse.wst.common.emf,
+ org.eclipse.core.runtime
diff --git a/plugins/org.eclipse.jst.common.annotations.core/property_files/annotationcore.properties b/plugins/org.eclipse.jst.common.annotations.core/property_files/annotationcore.properties
index 92b4d62..19a34cc 100644
--- a/plugins/org.eclipse.jst.common.annotations.core/property_files/annotationcore.properties
+++ b/plugins/org.eclipse.jst.common.annotations.core/property_files/annotationcore.properties
@@ -4,13 +4,14 @@
 # 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:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-TagSpec.3=Unknown tag scope:
-TagSpec.4=Null tag scope.
-AnnotationTagParser.0=Null event handler.
-AnnotationTagParser.1=
-AnnotationTagRegistry.0=More than one 'AnnotationTagInfo' tag for the tag '
-AnnotationTagRegistry.9=parseTagAttribs: unknown 'use' value:
+TagSpec_3=Unknown tag scope:
+TagSpec_4=Null tag scope.
+TagAttribSpec_6=
+AnnotationTagParser_0=Null event handler.
+AnnotationTagParser_1=
+AnnotationTagRegistry_0=More than one 'AnnotationTagInfo' tag for the tag '
+AnnotationTagRegistry_9=parseTagAttribs: unknown 'use' value:
diff --git a/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationTagParser.java b/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationTagParser.java
index f87a38a..6196693 100644
--- a/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationTagParser.java
+++ b/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationTagParser.java
@@ -34,7 +34,7 @@
 
 	public AnnotationTagParser(TagParseEventHandler tp) {
 		if (tp == null) {
-			throw new IllegalArgumentException(AnnotationsCoreResources.getString("AnnotationTagParser.0")); //$NON-NLS-1$
+			throw new IllegalArgumentException(AnnotationsCoreResources.AnnotationTagParser_0); 
 		}
 		handler = tp;
 	}
diff --git a/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationsCoreResources.java b/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationsCoreResources.java
index e7fdec1..81b8276 100644
--- a/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationsCoreResources.java
+++ b/plugins/org.eclipse.jst.common.annotations.core/src/org/eclipse/jst/common/internal/annotations/core/AnnotationsCoreResources.java
@@ -1,53 +1,34 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Mar 8, 2004
  *
- * To change the template for this generated file go to
- * Window - Preferences - Java - Code Generation - Code and Comments
- */
-
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.common.internal.annotations.core;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-/**
- * @author kkatyal
- * 
- * To change the template for this generated type comment go to Window - Preferences - Java - Code
- * Generation - Code and Comments
- */
-public class AnnotationsCoreResources {
+public final class AnnotationsCoreResources extends NLS {
 
 	private static final String BUNDLE_NAME = "annotationcore";//$NON-NLS-1$
-	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);
 
-	/**
-	 *  
-	 */
 	private AnnotationsCoreResources() {
-		// TODO Auto-generated constructor stub
+		// Do not instantiate
 	}
 
-	/**
-	 * @param key
-	 * @return
-	 */
-	public static String getString(String key) {
-		// TODO Auto-generated method stub
-		try {
-			return RESOURCE_BUNDLE.getString(key);
-		} catch (MissingResourceException e) {
-			return '!' + key + '!';
-		}
+	public static String TagSpec_3;
+	public static String TagSpec_4;
+	public static String TagAttribSpec_6;
+	public static String AnnotationTagParser_0;
+	public static String AnnotationTagParser_1;
+	public static String AnnotationTagRegistry_0;
+	public static String AnnotationTagRegistry_9;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, AnnotationsCoreResources.class);
 	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.common.annotations.ui/.cvsignore b/plugins/org.eclipse.jst.common.annotations.ui/.cvsignore
index 2521e52..80fffc1 100644
--- a/plugins/org.eclipse.jst.common.annotations.ui/.cvsignore
+++ b/plugins/org.eclipse.jst.common.annotations.ui/.cvsignore
@@ -2,3 +2,5 @@
 temp.folder
 build.xml
 ui.jar
+@dot
+src.zip
diff --git a/plugins/org.eclipse.jst.common.annotations.ui/property_files/taghandlerui.properties b/plugins/org.eclipse.jst.common.annotations.ui/property_files/taghandlerui.properties
index a184107..2d29099 100644
--- a/plugins/org.eclipse.jst.common.annotations.ui/property_files/taghandlerui.properties
+++ b/plugins/org.eclipse.jst.common.annotations.ui/property_files/taghandlerui.properties
@@ -4,9 +4,9 @@
 # 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:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-J2EEAnnotationsCompletionProcessor.3=Error parsing attributes - was expecing a '=' but found '
-J2EEAnnotationsCompletionProcessor.4=' instead.
+J2EEAnnotationsCompletionProcessor_3=Error parsing attributes - was expecing a '=' but found '
+J2EEAnnotationsCompletionProcessor_4=' instead.
diff --git a/plugins/org.eclipse.jst.common.annotations.ui/src/org/eclipse/jst/common/internal/annotations/ui/IWRDResources.java b/plugins/org.eclipse.jst.common.annotations.ui/src/org/eclipse/jst/common/internal/annotations/ui/IWRDResources.java
index 5062b28..6ef86fa 100644
--- a/plugins/org.eclipse.jst.common.annotations.ui/src/org/eclipse/jst/common/internal/annotations/ui/IWRDResources.java
+++ b/plugins/org.eclipse.jst.common.annotations.ui/src/org/eclipse/jst/common/internal/annotations/ui/IWRDResources.java
@@ -1,53 +1,29 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Mar 4, 2004
  *
- * To change the template for this generated file go to
- * Window - Preferences - Java - Code Generation - Code and Comments
- */
-
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.common.internal.annotations.ui;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-/**
- * @author kkatyal
- * 
- * To change the template for this generated type comment go to Window - Preferences - Java - Code
- * Generation - Code and Comments
- */
-public class IWRDResources {
+public final class IWRDResources extends NLS {
 
-	private static final String BUNDLE_NAME = "taghandlerui";//$NON-NLS-1$
-	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);
+	private static final String BUNDLE_NAME = "org.eclipse.jst.common.internal.annotations.ui.taghandlerui";//$NON-NLS-1$
 
-	/**
-	 *  
-	 */
 	private IWRDResources() {
-		// TODO Auto-generated constructor stub
+		// Do not instantiate
 	}
 
-	/**
-	 * @param key
-	 * @return
-	 */
-	public static String getString(String key) {
-		// TODO Auto-generated method stub
-		try {
-			return RESOURCE_BUNDLE.getString(key);
-		} catch (MissingResourceException e) {
-			return '!' + key + '!';
-		}
+	public static String J2EEAnnotationsCompletionProcessor_3;
+	public static String J2EEAnnotationsCompletionProcessor_4;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, IWRDResources.class);
 	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.common.frameworks/.cvsignore b/plugins/org.eclipse.jst.common.frameworks/.cvsignore
index c643447..e621eda 100644
--- a/plugins/org.eclipse.jst.common.frameworks/.cvsignore
+++ b/plugins/org.eclipse.jst.common.frameworks/.cvsignore
@@ -3,3 +3,4 @@
 build.xml
 jdt_integration.jar
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.common.frameworks/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.common.frameworks/META-INF/MANIFEST.MF
index 88c4f90..5e66062 100644
--- a/plugins/org.eclipse.jst.common.frameworks/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.common.frameworks/META-INF/MANIFEST.MF
@@ -11,6 +11,7 @@
  org.eclipse.jst.common.project.facet
 Require-Bundle: org.eclipse.core.runtime,
  org.eclipse.jdt.core,
+ org.eclipse.jdt.launching,
  org.eclipse.emf.ecore,
  org.eclipse.emf.ecore.xmi,
  org.eclipse.wst.common.frameworks,
diff --git a/plugins/org.eclipse.jst.common.frameworks/component.xml b/plugins/org.eclipse.jst.common.frameworks/component.xml
index 07a555f..4a89647 100644
--- a/plugins/org.eclipse.jst.common.frameworks/component.xml
+++ b/plugins/org.eclipse.jst.common.frameworks/component.xml
@@ -3,8 +3,6 @@
 	name="org.eclipse.jst.common.frameworks">
 	<component-depends unrestricted="true"></component-depends>
 	<plugin id="org.eclipse.jst.common.frameworks" fragment="false" />
-	<plugin id="org.eclipse.jst.common.frameworks.ui" fragment="false" />
-	<plugin id="org.eclipse.jst.common.launcher.ant" fragment="false" />
 	<plugin id="org.eclipse.jst.common.navigator.java" fragment="false" />
 	<plugin id="org.eclipse.jst.common.annotations.controller"
 		fragment="false" />
diff --git a/plugins/org.eclipse.jst.common.frameworks/plugin.xml b/plugins/org.eclipse.jst.common.frameworks/plugin.xml
index ef1db7f..c0b12f3 100644
--- a/plugins/org.eclipse.jst.common.frameworks/plugin.xml
+++ b/plugins/org.eclipse.jst.common.frameworks/plugin.xml
@@ -50,6 +50,7 @@
       <action type="runtime-changed">
         <delegate class="org.eclipse.jst.common.project.facet.JavaFacetRuntimeChangedDelegate"/>
       </action>
+      <group-member id="java"/>
     </project-facet-version>
 
     <project-facet-version facet="jst.java" version="1.4">
@@ -63,6 +64,7 @@
       <action type="runtime-changed">
         <delegate class="org.eclipse.jst.common.project.facet.JavaFacetRuntimeChangedDelegate"/>
       </action>
+      <group-member id="java"/>
     </project-facet-version>
 
     <project-facet-version facet="jst.java" version="5.0">
@@ -76,6 +78,7 @@
       <action type="runtime-changed">
         <delegate class="org.eclipse.jst.common.project.facet.JavaFacetRuntimeChangedDelegate"/>
       </action>
+      <group-member id="java"/>
     </project-facet-version>
 
   </extension>
diff --git a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/jdt/internal/classpath/FlexibleProjectContainer.java b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/jdt/internal/classpath/FlexibleProjectContainer.java
index f30a659..4872609 100644
--- a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/jdt/internal/classpath/FlexibleProjectContainer.java
+++ b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/jdt/internal/classpath/FlexibleProjectContainer.java
@@ -31,7 +31,6 @@
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jem.workbench.utility.JemProjectUtilities;
 import org.eclipse.jst.common.frameworks.CommonFrameworksPlugin;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
@@ -50,19 +49,11 @@
 {
     protected static final class PathType
     {
-//        private final String type;
-        
-        private PathType( final String type )
-        {
-//           this.type = type;
-        }
-        
         public static final PathType 
-            LIB_DIRECTORY = new PathType( "lib" ), //$NON-NLS-1$
-            CLASSES_DIRECTORY = new PathType( "classes" ); //$NON-NLS-1$
+            LIB_DIRECTORY = new PathType(),
+            CLASSES_DIRECTORY = new PathType();
     }
     
-    private static IWorkspace workspace;
     private static ClasspathDecorationsManager decorations; 
 
     static
@@ -71,8 +62,10 @@
         // resources relevant to flexible project containers across the
         // workspace and refresh them as necessary.
         
-        workspace = ResourcesPlugin.getWorkspace();
-        workspace.addResourceChangeListener( new Listener() );
+        final IWorkspace ws = ResourcesPlugin.getWorkspace();
+        
+        ws.addResourceChangeListener( new Listener(), 
+                                      IResourceChangeEvent.POST_CHANGE );
         
         // Read the decorations from the workspace metadata.
         
@@ -113,17 +106,12 @@
             return;
         }
               
-    //    final String cid = this.path.toString(); 
-            
-        
         final IVirtualComponent vc = ComponentCore.createComponent(this.project);
         
         for( int i = 0; i < paths.length; i++ )
         {
-            //final IVirtualFolder vf = vc.getFolder( paths[ i ] );			
-			IVirtualFolder rootFolder = vc.getRootFolder();
+			final IVirtualFolder rootFolder = vc.getRootFolder();
 			final IVirtualFolder vf = rootFolder.getFolder( paths[ i ] );
-
             
             if( types[ i ] == PathType.LIB_DIRECTORY )
             {
@@ -175,7 +163,7 @@
             }
         }
         
-        w.add( this.project.getFullPath().append( IModuleConstants.COMPONENT_FILE_PATH ) ); //$NON-NLS-1$
+        w.add( this.project.getFullPath().append( IModuleConstants.COMPONENT_FILE_PATH ) );
             
         this.cpentries = new IClasspathEntry[ cp.size() ];
         cp.toArray( this.cpentries );
@@ -243,36 +231,38 @@
     
     private boolean isSourceDirectory( final IPath aPath )
     {
-        try
+        if( isJavaProject( this.project ) )
         {
-            final IJavaProject jproject = JavaCore.create( this.project );
-            final IClasspathEntry[] cp = jproject.getRawClasspath();
-            
-            for( int i = 0; i < cp.length; i++ )
+            try
             {
-                final IClasspathEntry cpe = cp[ i ];
-                
-                if( cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE &&
-                    cpe.getPath().equals( aPath ) )
-                {
-                    return true;
-                }
+                final IJavaProject jproject = JavaCore.create( this.project );
+	            final IClasspathEntry[] cp = jproject.getRawClasspath();
+	            
+	            for( int i = 0; i < cp.length; i++ )
+	            {
+	                final IClasspathEntry cpe = cp[ i ];
+	                
+	                if( cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE &&
+	                    cpe.getPath().equals( aPath ) )
+	                {
+	                    return true;
+	                }
+	            }
             }
-         
-            return false;
+            catch( JavaModelException e )
+            {
+                CommonFrameworksPlugin.log( e );
+            }
         }
-        catch( JavaModelException e )
-        {
-            CommonFrameworksPlugin.log( e );
-            return false;
-        }
+    
+        return false;    
     }
     
     private static boolean isJavaProject( final IProject pj )
     {
         try
         {
-            return pj.getNature(JemProjectUtilities.JEM_EMF_NatureID) != null;
+            return pj.getNature( JavaCore.NATURE_ID ) != null;
         }
         catch( CoreException e )
         {
@@ -284,10 +274,7 @@
     {
         try
         {
-            final String nature 
-                = "org.eclipse.wst.common.modulecore.ModuleCoreNature"; //$NON-NLS-1$
-            
-            return pj.getNature( nature ) != null;
+            return pj.getNature( IModuleConstants.MODULE_NATURE_ID ) != null;
         }
         catch( CoreException e )
         {
@@ -305,7 +292,9 @@
             // Locate all of the flexible project containers.
             
             final ArrayList containers = new ArrayList();
-            final IProject[] projects = workspace.getRoot().getProjects();
+            
+            final IProject[] projects 
+                = ResourcesPlugin.getWorkspace().getRoot().getProjects();
             
             for( int i = 0; i < projects.length; i++ )
             {
diff --git a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDataModelProvider.java
index 5747cd1..8872f6a 100644
--- a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDataModelProvider.java
+++ b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDataModelProvider.java
@@ -12,6 +12,9 @@
 
 import java.util.Set;
 
+import org.eclipse.jdt.launching.IVMInstall;
+import org.eclipse.jdt.launching.IVMInstall2;
+import org.eclipse.jdt.launching.JavaRuntime;
 import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 
@@ -30,10 +33,22 @@
 	public Object getDefaultProperty(String propertyName) {
 		if (FACET_ID.equals(propertyName)) {
 			return IModuleConstants.JST_JAVA;
+		} else if (FACET_VERSION.equals(propertyName)) {
+			IVMInstall vmInstall = JavaRuntime.getDefaultVMInstall();
+			IVMInstall2 vmInstall2 = (IVMInstall2) vmInstall;
+			String jvmver = vmInstall2.getJavaVersion();
+			if (jvmver != null) {
+				if (jvmver.startsWith("1.3")) { //$NON-NLS-1$
+					return JavaFacetUtils.JAVA_13;
+				} else if (jvmver.startsWith("1.4")) { //$NON-NLS-1$
+					return JavaFacetUtils.JAVA_14;
+				}
+				return JavaFacetUtils.JAVA_50;
+			}
+			return JavaFacetUtils.JAVA_14;
+		} else if (SOURCE_FOLDER_NAME.equals(propertyName)) {
+			return "src";
 		}
-        else if (SOURCE_FOLDER_NAME.equals(propertyName)) {
-            return "src";
-        }
 		return super.getDefaultProperty(propertyName);
 	}
 
diff --git a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDelegate.java b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDelegate.java
index af2c1f2..39d7a73 100644
--- a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetInstallDelegate.java
@@ -93,7 +93,7 @@
 			// this might already be set so at the workspace level in case
 			// workspace settings change later or the project is included in a
 			// different workspace.
-
+			
 			JavaFacetUtils.setCompilerLevel(project, fv);
 
 			if (monitor != null) {
diff --git a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetRuntimeChangedDelegate.java b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetRuntimeChangedDelegate.java
index 2ae2960..7e182f1 100644
--- a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetRuntimeChangedDelegate.java
+++ b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetRuntimeChangedDelegate.java
@@ -14,6 +14,7 @@
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
@@ -54,6 +55,8 @@
             {
                 monitor.worked( 1 );
             }
+        }catch(Exception e){
+        	Logger.getLogger().logError(e);
         }
         finally
         {
diff --git a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetUtils.java b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetUtils.java
index 2577254..8f06ed8 100644
--- a/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetUtils.java
+++ b/plugins/org.eclipse.jst.common.frameworks/src/org/eclipse/jst/common/project/facet/JavaFacetUtils.java
@@ -28,13 +28,13 @@
 
 public final class JavaFacetUtils
 {
-    private static final IProjectFacetVersion JAVA_13
+    public static final IProjectFacetVersion JAVA_13
         = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_JAVA).getVersion( "1.3" );
     
-    private static final IProjectFacetVersion JAVA_14
+    public static final IProjectFacetVersion JAVA_14
         = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_JAVA).getVersion( "1.4" );
 
-    private static final IProjectFacetVersion JAVA_50
+    public static final IProjectFacetVersion JAVA_50
         = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_JAVA).getVersion( "5.0" );
     
     public static void setCompilerLevel( final IProject project,
diff --git a/plugins/org.eclipse.jst.j2ee.core/.cvsignore b/plugins/org.eclipse.jst.j2ee.core/.cvsignore
index 963bc29..994d5a2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.core/.cvsignore
@@ -2,3 +2,5 @@
 temp.folder
 build.xml
 runtime
+@dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.core/build.properties b/plugins/org.eclipse.jst.j2ee.core/build.properties
index 4dc04e7..f7a63be 100644
--- a/plugins/org.eclipse.jst.j2ee.core/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/build.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -13,7 +13,8 @@
                changes.log,\
                META-INF/,\
                about.html,\
-               .
+               .,\
+               schema/
 src.includes = rose/,\
                component.xml,\
                model/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/commonarchive.properties b/plugins/org.eclipse.jst.j2ee.core/commonArchive/commonarchive.properties
index 837df54..f50f549 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/commonarchive.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/commonarchive.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -62,10 +62,10 @@
 Parameter_should_not_be_nu_EXC_=IWAE0052E Parameter should not be null
 Archive_is_not_a_valid_EJB_EXC_=IWAE0055E Archive is not a valid EJB JAR file (1.0) because no serialized deployment descriptors can be found, either in the manifest or in entries with a ".ser" extension
 _The_following_files_could_EXC_=IWAE0056E The following files could not be loaded:
-FixPrimKeyCommand_failed_-_EXC_=IWAE0057E FixPrimKeyCommand failed - exception stack trace:
+FixPrimKeyCommand_failed___EXC_=IWAE0057E FixPrimKeyCommand failed - exception stack trace:
 FixPrimKeyCommand_usage___=FixPrimKeyCommand usage:  <sourceJarFilePath> [destinationPath]
 FixPrimKeyCommand_usage__s_EXC_=IWAE0058E FixPrimKeyCommand usage: sourceJarFilePath must point to a valid EJB JAR file or directory of an inflated EJB JAR file
-Repair_command_failed_-_ex_EXC_=IWAE0059E Repair command failed - exception stack trace:
+Repair_command_failed___ex_EXC_=IWAE0059E Repair command failed - exception stack trace:
 Repairs_all_entries_in_the=Repairs all entries in the META-INF and/or WEB-INF directories to be the correct case
 RepairArchiveCommand_usage=RepairArchiveCommand usage:  <sourceJarFilePath> <destinationPath>
 RepairArchiveCommand_usage1_ERROR_=IWAE0060E RepairArchiveCommand usage: sourceJarFilePath must point to a valid archive or directory of an inflated archive
@@ -91,4 +91,4 @@
 File_not_correct_type=The file {0} in EAR file {1} is not the correct type based on the application deployment descriptor.  Expected type: {2}";
 Module_not_in_EAR=Module is not in an EAR: {0}
 Module_file_does_not_exist_2=Module file does not exist for Module ref.  Module = {0}
-FileImpl._Error_0=Recursive containment not allowed for
+FileImpl__Error_0=Recursive containment not allowed for
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/Archive.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/Archive.java
index 99a1d6f..df8bd31 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/Archive.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/Archive.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonArchiveResourceHandler.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonArchiveResourceHandler.java
index 06357a8..8296270 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonArchiveResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonArchiveResourceHandler.java
@@ -1,62 +1,114 @@
 package org.eclipse.jst.j2ee.commonarchivecore.internal;
 
-/*
- * Licensed Material - Property of IBM 
- * (C) Copyright IBM Corp. 2001, 2002 - All Rights Reserved. 
- * US Government Users Restricted Rights - Use, duplication or disclosure 
- * restricted by GSA ADP Schedule Contract with IBM Corp. 
- */
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
- * Licensed Materials - Property of IBM,
- * WebSphere Studio Workbench
- * (c) Copyright IBM Corp 2001
- */
+import org.eclipse.osgi.util.NLS;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+public class CommonArchiveResourceHandler extends NLS {
+	private static final String BUNDLE_NAME = "commonarchive";//$NON-NLS-1$
 
-public class CommonArchiveResourceHandler {
-
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("commonarchive");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private CommonArchiveResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String not_a_dir_EXC_;
+	public static String FileImpl__Error_0;
+	public static String RepairArchiveCommand_usage1_ERROR_;
+	public static String file_exist_as_dir_EXC_;
+	public static String duplicate_entry_EXC_;
+	public static String ser_not_dd_EXC_;
+	public static String EAR_File;
+	public static String RAR_File;
+	public static String filename_exception_EXC_;
+	public static String An_Application_Client_JAR_file;
+	public static String no_sec_role_EXC_;
+	public static String Original_archive_is_not_a__EXC_;
+	public static String duplicate_module_EXC_;
+	public static String reading_dd_EXC_;
+	public static String Module_file_does_not_exist_2;
+	public static String A_WAR_file;
+	public static String IOException_occurred_while_EXC_;
+	public static String io_ex_manifest_EXC_;
+	public static String FixPrimKeyCommand_usage__s_EXC_;
+	public static String FixPrimKeyCommand_usage___;
+	public static String Parameter_should_not_be_nu_EXC_;
+	public static String dd_in_ear_load_EXC_;
+	public static String no_dds_10_EXC_;
+	public static String list_components_war_EXC_;
+	public static String An_EJB_JAR_file;
+	public static String open_nested_EXC_;
+	public static String Repair_command_failed___ex_EXC_;
+	public static String nested_open_fail_EXC_;
+	public static String Error_iterating_the_archiv_EXC_;
+	public static String make_temp_file_WARN_;
+	public static String missing_class_EXC_;
+	public static String repair_usage_ERROR_;
+	public static String Application_Client_Jar_Fil;
+	public static String WAR_File;
+	public static String could_not_find_dir_EXC_;
+	public static String Converted;
+	public static String Absolute_path_unknown_EXC_;
+	public static String add_copy_lib_dir_EXC_;
+	public static String removing_key_field_INFO_;
+	public static String Module_file;
+	public static String Stack_trace_of_nested_exce_EXC_;
+	public static String tx_bean_mgd_WARN_;
+	public static String manifest_dd_load_EXC_;
+	public static String key_class_reflection_ERROR_;
+	public static String uncontained_module_EXC_;
+	public static String file_not_found_EXC_;
+	public static String io_ex_reading_dd_EXC_;
+	public static String invalid_cp_file_WARN_;
+	public static String invalid_archive_EXC_;
+	public static String load_resource_EXC_;
+	public static String invalid_classpath_WARN_;
+	public static String Extract_destination_is_the_EXC_;
+	public static String subclass_responsibilty_EXC_;
+	public static String Module_not_in_EAR;
+	public static String File_not_correct_type;
+	public static String io_ex_loading_EXC_;
+	public static String could_not_open_EXC_;
+	public static String manifest_dd_find_EXC_;
+	public static String nested_jar_EXC_;
+	public static String dup_resource_EXC_;
+	public static String Repairs_all_entries_in_the;
+	public static String add_copy_class_dir_EXC_;
+	public static String io_ex_reopen_EXC_;
+	public static String Error_occurred_iterating_f_EXC_;
+	public static String dup_sec_role_module_EXC_;
+	public static String duplicate_file_EXC_;
+	public static String inferred_dds_EXC_;
+	public static String unable_replace_EXC_;
+	public static String EJB_Jar_File;
+	public static String A_file_does_not_exist_for_module;
+	public static String A_RAR_file;
+	public static String dup_sec_role_EXC_;
+	public static String _The_following_files_could_EXC_;
+	public static String key_field_reflection_ERROR_;
+	public static String End_of_list_reached_EXC_;
+	public static String error_saving_EXC_;
+	public static String Archive_is_not_a_valid_EJB_EXC_;
+	public static String make_temp_dir_EXC_;
+	public static String RepairArchiveCommand_usage;
+	public static String FixPrimKeyCommand_failed___EXC_;
+	public static String A_Application_file;
+	public static String Null_uri_EXC_;
+	public static String Internal_Error__Iterator_o_EXC_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, CommonArchiveResourceHandler.class);
 	}
 
 	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
+		return NLS.bind(key, args);
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchiveFactory.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchiveFactory.java
index f5af0aa..b3a0046 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchiveFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchiveFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchivePackage.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchivePackage.java
index a0c64d1..78531c2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchivePackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/CommonarchivePackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/File.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/File.java
index 5814e0c..98e9c84 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/File.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/File.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ModuleRef.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ModuleRef.java
index c9d8f7a..6b8bf8a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ModuleRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ModuleRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RARFile.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RARFile.java
index 56ddf53..7df5520 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RARFile.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RARFile.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RepairArchiveCommand.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RepairArchiveCommand.java
index d7cfe2d..94c750c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RepairArchiveCommand.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/RepairArchiveCommand.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -42,7 +42,7 @@
 	 *            java.lang.String
 	 */
 	public RepairArchiveCommand(Archive anArchive) {
-		super("Repair Archive", CommonArchiveResourceHandler.getString("Repairs_all_entries_in_the")); //$NON-NLS-2$ = "Repairs all entries in the META-INF and/or WEB-INF directories to be the correct case"//$NON-NLS-1$
+		super("Repair Archive", CommonArchiveResourceHandler.Repairs_all_entries_in_the); // = "Repairs all entries in the META-INF and/or WEB-INF directories to be the correct case"//$NON-NLS-1$
 		archive = anArchive;
 		//Ensure Initiailization
 		getDirectoryNames();
@@ -109,7 +109,7 @@
 			new RepairArchiveCommand(anArchive).execute();
 			anArchive.saveAs(args[1]);
 		} catch (Exception ex) {
-			System.out.println(CommonArchiveResourceHandler.getString("Repair_command_failed_-_ex_EXC_")); //$NON-NLS-1$ = "Repair command failed - exception stack trace:"
+			System.out.println(CommonArchiveResourceHandler.Repair_command_failed___ex_EXC_); // = "Repair command failed - exception stack trace:"
 			ex.printStackTrace();
 		}
 	}
@@ -127,7 +127,7 @@
 
 	protected static boolean validateArgs(String[] args) {
 		if (!(args.length == 2)) {
-			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(CommonArchiveResourceHandler.getString("RepairArchiveCommand_usage")); //$NON-NLS-1$ = "RepairArchiveCommand usage:  <sourceJarFilePath> <destinationPath>"
+			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(CommonArchiveResourceHandler.RepairArchiveCommand_usage); // = "RepairArchiveCommand usage:  <sourceJarFilePath> <destinationPath>"
 			return false;
 		}
 		java.io.File file = new java.io.File(args[0]);
@@ -147,11 +147,11 @@
 				}
 		}
 		if (!isZip && !file.isDirectory()) {
-			System.out.println(CommonArchiveResourceHandler.getString("RepairArchiveCommand_usage1_ERROR_")); //$NON-NLS-1$ = "RepairArchiveCommand usage: sourceJarFilePath must point to a valid archive or directory of an inflated archive"
+			System.out.println(CommonArchiveResourceHandler.RepairArchiveCommand_usage1_ERROR_); // = "RepairArchiveCommand usage: sourceJarFilePath must point to a valid archive or directory of an inflated archive"
 			return false;
 		}
 		if (new java.io.File(args[1]).canWrite()) {
-			System.out.println(CommonArchiveResourceHandler.getString("repair_usage_ERROR_", (new Object[]{args[1]}))); //$NON-NLS-1$ = "RepairArchiveCommand usage: cannot write to destinationPath "
+			System.out.println(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.repair_usage_ERROR_, (new Object[]{args[1]}))); // = "RepairArchiveCommand usage: cannot write to destinationPath "
 			return false;
 		}
 		return true;
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ValidateXmlCommand.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ValidateXmlCommand.java
index cb6bfb2..f1de916 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ValidateXmlCommand.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/ValidateXmlCommand.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,6 +19,7 @@
 import java.util.List;
 
 import org.eclipse.emf.common.command.AbstractCommand;
+import org.eclipse.emf.common.command.Command;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.jst.j2ee.internal.xml.CollectingErrorHandler;
 import org.eclipse.jst.j2ee.internal.xml.XmlDocumentReader;
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/WARFile.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/WARFile.java
index 8807e6d..577b084 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/WARFile.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/WARFile.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveException.java
index fc458b1..5357b47 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,6 +17,11 @@
  */
 public class ArchiveException extends Exception {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 4340145465956505570L;
+
+	/**
 	 *  
 	 */
 	public ArchiveException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveRuntimeException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveRuntimeException.java
index 8b8ae78..11b1a5a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveRuntimeException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveRuntimeException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -23,6 +23,11 @@
  */
 public class ArchiveRuntimeException extends WrappedRuntimeException implements IWrappedException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -4727603215052186958L;
+
+	/**
 	 * Constructor for ArchiveRuntimeException.
 	 */
 	public ArchiveRuntimeException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveWrappedException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveWrappedException.java
index dc7fbe2..2396cb7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveWrappedException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ArchiveWrappedException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,11 @@
  */
 public class ArchiveWrappedException extends WrappedException implements IWrappedException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3011655166037300546L;
+
+	/**
 	 * Constructor for ArchiveWrappedException.
 	 */
 	public ArchiveWrappedException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DeploymentDescriptorLoadException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DeploymentDescriptorLoadException.java
index 19025f8..d7b8e62 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DeploymentDescriptorLoadException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DeploymentDescriptorLoadException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,6 +17,11 @@
  */
 public class DeploymentDescriptorLoadException extends ArchiveRuntimeException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -3870314481148871665L;
+
+	/**
 	 * ResourceLoadException constructor comment.
 	 */
 	public DeploymentDescriptorLoadException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DuplicateObjectException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DuplicateObjectException.java
index 5d0ea62..9c8be78 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DuplicateObjectException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/DuplicateObjectException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,6 +17,10 @@
  * the same name, id, etc, as another object in the list.
  */
 public class DuplicateObjectException extends ArchiveException {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 7269139518957826130L;
 	protected Object duplicate;
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/EmptyResourceException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/EmptyResourceException.java
index a3c223a..4d39f86 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/EmptyResourceException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/EmptyResourceException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,11 @@
  */
 public class EmptyResourceException extends ArchiveException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -6482393304280160585L;
+
+	/**
 	 * EmptyResourceException constructor comment.
 	 */
 	public EmptyResourceException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/IArchiveWrappedException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/IArchiveWrappedException.java
index a89b208..aa97248 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/IArchiveWrappedException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/IArchiveWrappedException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ManifestException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ManifestException.java
index 3eaad73..93fe205 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ManifestException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ManifestException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,6 +14,11 @@
 public class ManifestException extends ArchiveRuntimeException {
 
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1045140899078192019L;
+
+	/**
 	 * Constructor for ManifestException.
 	 */
 	public ManifestException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NestedJarException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NestedJarException.java
index a2a7e3e..5828f57 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NestedJarException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NestedJarException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,6 +17,11 @@
  */
 public class NestedJarException extends ArchiveRuntimeException {
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -559954723242646381L;
+
 	public NestedJarException() {
 		super();
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoEJB10DescriptorsException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoEJB10DescriptorsException.java
index 3b062c9..d9973e5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoEJB10DescriptorsException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoEJB10DescriptorsException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,6 +19,11 @@
  */
 public class NoEJB10DescriptorsException extends RuntimeException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 7222290886333179223L;
+
+	/**
 	 * NoEJB10DescriptorsException constructor comment.
 	 */
 	public NoEJB10DescriptorsException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleElementException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleElementException.java
index 3351aa6..68bc7ec 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleElementException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleElementException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,11 @@
  */
 public class NoModuleElementException extends ArchiveException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3781813351160222774L;
+
+	/**
 	 * NoModuleElementException constructor comment.
 	 */
 	public NoModuleElementException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleFileException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleFileException.java
index 76586b4..e1f435a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleFileException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NoModuleFileException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,6 +14,11 @@
 public class NoModuleFileException extends ArchiveRuntimeException {
 
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -7261084646147362776L;
+
+	/**
 	 * Constructor for NoModuleFileException.
 	 */
 	public NoModuleFileException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotADeploymentDescriptorException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotADeploymentDescriptorException.java
index 5f9d32a..4189745 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotADeploymentDescriptorException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotADeploymentDescriptorException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,6 +19,11 @@
  */
 public class NotADeploymentDescriptorException extends Exception {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -9072252417343910963L;
+
+	/**
 	 * NotADeploymentDescriptorException constructor comment.
 	 */
 	public NotADeploymentDescriptorException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotSupportedException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotSupportedException.java
index 7433485..435d13e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotSupportedException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/NotSupportedException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,6 +14,11 @@
 
 public class NotSupportedException extends ArchiveWrappedException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -6690631631593101382L;
+
+	/**
 	 * NotSupportedException constructor comment.
 	 */
 	public NotSupportedException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ObjectNotFoundException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ObjectNotFoundException.java
index 52a8170..1c266b0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ObjectNotFoundException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ObjectNotFoundException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,6 +19,11 @@
  */
 public class ObjectNotFoundException extends ArchiveException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3539317762510485699L;
+
+	/**
 	 * ObjectNotFoundException constructor comment.
 	 */
 	public ObjectNotFoundException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/OpenFailureException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/OpenFailureException.java
index 90b29d8..c78d4a4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/OpenFailureException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/OpenFailureException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,11 @@
  */
 public class OpenFailureException extends ArchiveWrappedException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -1786924156051091340L;
+
+	/**
 	 * OpenFailureException constructor comment.
 	 */
 	public OpenFailureException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ReopenException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ReopenException.java
index 566c788..be479db 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ReopenException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ReopenException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,6 +20,11 @@
  */
 public class ReopenException extends ArchiveWrappedException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -2797595721842336360L;
+
+	/**
 	 * ReopenException constructor comment.
 	 */
 	public ReopenException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ResourceLoadException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ResourceLoadException.java
index 8e58df5..394c836 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ResourceLoadException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/ResourceLoadException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,11 @@
  */
 public class ResourceLoadException extends ArchiveRuntimeException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -3337225489102635339L;
+
+	/**
 	 * ResourceLoadException constructor comment.
 	 */
 	public ResourceLoadException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SaveFailureException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SaveFailureException.java
index 860565e..b2bd556 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SaveFailureException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SaveFailureException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,11 @@
  */
 public class SaveFailureException extends ArchiveWrappedException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 8593253339847650246L;
+
+	/**
 	 * SaveFailureException constructor comment.
 	 */
 	public SaveFailureException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SubclassResponsibilityException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SubclassResponsibilityException.java
index a9e9e5c..2c1ef6e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SubclassResponsibilityException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/SubclassResponsibilityException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,11 @@
  */
 public class SubclassResponsibilityException extends ArchiveRuntimeException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -6815673671775564354L;
+
+	/**
 	 * SubclassResponsibilityException constructor comment.
 	 */
 	public SubclassResponsibilityException() {
@@ -34,6 +39,6 @@
 	 *            java.lang.String
 	 */
 	public SubclassResponsibilityException(String methodName) {
-		super(CommonArchiveResourceHandler.getString("subclass_responsibilty_EXC_", (new Object[]{methodName}))); //$NON-NLS-1$ = " must be implemented in subclass"
+		super(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.subclass_responsibilty_EXC_, (new Object[]{methodName}))); // = " must be implemented in subclass"
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/UncontainedModuleFileException.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/UncontainedModuleFileException.java
index 7098171..61ed825 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/UncontainedModuleFileException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/exception/UncontainedModuleFileException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,6 +20,11 @@
  */
 public class UncontainedModuleFileException extends ArchiveRuntimeException {
 	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 7311775746549718190L;
+
+	/**
 	 * UncontainedModuleException constructor comment.
 	 */
 	public UncontainedModuleFileException() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveInit.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveInit.java
index 49cf69d..71bb8e5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveInit.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveInit.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifest.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifest.java
index 207ebe5..cc4d350 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifest.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifest.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -77,6 +77,12 @@
 	 * required for the manifest to save correctly
 	 */
 	public String getManifestVersion();
+	
+	/**
+	 * Return the value iff the entry exists in a case-sensitive manner; implementation version is
+	 * optional in  the manifest
+	 * */
+	public String getImplementationVersion();
 
 	/**
 	 * Add all the entries not already contained in the class path of this manifest
@@ -97,6 +103,8 @@
 	public void setMainClass(String className);
 
 	public void setManifestVersion(java.lang.String version);
+	
+	public void setImplemenationVersion(java.lang.String version);
 
 	/**
 	 * @see java.util.jar.Manifest#write
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifestImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifestImpl.java
index 75f2cda..bf83bf3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifestImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveManifestImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -319,5 +319,14 @@
 		return;
 	}
 
+	public String getImplementationVersion() {
+		return getMainAttributes().getValue(Attributes.Name.IMPLEMENTATION_VERSION);
+	}
+
+	public void setImplemenationVersion(String version) {
+		Attributes attributes = getMainAttributes();
+		attributes.putValue(Attributes.Name.IMPLEMENTATION_VERSION.toString(), version);
+	}
+
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveOptions.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveOptions.java
index 92413c7..98afdf9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveOptions.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveOptions.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveTypeDiscriminatorImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveTypeDiscriminatorImpl.java
index 7d7b268..9046b3c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveTypeDiscriminatorImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveTypeDiscriminatorImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -142,7 +142,7 @@
 	}
 
 	protected String getXmlDDMessage(String archiveType, String ddUri) {
-		return CommonArchiveResourceHandler.getString("invalid_archive_EXC_", (new Object[]{archiveType, ddUri})); //$NON-NLS-1$ = "Archive is not a valid {0} because the deployment descriptor can not be found (case sensitive): {1}"
+		return CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.invalid_archive_EXC_, (new Object[]{archiveType, ddUri})); // = "Archive is not a valid {0} because the deployment descriptor can not be found (case sensitive): {1}"
 	}
 
 	public boolean hasChild(ArchiveTypeDiscriminator disc) {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveURIConverterImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveURIConverterImpl.java
index c8c0329..2285f55 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveURIConverterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/ArchiveURIConverterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/FileIteratorImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/FileIteratorImpl.java
index 7433f94..b1f4641 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/FileIteratorImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/FileIteratorImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -46,7 +46,7 @@
 
 	public File next() {
 		if (!hasNext())
-			throw new NoSuchElementException(CommonArchiveResourceHandler.getString("End_of_list_reached_EXC_")); //$NON-NLS-1$ = "End of list reached"
+			throw new NoSuchElementException(CommonArchiveResourceHandler.End_of_list_reached_EXC_); // = "End of list reached"
 		return (File) files.get(position++);
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/NestedArchiveIterator.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/NestedArchiveIterator.java
index 7de9773..622d940 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/NestedArchiveIterator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/NestedArchiveIterator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -57,7 +57,7 @@
 
 	public InputStream getInputStream(File aFile) throws java.io.IOException, java.io.FileNotFoundException {
 		if (!aFile.getURI().equals(currentEntry.getName()))
-			throw new java.io.IOException(CommonArchiveResourceHandler.getString("Internal_Error__Iterator_o_EXC_")); //$NON-NLS-1$ = "Internal Error: Iterator out of sync with zip entries"
+			throw new java.io.IOException(CommonArchiveResourceHandler.Internal_Error__Iterator_o_EXC_); // = "Internal Error: Iterator out of sync with zip entries"
 		return new WrapperInputStream(zipInputStream);
 	}
 
@@ -68,7 +68,7 @@
 				currentEntry = zipInputStream.getNextEntry();
 			} while (currentEntry.isDirectory());
 		} catch (java.io.IOException ex) {
-			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString("Error_iterating_the_archiv_EXC_"), ex); //$NON-NLS-1$ = "Error iterating the archive"
+			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.Error_iterating_the_archiv_EXC_, ex); // = "Error iterating the archive"
 		}
 		return next;
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/SaveFilter.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/SaveFilter.java
index 0adb97c..8ee9450 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/SaveFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/helpers/SaveFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/AltResourceRegister.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/AltResourceRegister.java
index 3eef77b..253d7a1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/AltResourceRegister.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/AltResourceRegister.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ApplicationClientFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ApplicationClientFileImpl.java
index 0e7e25c..d5d4d9c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ApplicationClientFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ApplicationClientFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopySessionUtility.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopySessionUtility.java
index cf4868e..c515a38 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopySessionUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopySessionUtility.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopyUtility.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopyUtility.java
index a51cc15..ab9bc60 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopyUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveCopyUtility.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -76,7 +76,7 @@
 			return new ArchiveManifestImpl(in);
 		} catch (IOException iox) {
 			//This should almost never happen, unless there is an issure with memory allocation
-			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString("IOException_occurred_while_EXC_"), iox); //$NON-NLS-1$ = "IOException occurred while copying manifest"
+			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.IOException_occurred_while_EXC_, iox); // = "IOException occurred while copying manifest"
 		}
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveImpl.java
index df5fd60..72f8ed0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ArchiveImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -415,7 +415,7 @@
 		try {
 			File f = getFile(aUri);
 			if (f != null)
-				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString("duplicate_file_EXC_", (new Object[]{getURI(), aUri})), f); //$NON-NLS-1$ = "The archive named {0} already contains a file named {1}"
+				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.duplicate_file_EXC_, (new Object[]{getURI(), aUri})), f); // = "The archive named {0} already contains a file named {1}"
 		} catch (FileNotFoundException ok) {
 			//Ignore
 		}
@@ -426,7 +426,7 @@
 		checkWriteable(original);
 		boolean deleteWorked = false;
 		if (original.isDirectory() && !isRenameable(original)) {
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("unable_replace_EXC_", (new Object[]{original.getAbsolutePath()}))); //$NON-NLS-1$ = "Unable to replace original archive "
+			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.unable_replace_EXC_, (new Object[]{original.getAbsolutePath()}))); // = "Unable to replace original archive "
 		}
 
 		for (int i = 0; i < 10; i++) {
@@ -457,7 +457,7 @@
 				}
 			}
 		}
-		throw new SaveFailureException(CommonArchiveResourceHandler.getString("unable_replace_EXC_", (new Object[]{original.getAbsolutePath()}))); //$NON-NLS-1$ = "Unable to replace original archive "
+		throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.unable_replace_EXC_, (new Object[]{original.getAbsolutePath()}))); // = "Unable to replace original archive "
 	}
 
 	/**
@@ -560,7 +560,7 @@
 
 	protected SaveStrategy createSaveStrategyForJar(java.io.File aFile) throws java.io.IOException {
 		if (aFile.exists() && aFile.isDirectory())
-			throw new IOException(CommonArchiveResourceHandler.getString("file_exist_as_dir_EXC_", (new Object[]{aFile.getAbsolutePath()})));//$NON-NLS-1$ = "A file named {0} exists and is a directory"
+			throw new IOException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_exist_as_dir_EXC_, (new Object[]{aFile.getAbsolutePath()})));// = "A file named {0} exists and is a directory"
 		java.io.File parent = aFile.getParentFile();
 		if (parent != null)
 			parent.mkdirs();
@@ -594,7 +594,7 @@
 				cleanupAfterTempSave(aUri, aDir, destinationDir);
 			}
 		} catch (java.io.IOException ex) {
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("error_saving_EXC_", (new Object[]{uri})), ex); //$NON-NLS-1$ = "Error saving "
+			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{uri})), ex); // = "Error saving "
 		}
 	}
 
@@ -604,14 +604,14 @@
 	public void extractTo(java.lang.String aUri, int expansionFlags) throws SaveFailureException {
 		java.io.File aDir = new java.io.File(aUri);
 		if (getLoadStrategy().isUsing(aDir))
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("Extract_destination_is_the_EXC_")); //$NON-NLS-1$ = "Extract destination is the same path as source file"
+			throw new SaveFailureException(CommonArchiveResourceHandler.Extract_destination_is_the_EXC_); // = "Extract destination is the same path as source file"
 
 		try {
 			SaveStrategy aSaveStrategy = createSaveStrategyForDirectory(aDir, expansionFlags);
 			save(aSaveStrategy);
 			aSaveStrategy.close();
 		} catch (java.io.IOException ex) {
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("error_saving_EXC_", (new Object[]{aUri})), ex); //$NON-NLS-1$ = "Error saving "
+			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{aUri})), ex); // = "Error saving "
 		}
 
 	}
@@ -841,9 +841,9 @@
 				if (ExtendedEcoreUtil.getFileNotFoundDetector().isFileNotFound(wrapEx))
 					makeManifest();
 				else
-					throw new ManifestException(CommonArchiveResourceHandler.getString("io_ex_manifest_EXC_", (new Object[]{getURI()})), ex); //$NON-NLS-1$ = "An IOException occurred reading the manifest: "
+					throw new ManifestException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_manifest_EXC_, (new Object[]{getURI()})), ex); // = "An IOException occurred reading the manifest: "
 			} catch (IOException ex) {
-				throw new ManifestException(CommonArchiveResourceHandler.getString("io_ex_manifest_EXC_", (new Object[]{getURI()})), ex); //$NON-NLS-1$ = "An IOException occurred reading the manifest: "
+				throw new ManifestException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_manifest_EXC_, (new Object[]{getURI()})), ex); // = "An IOException occurred reading the manifest: "
 			} finally {
 				if (in != null)
 					try {
@@ -1078,7 +1078,7 @@
 	 */
 	public Resource makeMofResource(String aUri, EList extent) throws DuplicateObjectException {
 		if (isDuplicate(aUri))
-			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString("duplicate_entry_EXC_", (new Object[]{aUri, getURI()}))); //$NON-NLS-1$ = "A file or resource with uri {0} already exists in the archive named {1}"
+			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.duplicate_entry_EXC_, (new Object[]{aUri, getURI()}))); // = "A file or resource with uri {0} already exists in the archive named {1}"
 		return getLoadStrategy().makeMofResource(aUri, extent);
 	}
 
@@ -1136,7 +1136,7 @@
 		try {
 			aLoadStrategy = createLoadStrategyForReopen(parent);
 		} catch (IOException ex) {
-			throw new ReopenException(CommonArchiveResourceHandler.getString("io_ex_reopen_EXC_", (new Object[]{getURI()})), ex); //$NON-NLS-1$ = "IOException occurred while reopening "
+			throw new ReopenException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_reopen_EXC_, (new Object[]{getURI()})), ex); // = "IOException occurred while reopening "
 		}
 		//PQ54572
 		LoadStrategy current = getLoadStrategy();
@@ -1320,7 +1320,7 @@
 					cleanupAfterTempSave(aUri, aFile, destinationFile);
 				}
 			} catch (java.io.IOException ex) {
-				throw new SaveFailureException(CommonArchiveResourceHandler.getString("error_saving_EXC_", (new Object[]{aUri})), ex); //$NON-NLS-1$ = "Error saving "
+				throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{aUri})), ex); // = "Error saving "
 			}
 		} catch (SaveFailureException failure) {
 			try {
@@ -1441,7 +1441,7 @@
 	}
 
 	protected void throwResourceLoadException(String resourceUri, Exception ex) throws ResourceLoadException {
-		throw new ResourceLoadException(CommonArchiveResourceHandler.getString("load_resource_EXC_", (new Object[]{resourceUri, getURI()})), ex); //$NON-NLS-1$ = "Could not load resource "{0}" in archive "{1}""
+		throw new ResourceLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.load_resource_EXC_, (new Object[]{resourceUri, getURI()})), ex); // = "Could not load resource "{0}" in archive "{1}""
 	}
 
 	public String getResourcesPath() throws FileNotFoundException {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ClientModuleRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ClientModuleRefImpl.java
index 946cec9..a239051 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ClientModuleRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ClientModuleRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchiveFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchiveFactoryImpl.java
index 50351c5..c197a11 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchiveFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchiveFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -305,7 +305,7 @@
 		String filename = uri.replace('/', java.io.File.separatorChar);
 		java.io.File file = new java.io.File(filename);
 		if (!file.exists()) {
-			throw new FileNotFoundException(CommonArchiveResourceHandler.getString("file_not_found_EXC_", (new Object[]{uri, file.getAbsolutePath()}))); //$NON-NLS-1$ = "URI Name: {0}; File name: {1}"
+			throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
 		}
 		if (file.isDirectory()) {
 			return new DirectoryArchiveLoadStrategyImpl(uri);
@@ -355,7 +355,7 @@
 			ArchiveUtil.copy(in, out);
 			return new TempZipFileLoadStrategyImpl(tempFile);
 		} catch (IOException ex) {
-			ArchiveUtil.inform(CommonArchiveResourceHandler.getString("make_temp_file_WARN_", (new Object[]{uri})) + ex.getLocalizedMessage()); //$NON-NLS-1$ = "Warning: Unable to create temp file for {0}.  This will impact performance."
+			ArchiveUtil.inform(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.make_temp_file_WARN_, (new Object[]{uri})) + ex.getLocalizedMessage()); // = "Warning: Unable to create temp file for {0}.  This will impact performance."
 		}
 		return null;
 	}
@@ -701,14 +701,14 @@
 		String uri = loose.getUri();
 		try {
 			if(loose.getBinariesPath() == null){
-				throw new OpenFailureException(CommonArchiveResourceHandler.getString("open_nested_EXC_", (new Object[] {uri,parent.getURI()})), null); //$NON-NLS-1$ = "Could not open the nested archive "{0}" in "{1}""
+				throw new OpenFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.open_nested_EXC_, (new Object[] {uri,parent.getURI()})), null); // = "Could not open the nested archive "{0}" in "{1}""
 			}
 			LoadStrategy childStrategy = createLoadStrategy(loose.getBinariesPath());
 			childStrategy.setLooseArchive(loose);
 			ArchiveOptions options = parent.getOptions().cloneWith(childStrategy, loose.getUri());
 			return primOpenArchive(options, uri);
 		} catch (IOException ex) {
-			throw new OpenFailureException(CommonArchiveResourceHandler.getString("open_nested_EXC_", (new Object[]{uri, parent.getURI()})), ex); //$NON-NLS-1$ = "Could not open the nested archive "{0}" in "{1}""
+			throw new OpenFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.open_nested_EXC_, (new Object[]{uri, parent.getURI()})), ex); // = "Could not open the nested archive "{0}" in "{1}""
 		}
 	}
 
@@ -723,7 +723,7 @@
 				return openArchive(options, uri);
 			return primOpenArchive(options, uri);
 		} catch (IOException ex) {
-			throw new OpenFailureException(CommonArchiveResourceHandler.getString("open_nested_EXC_", (new Object[]{uri, parent.getURI()})), ex); //$NON-NLS-1$ = "Could not open the nested archive "{0}" in "{1}""
+			throw new OpenFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.open_nested_EXC_, (new Object[]{uri, parent.getURI()})), ex); // = "Could not open the nested archive "{0}" in "{1}""
 		}
 	}
 
@@ -761,9 +761,9 @@
 	public ReadOnlyDirectory openReadOnlyDirectory(java.lang.String uri) throws java.io.IOException {
 		java.io.File aFile = new java.io.File(uri);
 		if (!aFile.exists())
-			throw new FileNotFoundException(CommonArchiveResourceHandler.getString("could_not_find_dir_EXC_", (new Object[]{uri}))); //$NON-NLS-1$ = "Unable to open directory "
+			throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.could_not_find_dir_EXC_, (new Object[]{uri}))); // = "Unable to open directory "
 		if (!aFile.isDirectory())
-			throw new IOException(CommonArchiveResourceHandler.getString("not_a_dir_EXC_", (new Object[]{uri}))); //$NON-NLS-1$ = "Unable to open directory because file is not a directory :"
+			throw new IOException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.not_a_dir_EXC_, (new Object[]{uri}))); // = "Unable to open directory because file is not a directory :"
 		LoadStrategy strategy = new ReadOnlyDirectoryLoadStrategyImpl(uri);
 		ReadOnlyDirectory container = createReadOnlyDirectory();
 		container.setURI(uri);
@@ -837,7 +837,7 @@
 			try {
 				options.setLoadStrategy(createLoadStrategy(uri));
 			} catch (IOException ex) {
-				throw new OpenFailureException(CommonArchiveResourceHandler.getString("could_not_open_EXC_", (new Object[]{uri})), ex); //$NON-NLS-1$ = "Could not open "
+				throw new OpenFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.could_not_open_EXC_, (new Object[]{uri})), ex); // = "Could not open "
 			}
 		}
 		Archive anArchive = createArchive();
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchivePackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchivePackageImpl.java
index fd9310b..062e303 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchivePackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/CommonarchivePackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ConnectorModuleRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ConnectorModuleRefImpl.java
index 9653d6e..2fc9e79 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ConnectorModuleRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ConnectorModuleRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ContainerImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ContainerImpl.java
index 5aca84c..ad2ab4a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ContainerImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ContainerImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EARFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EARFileImpl.java
index f6b6e5c..95e7b1f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EARFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EARFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -46,7 +46,6 @@
 import org.eclipse.jst.j2ee.client.internal.impl.ApplicationClientResourceFactory;
 import org.eclipse.jst.j2ee.common.EjbRef;
 import org.eclipse.jst.j2ee.common.SecurityRole;
-import org.eclipse.jst.j2ee.common.internal.impl.J2EEResourceFactoryRegistry;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonArchiveResourceHandler;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonarchivePackage;
@@ -79,6 +78,7 @@
 import org.eclipse.jst.j2ee.jca.internal.impl.ConnectorResourceFactory;
 import org.eclipse.jst.j2ee.webapplication.WebApp;
 import org.eclipse.jst.j2ee.webapplication.internal.impl.WebAppResourceFactory;
+import org.eclipse.wst.common.internal.emf.resource.FileNameResourceFactoryRegistry;
 import org.eclipse.wst.common.internal.emf.utilities.EtoolsCopyUtility;
 
 
@@ -180,19 +180,19 @@
 		try {
 			dd = getDeploymentDescriptor(aModule);
 		} catch (Exception e) {
-			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString("dd_in_ear_load_EXC_", (new Object[]{aModule.getUri(), getURI()})), e); //$NON-NLS-1$ = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
+			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dd_in_ear_load_EXC_, (new Object[]{aModule.getUri(), getURI()})), e); // = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
 		}
 		String roleName = aRole.getRoleName();
 		SecurityRole copy = (SecurityRole) EtoolsCopyUtility.createCopy(aRole);
 		if (aModule.isEjbModule()) {
 			EJBJar ejbJar = (EJBJar) dd;
 			if (ejbJar.containsSecurityRole(roleName))
-				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString("dup_sec_role_module_EXC_", (new Object[]{aModule.getUri(), roleName})), ejbJar.getAssemblyDescriptor().getSecurityRoleNamed(roleName)); //$NON-NLS-1$ = "Deployment descriptor for {0} already contains a security role named {1}"
+				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dup_sec_role_module_EXC_, (new Object[]{aModule.getUri(), roleName})), ejbJar.getAssemblyDescriptor().getSecurityRoleNamed(roleName)); // = "Deployment descriptor for {0} already contains a security role named {1}"
 			getAssemblyDescriptorAddIfNecessary(ejbJar).getSecurityRoles().add(copy);
 		} else if (aModule.isWebModule()) {
 			WebApp webApp = (WebApp) dd;
 			if (webApp.containsSecurityRole(roleName))
-				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString("dup_sec_role_module_EXC_", (new Object[]{aModule.getUri(), roleName})), webApp.getSecurityRoleNamed(roleName));//$NON-NLS-1$ = "Deployment descriptor for {0} already contains a security role named {1}"
+				throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dup_sec_role_module_EXC_, (new Object[]{aModule.getUri(), roleName})), webApp.getSecurityRoleNamed(roleName));// = "Deployment descriptor for {0} already contains a security role named {1}"
 			webApp.getSecurityRoles().add(copy);
 		}
 		addCopyIfNotExists(aRole);
@@ -214,7 +214,7 @@
 
 	protected void checkDuplicate(String aUri) throws DuplicateObjectException {
 		if (isDuplicate(aUri))
-			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString("dup_resource_EXC_", (new Object[]{aUri, getURI()}))); //$NON-NLS-1$ = "Resource named "{0}" already exists in archive "{1}""
+			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dup_resource_EXC_, (new Object[]{aUri, getURI()}))); // = "Resource named "{0}" already exists in archive "{1}""
 	}
 
 
@@ -514,7 +514,7 @@
 
 	protected ArchiveOptions getOptionsForOpening(LooseArchive loose) throws IOException, OpenFailureException{
 		if(loose.getBinariesPath() == null){
-			throw new OpenFailureException(CommonArchiveResourceHandler.getString("open_nested_EXC_", (new Object[] {loose.getUri(), getURI()})), null); //$NON-NLS-1$ = "Could not open the nested archive "{0}" in "{1}""
+			throw new OpenFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.open_nested_EXC_, (new Object[] {loose.getUri(), getURI()})), null); // = "Could not open the nested archive "{0}" in "{1}""
 		}
 		LoadStrategy strategy = getCommonArchiveFactory().createLoadStrategy(loose.getBinariesPath());
 		strategy.setLooseArchive(loose);
@@ -563,7 +563,7 @@
 			else if (aModule.isEjbModule())
 				roleList = getAssemblyDescriptorAddIfNecessary(getDeploymentDescriptor((EjbModule) aModule)).getSecurityRoles();
 		} catch (Exception e) {
-			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString("dd_in_ear_load_EXC_", (new Object[]{aModule.getUri(), getURI()})), e); //$NON-NLS-1$ = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
+			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dd_in_ear_load_EXC_, (new Object[]{aModule.getUri(), getURI()})), e); // = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
 		}
 		return roleList;
 	}
@@ -686,7 +686,7 @@
 				return getCommonArchiveFactory().openRARFile(archiveOptions, aUri);
 
 		} catch (OpenFailureException ex) {
-			throw new OpenFailureException(CommonArchiveResourceHandler.getString("nested_open_fail_EXC_", (new Object[]{aUri, getURI()})), ex); //$NON-NLS-1$ = "Unable to open module file "{0}" in EAR file "{1}""
+			throw new OpenFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.nested_open_fail_EXC_, (new Object[]{aUri, getURI()})), ex); // = "Unable to open module file "{0}" in EAR file "{1}""
 		}
 		//Should never reach the code below
 		return null;
@@ -697,7 +697,7 @@
 	 */
 	public void pushDownRole(SecurityRole role) {
 		if (role == null)
-			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString("Parameter_should_not_be_nu_EXC_")); //$NON-NLS-1$ = "Parameter should not be null"
+			throw new IllegalArgumentException(CommonArchiveResourceHandler.Parameter_should_not_be_nu_EXC_); // = "Parameter should not be null"
 
 		List modules = getDeploymentDescriptor().getModules();
 		for (int i = 0; i < modules.size(); i++) {
@@ -721,7 +721,7 @@
 					assembly.getSecurityRoles().add(EtoolsCopyUtility.createCopy(role));
 			}
 		} catch (Exception e) {
-			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString("dd_in_ear_load_EXC_", (new Object[]{aModule.getUri(), getURI()})), e); //$NON-NLS-1$ = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
+			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dd_in_ear_load_EXC_, (new Object[]{aModule.getUri(), getURI()})), e); // = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
 		}
 	}
 
@@ -742,7 +742,7 @@
 
 		if (factory != null) {
 			ResourceSet set = getResourceSet();
-			((J2EEResourceFactoryRegistry) set.getResourceFactoryRegistry()).registerLastFileSegment(aUri, factory);
+			((FileNameResourceFactoryRegistry) set.getResourceFactoryRegistry()).registerLastFileSegment(aUri, factory);
 		}
 	}
 
@@ -786,7 +786,7 @@
 				else if (m.isWebModule())
 					getDeploymentDescriptor((WebModule) m).renameSecurityRole(existingRoleName, newRoleName);
 			} catch (Exception e) {
-				throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString("dd_in_ear_load_EXC_", (new Object[]{m.getUri(), getURI()})), e); //$NON-NLS-1$ = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
+				throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dd_in_ear_load_EXC_, (new Object[]{m.getUri(), getURI()})), e); // = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
 			}
 		}
 	}
@@ -798,9 +798,9 @@
 		Application app = getDeploymentDescriptor();
 		SecurityRole aRole = app.getSecurityRoleNamed(existingRoleName);
 		if (aRole == null)
-			throw new ObjectNotFoundException(CommonArchiveResourceHandler.getString("no_sec_role_EXC_", (new Object[]{getURI(), existingRoleName}))); //$NON-NLS-1$ = ": EAR File deployment descriptor does not contain a security role named "
+			throw new ObjectNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.no_sec_role_EXC_, (new Object[]{getURI(), existingRoleName}))); // = ": EAR File deployment descriptor does not contain a security role named "
 		if (app.getSecurityRoleNamed(newRoleName) != null)
-			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString("dup_sec_role_EXC_", (new Object[]{getURI(), newRoleName})), app.getSecurityRoleNamed(newRoleName)); //$NON-NLS-1$ = ": EAR File deployment descriptor already contains a security role named "
+			throw new DuplicateObjectException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dup_sec_role_EXC_, (new Object[]{getURI(), newRoleName})), app.getSecurityRoleNamed(newRoleName)); // = ": EAR File deployment descriptor already contains a security role named "
 
 		aRole.setRoleName(newRoleName);
 
@@ -829,7 +829,7 @@
 			else if (aModule.isEjbModule())
 				securityRoles = getAssemblyDescriptorAddIfNecessary(getDeploymentDescriptor((EjbModule) aModule)).getSecurityRoles();
 		} catch (Exception e) {
-			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString("dd_in_ear_load_EXC_", (new Object[]{aModule.getUri(), getURI()})), e); //$NON-NLS-1$ = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
+			throw new DeploymentDescriptorLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.dd_in_ear_load_EXC_, (new Object[]{aModule.getUri(), getURI()})), e); // = "Exception occurred loading deployment descriptor for module "{0}" in ear file "{1}""
 		}
 
 		if (securityRoles == null)
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBJarFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBJarFileImpl.java
index c39c87d..623bf19 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBJarFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBJarFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBModuleRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBModuleRefImpl.java
index 5ca9ab2..0b57346 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBModuleRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/EJBModuleRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/FileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/FileImpl.java
index 1f761ee..c4d6b1e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/FileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/FileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleFileImpl.java
index 75ec846..7c43d61 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleRefImpl.java
index 934e2bc..c42147f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ModuleRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -466,7 +466,7 @@
 
 	protected void checkEARFile() {
 		if (getEarFile() == null)
-			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString("Module_not_in_EAR", new Object[]{getUri()})); //$NON-NLS-1$
+			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.Module_not_in_EAR, new Object[]{getUri()})); 
 	}
 
 	/**
@@ -481,29 +481,29 @@
 	protected void checkModuleFile() {
 		getModuleFile();
 		if (moduleFile == null)
-			throw new NoModuleFileException(CommonArchiveResourceHandler.getString("Module_file_does_not_exist_2", new Object[]{getUri()})); //$NON-NLS-1$
+			throw new NoModuleFileException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.Module_file_does_not_exist_2, new Object[]{getUri()})); 
 	}
 
 	protected void checkType(Module moduleDescriptor, File aFile) {
 		if (aFile == null) {
-			String message = CommonArchiveResourceHandler.getString("A_file_does_not_exist_for_module", new Object[]{moduleDescriptor.getUri()}); //$NON-NLS-1$
+			String message = CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.A_file_does_not_exist_for_module, new Object[]{moduleDescriptor.getUri()}); 
 			throw new NoModuleFileException(message);
 		}
 		//Added for defect 113929
 		boolean isValid = true;
-		String type = CommonArchiveResourceHandler.getString("Module_file"); //$NON-NLS-1$
+		String type = CommonArchiveResourceHandler.Module_file; 
 		if (moduleDescriptor.isWebModule() && !aFile.isWARFile()) {
 			isValid = false;
-			type = CommonArchiveResourceHandler.getString("A_WAR_file"); //$NON-NLS-1$
+			type = CommonArchiveResourceHandler.A_WAR_file; 
 		} else if (moduleDescriptor.isEjbModule() && !aFile.isEJBJarFile()) {
 			isValid = false;
-			type = CommonArchiveResourceHandler.getString("An_EJB_JAR_file"); //$NON-NLS-1$
+			type = CommonArchiveResourceHandler.An_EJB_JAR_file; 
 		} else if (moduleDescriptor.isJavaModule() && !aFile.isApplicationClientFile()) {
 			isValid = false;
-			type = CommonArchiveResourceHandler.getString("An_Application_Client_JAR_file"); //$NON-NLS-1$
+			type = CommonArchiveResourceHandler.An_Application_Client_JAR_file; 
 		} else if (moduleDescriptor.isConnectorModule() && !aFile.isRARFile()) {
 			isValid = false;
-			type = CommonArchiveResourceHandler.getString("A_RAR_file"); //$NON-NLS-1$
+			type = CommonArchiveResourceHandler.A_RAR_file; 
 		} else if (!aFile.isModuleFile())
 			isValid = false;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/RARFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/RARFileImpl.java
index 5dd23e1..310bbced 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/RARFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/RARFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -72,7 +72,7 @@
 	 */
 	public File addCopyClass(File aFile) throws org.eclipse.jst.j2ee.commonarchivecore.internal.exception.DuplicateObjectException {
 		if (aFile.isReadOnlyDirectory())
-			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString("add_copy_class_dir_EXC_", (new Object[]{aFile.getURI()}))); //$NON-NLS-1$ = "Method addCopyClass not supported for directories :"
+			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.add_copy_class_dir_EXC_, (new Object[]{aFile.getURI()}))); // = "Method addCopyClass not supported for directories :"
 		return addCopyFileAddingPrefix(aFile, ArchiveConstants.WEBAPP_CLASSES_URI);
 	}
 
@@ -98,14 +98,14 @@
 	public void extractToConnectorDirectory(java.lang.String aUri, int expansionFlags) throws SaveFailureException {
 		java.io.File aDir = new java.io.File(aUri);
 		if (getLoadStrategy().isUsing(aDir))
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("Extract_destination_is_the_EXC_")); //$NON-NLS-1$ = "Extract destination is the same path as source file"
+			throw new SaveFailureException(CommonArchiveResourceHandler.Extract_destination_is_the_EXC_); // = "Extract destination is the same path as source file"
 
 		try {
 			SaveStrategy aSaveStrategy = createSaveStrategyForConnectorDirectory(aDir, expansionFlags);
 			save(aSaveStrategy);
 			aSaveStrategy.close();
 		} catch (java.io.IOException ex) {
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("error_saving_EXC_", (new Object[]{uri})), ex); //$NON-NLS-1$ = "Error saving "
+			throw new SaveFailureException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.error_saving_EXC_, (new Object[]{uri})), ex); // = "Error saving "
 		}
 
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ReadOnlyDirectoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ReadOnlyDirectoryImpl.java
index 86e3623..8a2f502 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ReadOnlyDirectoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/ReadOnlyDirectoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WARFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WARFileImpl.java
index 60dab02..2bf1548 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WARFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WARFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -79,7 +79,7 @@
 	 */
 	public File addCopyClass(File aFile) throws DuplicateObjectException {
 		if (aFile.isReadOnlyDirectory())
-			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString("add_copy_class_dir_EXC_", (new Object[]{aFile.getURI()}))); //$NON-NLS-1$ = "Method addCopyClass not supported for directories :"
+			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.add_copy_class_dir_EXC_, (new Object[]{aFile.getURI()}))); // = "Method addCopyClass not supported for directories :"
 		return addCopyFileAddingPrefix(aFile, ArchiveConstants.WEBAPP_CLASSES_URI);
 	}
 
@@ -100,7 +100,7 @@
 	 */
 	public File addCopyLib(File aFile) throws DuplicateObjectException {
 		if (aFile.isReadOnlyDirectory())
-			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString("add_copy_lib_dir_EXC_", (new Object[]{aFile.getURI()}))); //$NON-NLS-1$ = "Method addCopyLib not supported for directories :"
+			throw new IllegalArgumentException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.add_copy_lib_dir_EXC_, (new Object[]{aFile.getURI()}))); // = "Method addCopyLib not supported for directories :"
 		return addCopyFileAddingPrefix(aFile, ArchiveConstants.WEBAPP_LIB_URI);
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WebModuleRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WebModuleRefImpl.java
index 649246c..4df5776 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WebModuleRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/impl/WebModuleRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/AppClient12ImportStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/AppClient12ImportStrategyImpl.java
index aa51be7..c5236f2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/AppClient12ImportStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/AppClient12ImportStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -39,7 +39,7 @@
 		}
 
 		public String getUnableToOpenMessage() {
-			return getXmlDDMessage(CommonArchiveResourceHandler.getString("Application_Client_Jar_Fil"), J2EEConstants.APP_CLIENT_DD_URI); //$NON-NLS-1$ = "Application Client Jar File"
+			return getXmlDDMessage(CommonArchiveResourceHandler.Application_Client_Jar_Fil, J2EEConstants.APP_CLIENT_DD_URI); // = "Application Client Jar File"
 		}
 
 		public Archive createConvertedArchive() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ConnectorDirectorySaveStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ConnectorDirectorySaveStrategyImpl.java
index b7587d0..2eb2eb6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ConnectorDirectorySaveStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ConnectorDirectorySaveStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryArchiveLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryArchiveLoadStrategyImpl.java
index e50602d..6e86686 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryArchiveLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryArchiveLoadStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryLoadStrategyImpl.java
index 31b9075..e9c4755 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectoryLoadStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectorySaveStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectorySaveStrategyImpl.java
index dce6e70..b404f5d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectorySaveStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/DirectorySaveStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/Ear12ImportStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/Ear12ImportStrategyImpl.java
index 02913c9..441d56c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/Ear12ImportStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/Ear12ImportStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -43,7 +43,7 @@
 		}
 
 		public String getUnableToOpenMessage() {
-			return getXmlDDMessage(CommonArchiveResourceHandler.getString("EAR_File"), J2EEConstants.APPLICATION_DD_URI); //$NON-NLS-1$ = "EAR File"
+			return getXmlDDMessage(CommonArchiveResourceHandler.EAR_File, J2EEConstants.APPLICATION_DD_URI); // = "EAR File"
 		}
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/EjbJar11ImportStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/EjbJar11ImportStrategyImpl.java
index ae03129..5da26c1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/EjbJar11ImportStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/EjbJar11ImportStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -39,7 +39,7 @@
 		}
 
 		public String getUnableToOpenMessage() {
-			return getXmlDDMessage(CommonArchiveResourceHandler.getString("EJB_Jar_File"), J2EEConstants.EJBJAR_DD_URI); //$NON-NLS-1$ = "EJB Jar File"
+			return getXmlDDMessage(CommonArchiveResourceHandler.EJB_Jar_File, J2EEConstants.EJBJAR_DD_URI); // = "EJB Jar File"
 		}
 
 		public Archive createConvertedArchive() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ExportStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ExportStrategyImpl.java
index 46bdf49..fd875ea 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ExportStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ExportStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategy.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategy.java
index c45cf1a..09eab45 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategy.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategy.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategyImpl.java
index 93a7073..39058f4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/LoadStrategyImpl.java
@@ -1,18 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.commonarchivecore.internal.strategy;
 
-/*
- * Licensed Material - Property of IBM 
- * (C) Copyright IBM Corp. 2002 - All Rights Reserved. 
- * US Government Users Restricted Rights - Use, duplication or disclosure 
- * restricted by GSA ADP Schedule Contract with IBM Corp. 
- */
-
-/*
- * Licensed Material - Property of IBM
- * (C) Copyright IBM Corp. 2001 - All Rights Reserved.
- * US Government Users Restricted Rights - Use, duplication or disclosure
- * restricted by GSA ADP Schedule Contract with IBM Corp.
- */
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
@@ -161,7 +158,7 @@
 	 * @see LoadStrategy
 	 */
 	public java.lang.String getAbsolutePath() throws FileNotFoundException {
-		throw new FileNotFoundException(CommonArchiveResourceHandler.getString("Absolute_path_unknown_EXC_")); //$NON-NLS-1$ = "Absolute path unknown"
+		throw new FileNotFoundException(CommonArchiveResourceHandler.Absolute_path_unknown_EXC_); // = "Absolute path unknown"
 	}
 
 	public String getResourcesPath() throws FileNotFoundException {
@@ -490,7 +487,7 @@
 	}
 
 	protected void throwResourceLoadException(String resourceUri, Exception ex) throws ResourceLoadException {
-		throw new ResourceLoadException(CommonArchiveResourceHandler.getString("load_resource_EXC_", (new Object[]{resourceUri, getContainer().getURI()})), ex); //$NON-NLS-1$ = "Could not load resource "{0}" in archive "{1}""
+		throw new ResourceLoadException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.load_resource_EXC_, (new Object[]{resourceUri, getContainer().getURI()})), ex); // = "Could not load resource "{0}" in archive "{1}""
 	}
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/NestedArchiveLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/NestedArchiveLoadStrategyImpl.java
index ec211da..def55bc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/NestedArchiveLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/NestedArchiveLoadStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -197,7 +197,7 @@
 
 	protected ZipInputStream getZipInputStreamSkippedTo(String uri) throws IOException, FileNotFoundException {
 		if (uri == null)
-			throw new NullPointerException(CommonArchiveResourceHandler.getString("Null_uri_EXC_")); //$NON-NLS-1$ = "Null uri"
+			throw new NullPointerException(CommonArchiveResourceHandler.Null_uri_EXC_); // = "Null uri"
 		ZipInputStream zis = null;
 		ZipEntry entry = null;
 		try {
@@ -245,7 +245,7 @@
 	 * An exception was caught reading the nested jar; throws a runtime exception
 	 */
 	protected void throwNestedJarException(Exception caughtException) {
-		throw new NestedJarException(CommonArchiveResourceHandler.getString("nested_jar_EXC_", (new Object[]{getContainer().getURI(), getParent().getContainer().getURI()})), caughtException);//$NON-NLS-1$ = "An error occurred reading {0} from {1}"
+		throw new NestedJarException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.nested_jar_EXC_, (new Object[]{getContainer().getURI(), getParent().getContainer().getURI()})), caughtException);// = "An error occurred reading {0} from {1}"
 	}
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/RarImportStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/RarImportStrategyImpl.java
index 10c35f8..5a8dc18 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/RarImportStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/RarImportStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
 		}
 
 		public String getUnableToOpenMessage() {
-			return getXmlDDMessage(CommonArchiveResourceHandler.getString("RAR_File"), J2EEConstants.RAR_DD_URI); //$NON-NLS-1$ = "RAR File"
+			return getXmlDDMessage(CommonArchiveResourceHandler.RAR_File, J2EEConstants.RAR_DD_URI); // = "RAR File"
 		}
 
 		public Archive createConvertedArchive() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/SaveStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/SaveStrategyImpl.java
index 19549c6..bd99805 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/SaveStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/SaveStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,7 +145,7 @@
 					save(aFile, iterator);
 			}
 		} catch (IOException iox) {
-			throw new SaveFailureException(CommonArchiveResourceHandler.getString("Error_occurred_iterating_f_EXC_"), iox); //$NON-NLS-1$ = "Error occurred iterating files"
+			throw new SaveFailureException(CommonArchiveResourceHandler.Error_occurred_iterating_f_EXC_, iox); // = "Error occurred iterating files"
 		}
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/TempZipFileLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/TempZipFileLoadStrategyImpl.java
index 54a85d2..2031fd8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/TempZipFileLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/TempZipFileLoadStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -53,6 +53,6 @@
 	 * @see com.ibm.etools.archive.LoadStrategy
 	 */
 	public java.lang.String getAbsolutePath() throws java.io.FileNotFoundException {
-		throw new FileNotFoundException(CommonArchiveResourceHandler.getString("Absolute_path_unknown_EXC_")); //$NON-NLS-1$ = "Absolute path unknown"
+		throw new FileNotFoundException(CommonArchiveResourceHandler.Absolute_path_unknown_EXC_); // = "Absolute path unknown"
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/War22ImportStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/War22ImportStrategyImpl.java
index 3d14872..f45d65d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/War22ImportStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/War22ImportStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -39,7 +39,7 @@
 		}
 
 		public String getUnableToOpenMessage() {
-			return getXmlDDMessage(CommonArchiveResourceHandler.getString("WAR_File"), J2EEConstants.WEBAPP_DD_URI); //$NON-NLS-1$ = "WAR File"
+			return getXmlDDMessage(CommonArchiveResourceHandler.WAR_File, J2EEConstants.WEBAPP_DD_URI); // = "WAR File"
 		}
 
 		public Archive createConvertedArchive() {
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipFileLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipFileLoadStrategyImpl.java
index 2c03dbf..747ee90 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipFileLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipFileLoadStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipStreamSaveStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipStreamSaveStrategyImpl.java
index 445c878..9fee0c8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipStreamSaveStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/strategy/ZipStreamSaveStrategyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveFileDynamicClassLoader.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveFileDynamicClassLoader.java
index 352a764..eb945c2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveFileDynamicClassLoader.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveFileDynamicClassLoader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -85,7 +85,7 @@
 			} catch (FileNotFoundException e) {
 				return null;
 			} catch (IOException e) {
-				throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString("io_ex_loading_EXC_", (new Object[]{file.getName()})), e); //$NON-NLS-1$ = "An IO exception occurred loading "			}
+				throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_loading_EXC_, (new Object[]{file.getName()})), e); // = "An IO exception occurred loading "			}
 			}
 		}
 		return null;
@@ -239,7 +239,7 @@
 				return file.getInputStream();
 			}
 		} catch (IOException e) {
-			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString("io_ex_loading_EXC_", (new Object[]{name})), e); //$NON-NLS-1$ = "An IO exception occurred loading "
+			throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_loading_EXC_, (new Object[]{name})), e); // = "An IO exception occurred loading "
 		}
 		return null;
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveUtil.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveUtil.java
index 7659e8d..4c43a31 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ArchiveUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -327,15 +327,15 @@
 	public static String getModuleFileTypeName(int moduleType) {
 		switch (moduleType) {
 			case XMLResource.APPLICATION_TYPE :
-				return CommonArchiveResourceHandler.getString("A_Application_file"); //$NON-NLS-1$
+				return CommonArchiveResourceHandler.A_Application_file; 
 			case XMLResource.APP_CLIENT_TYPE :
-				return CommonArchiveResourceHandler.getString("An_Application_Client_JAR_file"); //$NON-NLS-1$
+				return CommonArchiveResourceHandler.An_Application_Client_JAR_file; 
 			case XMLResource.EJB_TYPE :
-				return CommonArchiveResourceHandler.getString("An_EJB_JAR_file"); //$NON-NLS-1$
+				return CommonArchiveResourceHandler.An_EJB_JAR_file; 
 			case XMLResource.WEB_APP_TYPE :
-				return CommonArchiveResourceHandler.getString("A_WAR_file"); //$NON-NLS-1$
+				return CommonArchiveResourceHandler.A_WAR_file; 
 			case XMLResource.RAR_TYPE :
-				return CommonArchiveResourceHandler.getString("A_RAR_file"); //$NON-NLS-1$
+				return CommonArchiveResourceHandler.A_RAR_file; 
 		}
 		return null;
 	}
@@ -545,7 +545,7 @@
 		if (!dir.exists()) {
 			dir.mkdirs();
 			if (!dir.exists())
-				throw new ArchiveException(CommonArchiveResourceHandler.getString("make_temp_dir_EXC_", (new Object[]{newTempDirectoryName}))); //$NON-NLS-1$ = "Unable to make temp directory: "
+				throw new ArchiveException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.make_temp_dir_EXC_, (new Object[]{newTempDirectoryName}))); // = "Unable to make temp directory: "
 			dir.deleteOnExit();
 		}
 		setTempDirectory(dir);
@@ -587,7 +587,7 @@
 				try {
 					zip = new ZipFile(aFile);
 				} catch (Exception ex) {
-					inform(CommonArchiveResourceHandler.getString("invalid_classpath_WARN_", (new Object[]{pathEntry}))); //$NON-NLS-1$ = "Classpath element "{0}" is not a directory or a Zip file"
+					inform(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.invalid_classpath_WARN_, (new Object[]{pathEntry}))); // = "Classpath element "{0}" is not a directory or a Zip file"
 					continue;
 				} finally {
 					if (zip != null)
@@ -600,10 +600,10 @@
 			}
 			try {
 				aFile = new java.io.File(pathEntry);
-				java.net.URL aUrl = aFile.toURL(); //$NON-NLS-1$
+				java.net.URL aUrl = aFile.toURL(); 
 				urls.add(aUrl);
 			} catch (java.net.MalformedURLException ex) {
-				inform(CommonArchiveResourceHandler.getString("invalid_cp_file_WARN_", (new Object[]{pathEntry}))); //$NON-NLS-1$ = "Classpath element "{0}" does not point to a local file"
+				inform(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.invalid_cp_file_WARN_, (new Object[]{pathEntry}))); // = "Classpath element "{0}" does not point to a local file"
 			}
 		}
 		java.net.URL[] urlArray = new java.net.URL[urls.size()];
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ClasspathUtil.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ClasspathUtil.java
index 4962583..08bf76d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ClasspathUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ClasspathUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveAdapterFactory.java
index bdfba58..02bbad6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveSwitch.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveSwitch.java
index 31b66f2..f426e7d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/CommonarchiveSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/EARFileUtil.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/EARFileUtil.java
index ef6ea52..c22e959 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/EARFileUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/EARFileUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/FileDups.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/FileDups.java
index fbb2081..4584f23 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/FileDups.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/FileDups.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ObjectInputStreamCustomResolver.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ObjectInputStreamCustomResolver.java
index b7ac91a..76cef83 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ObjectInputStreamCustomResolver.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/ObjectInputStreamCustomResolver.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/RarFileDynamicClassLoader.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/RarFileDynamicClassLoader.java
index c38a6f7..c7a26ab 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/RarFileDynamicClassLoader.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/RarFileDynamicClassLoader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/WarFileDynamicClassLoader.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/WarFileDynamicClassLoader.java
index fd89158..e59c6a2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/WarFileDynamicClassLoader.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/internal/util/WarFileDynamicClassLoader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -71,4 +71,4 @@
 	private WARFile getWarFile() {
 		return (WARFile) getArchive();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseApplication.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseApplication.java
index 76e143c..4f8a485 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseApplication.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseApplication.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseArchive.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseArchive.java
index a2d30e2..c7cf186 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseArchive.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseArchive.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfigRegister.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfigRegister.java
index e0bdcbc..17c6707 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfigRegister.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfigRegister.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfiguration.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfiguration.java
index 8243cdb..7df3fce 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfiguration.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseConfiguration.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseLibrary.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseLibrary.java
index b73429b..4e4b31c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseLibrary.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseLibrary.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseModule.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseModule.java
index 61970f7..39888c8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseModule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseModule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseWARFile.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseWARFile.java
index 3b979cd..4bea047 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseWARFile.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseWARFile.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigFactory.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigFactory.java
index 1e77942..2a90076 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigPackage.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigPackage.java
index 09d8426..d17963a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/LooseconfigPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseApplicationImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseApplicationImpl.java
index ca05caa..ea23d13 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseApplicationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseApplicationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseArchiveImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseArchiveImpl.java
index de6ef9a..98dfd2b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseArchiveImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseArchiveImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseConfigurationImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseConfigurationImpl.java
index 17bde6c..a08767a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseConfigurationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseConfigurationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseLibraryImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseLibraryImpl.java
index c2e2d17..09705ba 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseLibraryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseLibraryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseModuleImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseModuleImpl.java
index f96b011..19e8587 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseModuleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseModuleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseWARFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseWARFileImpl.java
index 2830dc1..962f71f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseWARFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseWARFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigFactoryImpl.java
index fddd341..db00a6b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigPackageImpl.java
index 2d979ca..6c96b3c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/impl/LooseconfigPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigAdapterFactory.java
index 7adfa02..d326020 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigSwitch.java b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigSwitch.java
index 412257d..ce123d8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/commonArchive/org/eclipse/jst/j2ee/commonarchivecore/looseconfig/internal/util/LooseconfigSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/component.xml b/plugins/org.eclipse.jst.j2ee.core/component.xml
index 57662d5..3fa4481 100644
--- a/plugins/org.eclipse.jst.j2ee.core/component.xml
+++ b/plugins/org.eclipse.jst.j2ee.core/component.xml
@@ -1 +1,176 @@
-<?xml version="1.0" encoding="UTF-8"?><component  xmlns="http://eclipse.org/wtp/releng/tools/component-model" name="org.eclipse.jst.j2ee.core"><component-depends unrestricted="true"></component-depends><plugin id="org.eclipse.jst.j2ee.core" fragment="false"/><package name="org.eclipse.jst.j2ee.webservice.jaxrpcmap"></package><package name="org.eclipse.jst.j2ee.webapplication"></package><package name="org.eclipse.jst.j2ee.webservice.jaxrpcmap.impl"></package><package name="org.eclipse.jst.j2ee.webservice.wsdd"></package><package name="org.eclipse.jst.j2ee.application"></package><package name="org.eclipse.jst.j2ee.common"></package><package name="org.eclipse.jst.j2ee.jca"></package><package name="org.eclipse.jst.j2ee.ejb"></package><package name="org.eclipse.jst.j2ee.webservice.wscommon"></package><package name="org.eclipse.jst.j2ee.client"></package><package name="org.eclipse.jst.j2ee.webservice.wsclient"></package><package name="org.eclipse.jst.j2ee.webservice"></package><package name="org.eclipse.jst.j2ee.jsp"></package><package name="org.eclipse.jst.j2ee.webservice.jaxrpcmap.util"></package></component>
\ No newline at end of file
+<?xml version="1.0" encoding="UTF-8"?>
+<component xmlns="http://eclipse.org/wtp/releng/tools/component-model"
+	name="org.eclipse.jst.j2ee.core">
+	<description url=""></description>
+	<component-depends unrestricted="true"></component-depends>
+	<plugin id="org.eclipse.jst.j2ee.core" fragment="false" />
+	<package name="org.eclipse.jst.j2ee.webservice.wsclient" api="false">
+		<type name="ComponentScopedRefs"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="Handler"  implement="false" subclass="false" instantiate="false"/>
+		<type name="PortComponentRef"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ServiceRef"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="Webservice_clientFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="WebServicesClient"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="WebServicesResource"  implement="false" subclass="false" instantiate="false"/>
+	</package>
+	<package name="org.eclipse.jst.j2ee.application" api="false" >
+		<type name="Application"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="ApplicationFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ApplicationResource"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ConnectorModule"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="EjbModule"  implement="false" subclass="false" instantiate="false"/>
+		<type name="JavaClientModule"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Module"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="WebModule"  implement="false" subclass="false" instantiate="false"/>
+	</package>
+	<package name="org.eclipse.jst.j2ee.webservice.wsdd"></package>
+	<package name="org.eclipse.jst.j2ee.jsp" api="false" >
+		<type name="JSPConfig"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="JspFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="JSPPropertyGroup"  implement="false" subclass="false" instantiate="false"/>
+		<type name="TagLibRefType"  implement="false" subclass="false" instantiate="false"/>		
+	</package>
+	<package name="org.eclipse.jst.j2ee.client" api="false" >
+		<type name="ApplicationClient"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="ApplicationClientResource"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ClientFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ResAuthApplicationType"  implement="false" subclass="false" instantiate="false"/>		
+	</package>
+	<package name="org.eclipse.jst.j2ee.webapplication" api="false">
+		<type name="AuthConstraint"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="AuthMethodKind"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ContextParam"  implement="false" subclass="false" instantiate="false"/>
+		<type name="DispatcherType"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="ErrorCodeErrorPage"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ErrorPage"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ExceptionTypeErrorPage"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Filter"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="FilterMapping"  implement="false" subclass="false" instantiate="false"/>
+		<type name="FormLoginConfig"  implement="false" subclass="false" instantiate="false"/>
+		<type name="HTTPMethodType"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="HTTPMethodTypeEnum"  implement="false" subclass="false" instantiate="false"/>
+		<type name="InitParam"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="JSPType"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="LocalEncodingMapping"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="LocalEncodingMappingList"  implement="false" subclass="false" instantiate="false"/>
+		<type name="LoginConfig"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MimeMapping"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="ResAuthServletType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="RoleNameType"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="SecurityConstraint"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Servlet"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ServletMapping"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ServletType"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="SessionConfig"  implement="false" subclass="false" instantiate="false"/>
+		<type name="TagLibRef"  implement="false" subclass="false" instantiate="false"/>
+		<type name="TransportGuaranteeType"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="URLPatternType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="UserDataConstraint"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="WebApp"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="WebapplicationFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="WebAppResource"  implement="false" subclass="false" instantiate="false"/>
+		<type name="WebResourceCollection"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="WebType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="WelcomeFile"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="WelcomeFileList"  implement="false" subclass="false" instantiate="false"/>
+	</package>
+	<package name="org.eclipse.jst.j2ee.webservice"></package>
+	<package name="org.eclipse.jst.j2ee.common" api="false">
+		<type name="CommonFactory"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="CompatibilityDescriptionGroup"  implement="false" subclass="false" instantiate="false"/>
+		<type name="DeploymentExtension"  implement="false" subclass="false" instantiate="false"/>
+		<type name="Description"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="DescriptionGroup"  implement="false" subclass="false" instantiate="false"/>
+		<type name="DisplayName"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="EJBLocalRef"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="EjbRef"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="EjbRefType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EnvEntry"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EnvEntryType"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="ExtensibleType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="IconType"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Identity"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="JNDIEnvRefsGroup"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="Listener"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MessageDestination"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MessageDestinationRef"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="MessageDestinationUsageType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ParamValue"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="QName"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ResAuthTypeBase"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ResourceEnvRef"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ResourceRef"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="ResSharingScopeType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="RunAsSpecifiedIdentity"  implement="false" subclass="false" instantiate="false"/>
+		<type name="SecurityIdentity"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="SecurityRole"  implement="false" subclass="false" instantiate="false"/>
+		<type name="SecurityRoleRef"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="UseCallerIdentity"  implement="false" subclass="false" instantiate="false"/>
+	</package>
+	<package name="org.eclipse.jst.j2ee.webservice.jaxrpcmap">
+		<type name="JaxrpcmapResourceFactory" reference="false" implement="false" subclass="false" instantiate="false"/>
+	</package>
+	<package name="org.eclipse.jst.j2ee.webservice.wscommon"></package>
+	<package name="org.eclipse.jst.j2ee.jca" api="false" >
+		<type name="ActivationSpec"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="AdminObject"  implement="false" subclass="false" instantiate="false"/>
+		<type name="AuthenticationMechanism"  implement="false" subclass="false" instantiate="false"/>
+		<type name="AuthenticationMechanismType"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="ConfigProperty"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ConnectionDefinition"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Connector"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ConnectorResource"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="InboundResourceAdapter"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="JcaFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="License"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MessageAdapter"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="MessageListener"  implement="false" subclass="false" instantiate="false"/>
+		<type name="OutboundResourceAdapter"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="RequiredConfigPropertyType"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ResourceAdapter"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="SecurityPermission"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="TransactionSupportKind"  implement="false" subclass="false" instantiate="false"/>
+	</package>
+	<package name="org.eclipse.jst.j2ee.ejb" api="false">
+		<type name="AcknowledgeMode"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="ActivationConfig"  implement="false" subclass="false" instantiate="false"/>
+		<type name="ActivationConfigProperty"  implement="false" subclass="false" instantiate="false"/>
+		<type name="AssemblyDescriptor"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="CMPAttribute"  implement="false" subclass="false" instantiate="false"/>
+		<type name="CMRField"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="CommonRelationship"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="CommonRelationshipRole"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="ContainerManagedEntity"  implement="false" subclass="false" instantiate="false"/>
+		<type name="DestinationType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EJBExtensionFilter"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="EjbFactory"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EJBJar"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="EJBMethodCategory"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="EjbMethodElementComparator"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="EjbMethodElementHelper"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EJBRelation"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EJBRelationshipRole"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="EJBResource"  implement="false" subclass="false" instantiate="false"/>
+		<type name="EnterpriseBean"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Entity"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="ExcludeList"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="IRoleShapeStrategy"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="MessageDriven"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="MessageDrivenDestination"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MethodElement"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MethodElementKind"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="MethodPermission"  implement="false" subclass="false" instantiate="false"/>
+		<type name="MethodTransaction"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="MultiplicityKind"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Query"  implement="false" subclass="false" instantiate="false"/>
+		<type name="QueryMethod"  implement="false" subclass="false" instantiate="false"/>
+		<type name="Relationships"  implement="false" subclass="false" instantiate="false"/>		
+		<type name="ReturnTypeMapping"  implement="false" subclass="false" instantiate="false"/>
+		<type name="RoleSource"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="Session"  implement="false" subclass="false" instantiate="false"/>
+    	<type name="SessionType"  implement="false" subclass="false" instantiate="false"/>	
+		<type name="SubscriptionDurabilityKind"  implement="false" subclass="false" instantiate="false"/>
+		<type name="TransactionAttributeType"  implement="false" subclass="false" instantiate="false"/>
+		<type name="TransactionType"  implement="false" subclass="false" instantiate="false"/>		
+	</package>
+</component>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABMPHomeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABMPHomeVRule.java
index bbb2f65..3862baa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABMPHomeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABMPHomeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABeanClassVRule.java
index a86b79d..c09dbaa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ABeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ACMPHomeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ACMPHomeVRule.java
index 04053bd..573438d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ACMPHomeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ACMPHomeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AComponentVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AComponentVRule.java
index 870ed42..ba2aece 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AComponentVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AComponentVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityBeanClassVRule.java
index 4948507..1f12194 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityHomeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityHomeVRule.java
index b742fc3..254ca20 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityHomeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AEntityHomeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AHomeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AHomeVRule.java
index fdcab91..09dfc45 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AHomeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AHomeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AInterfaceTypeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AInterfaceTypeVRule.java
index 0fd0c14..8ff7d3e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AInterfaceTypeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AInterfaceTypeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AKeyClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AKeyClassVRule.java
index ec134bc..9584074 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AKeyClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AKeyClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ASessionBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ASessionBeanClassVRule.java
index 43e682b..e1b9475 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ASessionBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ASessionBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AStatelessHomeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AStatelessHomeVRule.java
index 0a7e3eb..3bf8b84 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AStatelessHomeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AStatelessHomeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ATypeVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ATypeVRule.java
index d3801b2..f28dfd0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ATypeVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ATypeVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateBean.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateBean.java
index 10991ba..7a3a3ad 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateBean.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEJB.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEJB.java
index e588662..dd99af8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEJB.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEJB.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityBean.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityBean.java
index e2d518a..c776265 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityBean.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.Iterator;
 import java.util.Set;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityHome.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityHome.java
index 12466b6..9955fcd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityHome.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateEntityHome.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.HashSet;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateHome.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateHome.java
index 4a59c11..c6f8c63 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateHome.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateHome.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.List;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateKeyClass.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateKeyClass.java
index ddb9750..ce52557 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateKeyClass.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateKeyClass.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.List;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateRemote.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateRemote.java
index de90c77..f4f996d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateRemote.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidateRemote.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.List;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidationRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidationRule.java
index d590586..08d5d7b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidationRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AValidationRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidationRuleFactory.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidationRuleFactory.java
index 3704d09..47f92a0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidationRuleFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidationRuleFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidator.java
index 429d70d..a866f95 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ApplicationClientValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ApplicationClientValidator.java
index fe1cf8d..96d5f86 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ApplicationClientValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ApplicationClientValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPBeanClassVRule.java
index 118eb9d..58607c9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPKeyClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPKeyClassVRule.java
index 3e75d0e..b091a8f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPKeyClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/BMPKeyClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPBeanClassVRule.java
index 2ed1498..0bc8c64 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPKeyClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPKeyClassVRule.java
index 1ee5bd7..dceab8b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPKeyClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPKeyClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPRemoteComponentVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPRemoteComponentVRule.java
index 2edf00a..87155b4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPRemoteComponentVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/CMPRemoteComponentVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ClassUtility.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ClassUtility.java
index a84223f..976d51c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ClassUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ClassUtility.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ConnectorValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ConnectorValidator.java
index da24595..0f1ece6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ConnectorValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ConnectorValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/DuplicatesTable.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/DuplicatesTable.java
index 3bd98fe..cb1c638 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/DuplicatesTable.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/DuplicatesTable.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -26,6 +26,10 @@
  * the duplicates easier.
  */
 public class DuplicatesTable extends java.util.HashMap {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -3189901849555229718L;
 	protected static final Boolean UNIQUE = Boolean.FALSE;
 	protected static final Boolean DUPLICATE = Boolean.TRUE;
 	protected Map _duplicates = null;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBExt20VRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBExt20VRule.java
index 153f5f7..0e10711 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBExt20VRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBExt20VRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar11VRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar11VRule.java
index bc3852f..cb0759d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar11VRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar11VRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar20VRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar20VRule.java
index 4de324a..5443319 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar20VRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBJar20VRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationContext.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationContext.java
index 7e496e1..5bb51ba 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationContext.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationContext.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -160,7 +160,13 @@
 	}
 	
 	public void addMessage(int severity, String messageId, Object target, String groupName) throws MessageLimitException {
-		IMessage message =  new Message(IEJBValidatorConstants.BUNDLE_NAME,severity,messageId,null,target,groupName);
+		/**
+		 * 11/28/05 Commenting the following line to get rid of Warning message
+		 * Quite possibly the getRoporter().addMessage needs to be used.
+		 * 
+		 */
+		
+		//IMessage message =  new Message(IEJBValidatorConstants.BUNDLE_NAME,severity,messageId,null,target,groupName);
 	}
 	
 	public void addMessage(int severity, String messageId, String[] parms, Object target, String groupName) throws MessageLimitException {
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationRuleFactory.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationRuleFactory.java
index 522bf68..610ab03 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationRuleFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidationRuleFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidator.java
index db98585..3b63991 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidatorModelEnum.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidatorModelEnum.java
index 5848240..6882460 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidatorModelEnum.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EJBValidatorModelEnum.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EarValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EarValidator.java
index e33b948..d3eb3f9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EarValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EarValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean11VRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean11VRule.java
index fde5fe2..576136e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean11VRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean11VRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean20VRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean20VRule.java
index d7276bd..ddba1fd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean20VRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/EnterpriseBean20VRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IClassVRule.java
index b7e13e5..c181423 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBInterfaceType.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBInterfaceType.java
index 043842b..05402eb 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBInterfaceType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBInterfaceType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBValidationContext.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBValidationContext.java
index 9c1fd5a..9b9a027 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBValidationContext.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IEJBValidationContext.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ILocalType.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ILocalType.java
index c6cdcfa..afa0a07 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ILocalType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ILocalType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IRemoteType.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IRemoteType.java
index 38511c4..5db5385 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IRemoteType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IRemoteType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IValidationRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IValidationRule.java
index 01a6509..e54a185 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IValidationRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/IValidationRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/InvalidInputException.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/InvalidInputException.java
index 0745d33..51c673a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/InvalidInputException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/InvalidInputException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,10 @@
  * or when expected input (e.g. the remote interface) is null.
  */
 public class InvalidInputException extends Exception {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 7811046448684869845L;
 	private JavaClass _class = null;
 	
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/J2EEValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/J2EEValidator.java
index bc3a617..4a2531d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/J2EEValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/J2EEValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageDrivenBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageDrivenBeanClassVRule.java
index 7c154c0..8a24f77 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageDrivenBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageDrivenBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageUtility.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageUtility.java
index 70cbf91..4ae32f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/MessageUtility.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatefulSessionBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatefulSessionBeanClassVRule.java
index ced1f65..128f00c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatefulSessionBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatefulSessionBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatelessSessionBeanClassVRule.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatelessSessionBeanClassVRule.java
index d8c6323..621a111 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatelessSessionBeanClassVRule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/StatelessSessionBeanClassVRule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPBean.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPBean.java
index 6dc852e..1183c0b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPBean.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPHome.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPHome.java
index 2576c40..4cfb628 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPHome.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPHome.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPKey.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPKey.java
index 7e795f0..10c4adf 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPKey.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateBMPKey.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPBean.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPBean.java
index bb8cbf2..8dbe2b0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPBean.java
@@ -1,11 +1,16 @@
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
 package org.eclipse.jst.j2ee.model.internal.validation;
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPKey.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPKey.java
index b08b6b0..74ee76e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPKey.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateCMPKey.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.HashMap;
 import java.util.HashSet;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionBean.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionBean.java
index a4c293d..5b79841 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionBean.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.HashMap;
 import java.util.HashSet;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionHome.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionHome.java
index 45b289f..0199c34 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionHome.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidateSessionHome.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.model.internal.validation;
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
-* Licensed Material - Property of IBM
-* (C) Copyright IBM Corp. 2001 - All Rights Reserved.
-* US Government Users Restricted Rights - Use, duplication or disclosure
-* restricted by GSA ADP Schedule Contract with IBM Corp.
-*/
+package org.eclipse.jst.j2ee.model.internal.validation;
 
 import java.util.HashMap;
 import java.util.HashSet;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationCancelledException.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationCancelledException.java
index 54b9214..1b9d614 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationCancelledException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationCancelledException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,6 +15,11 @@
  * This exception should be thrown if the user cancels validation.
  */
 public class ValidationCancelledException extends RuntimeException {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 7065655347030103289L;
+
 	public ValidationCancelledException() {
 		super();
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationRuleUtility.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationRuleUtility.java
index 8aa06aa..120d92f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationRuleUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/ValidationRuleUtility.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WARValidationResourceHandler.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WARValidationResourceHandler.java
index 567e1d7..a549380 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WARValidationResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WARValidationResourceHandler.java
@@ -1,64 +1,100 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
- * IBM Corporation - initial API and implementation
+ *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.model.internal.validation;
 
+import org.eclipse.osgi.util.NLS;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+public final class WARValidationResourceHandler extends NLS {
 
-public class WARValidationResourceHandler {
-	private static ResourceBundle fgResourceBundle;
+	private static final String BUNDLE_NAME = "warvalidation";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("warvalidation");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String) will return the key
-			// it was called with
-		}
-		return null;
+	private WARValidationResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String ERROR_WAR_VALIDATION_FAILED;
+	public static String ERROR_EAR_DUPLICATE_ROLES;
+	public static String MESSAGE_WAR_VALIDATION_MISSING_JSP;
+	public static String MESSAGE_WAR_VALIDATION_SMALL_ICON;
+	public static String MESSAGE_WAR_VALIDATION_LARGE_ICON;
+	public static String MESSAGE_WAR_VALIDATION_BROKEN_SERVLET_MAPPING;
+	public static String MESSAGE_WAR_VALIDATION_NO_WELCOME_FILE;
+	public static String MESSAGE_WAR_VALIDATION_MISSING_WELCOME_FILE;
+	public static String MESSAGE_WAR_VALIDATION_MISSING_TLD;
+	public static String ERROR_INVALID_WAR_FILE;
+	public static String MESSAGE_WAR_VALIDATION_BROKEN_FILTER_MAPPING;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_WELCOME_FILE;
+	public static String WAR_DD_PARSE_LINECOL;
+	public static String WAR_DD_PARSE_LINE;
+	public static String WAR_DD_PARSE_NOINFO;
+	public static String WAR_DD_CANNOT_OPEN_DD;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_URL;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_SEC_ROLE;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_HTTP_CMD;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_TRANSPORT;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_JSPFILE_REF;
+	public static String ERROR_EAR_INVALID_CONTEXT_ROOT;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_ERROR_PAGE;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_SEC_ROLE_NAME;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_AUTH_METHOD;
+	public static String MESSAGE_WAR_VALIDATION_IGNORE_FORM_LOGIN;
+	public static String MESSAGE_WAR_VALIDATION_RES_AUTH_REQUIRED_22;
+	public static String MESSAGE_WAR_VALIDATION_RES_AUTH_REQUIRED_23;
+	public static String MESSAGE_WAR_VALIDATION_RES_AUTH_INVALID_22;
+	public static String MESSAGE_WAR_VALIDATION_RES_AUTH_INVALID_23;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_EXCEPTION_TYPE;
+	public static String MESSAGE_WAR_VALIDATION_DUPLICATE_MAPPING;
+	public static String MESSAGE_WAR_VALIDATION_DUPLICATE_SERVLET;
+	public static String MESSAGE_WAR_VALIDATION_SESSION_TIMEOUT;
+	public static String MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY;
+	public static String MESSAGE_WAR_VALIDATION_EMPTY_ENTRY;
+	public static String MESSAGE_WAR_VALIDATION_DUPLICATE_FILTER;
+	public static String MESSAGE_WAR_VALIDATION_DUPLICATE_EJB_REF;
+	public static String ERROR_EAR_UNCONTAINED_MODULE_FILE_EXCEPTION;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_ERROR_CODE;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_RES_SHARING_SCOPE;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_ENV_ENTRY;
+	public static String MESSAGE_WAR_VALIDATION_MISSING_WLP_PROJECT;
+	public static String MESSAGE_WAR_VALIDATION_CONFLICTING_WLP_PROJECT;
+	public static String MSG_SERVER_TARGET_MISMATCH;
+	public static String MESSAGE_URL_PATTERN_END_WITH_CARRAIGE_RETURN;
+	public static String MESSAGE_WAR_VALIDATION_INVALID_EJB_REF_TYPE;
+	public static String ERROR_EAR_MISSING_EJB_ROLE;
+	public static String of_Type_Security_Role_Name_6;
+	public static String Web_Archive_Validator_8;
+	public static String of_Type_Role_Name_19;
+	public static String of_Type_Parameter_Name_25;
+	public static String of_Type_Parameter_Value_26;
+	public static String of_Type_Parameter_Name_32;
+	public static String of_Type_Parameter_Value_33;
+	public static String of_Type_Parameter_Name_39;
+	public static String of_Type_Parameter_Value_40;
+	public static String of_Type_ejb_ref_name_44;
+	public static String of_Type_Error_Location_47;
+	public static String of_Type_Error_Location_49;
+	public static String of_Type_Mime_Extension_54;
+	public static String of_Type_Mime_Type_55;
+	public static String of_Type_Mime_Extension___56;
+	public static String of_Type_Web_Resource_Collection_64;
+	public static String of_Type_Filter_Name_66;
+	public static String Invalid_URL_70;
+	public static String Invalid_URL_75;
+	public static String of_Type_Servlet_Name_77;
+	public static String of_Type_Taglib_80;
+	public static String of_Type_TagLib___81;
+	public static String of_Type_Web_Resource_Name_84;
+	public static String of_Type_Welcome_File_Name__87;
+	public static String of_Type_Env_Entry_Name___88;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, WARValidationResourceHandler.class);
 	}
-
-	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
-	}
-
-	public static String getString(String key, Object[] args, int x) {
-
-		return getString(key);
-	}
-}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WarValidator.java b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WarValidator.java
index fbe4a2e..86f31e2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WarValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/WarValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -103,7 +103,7 @@
 			 name = name.trim() ;
 	  if (name == null || name.equals("")) { //$NON-NLS-1$
 		  String[] parms = new String[1];
-		  parms[0] = WARValidationResourceHandler.getString("of_Type_Security_Role_Name_6") ; //$NON-NLS-1$
+		  parms[0] = WARValidationResourceHandler.of_Type_Security_Role_Name_6 ; 
 		  addError(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,role);
 		  continue ;          
 	  }
@@ -138,7 +138,7 @@
 
 	public String getName()
 	{
-		return WARValidationResourceHandler.getString("Web_Archive_Validator_8"); //$NON-NLS-1$
+		return WARValidationResourceHandler.Web_Archive_Validator_8; 
 	}
 	// Messaging helpers ...
 
@@ -310,7 +310,7 @@
 			String role = (String)authRoles.next() ;
 			if (role == null || role.trim().equals("")) { //$NON-NLS-1$
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Role_Name_19") ; //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_Role_Name_19 ; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,authConstraint);
 				continue ;              
 			}
@@ -347,7 +347,7 @@
 
 		if (name == null || name.equals("") ) { //$NON-NLS-1$
 			String[] parms = new String[1];
-			parms[0] = WARValidationResourceHandler.getString("of_Type_Parameter_Name_25"); //$NON-NLS-1$
+			parms[0] = WARValidationResourceHandler.of_Type_Parameter_Name_25; 
 
 			addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms, context);
 			continue;
@@ -355,7 +355,7 @@
 		//if (remember.get(name + value) != null) { // Check for dups
 		if (remember.get(name) != null) { // Check for dups
 			String[] parms = new String[1];
-			parms[0] = WARValidationResourceHandler.getString("of_Type_Parameter_Name_25") + ": " + name; //$NON-NLS-1$  //$NON-NLS-2$
+			parms[0] = WARValidationResourceHandler.of_Type_Parameter_Name_25 + ": " + name; 
 			addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms, context);
 			continue;
 		}
@@ -379,14 +379,14 @@
 
 			if (name == null || name.equals("") ) { //$NON-NLS-1$ 
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Parameter_Name_32"); //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_Parameter_Name_32; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms, initParam);
 				continue;
 			}
 			if (remember.get(name) != null) { // Check for dups
 
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Parameter_Name_25") + ": " +  name; //$NON-NLS-1$ //$NON-NLS-2$
+				parms[0] = WARValidationResourceHandler.of_Type_Parameter_Name_25 + ": " +  name; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms, initParam);
 				continue;
 			}
@@ -409,13 +409,13 @@
 
 			if (name == null || name.equals("") ) { //$NON-NLS-1$ 
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Parameter_Name_39"); //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_Parameter_Name_39; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms, initParam);
 				continue;
 			}
 			if (remember.get(name) != null) { // Check for dups
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Parameter_Name_25") + ": " +  name; //$NON-NLS-1$ //$NON-NLS-2$
+				parms[0] = WARValidationResourceHandler.of_Type_Parameter_Name_25 + ": " +  name; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms, initParam);
 				continue;
 			}
@@ -483,7 +483,7 @@
 
 				if (name.equals("")) { //$NON-NLS-1$
 					String[] parms = new String[1];
-					parms[0] = WARValidationResourceHandler.getString("of_Type_ejb-ref-name_44"); //$NON-NLS-1$
+					parms[0] = WARValidationResourceHandler.of_Type_ejb_ref_name_44; 
 					addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,eref);
 					continue ;
 				}           
@@ -496,7 +496,7 @@
 				remember.put(name,"Yea") ; //$NON-NLS-1$
 			} else {
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_ejb-ref-name_44"); //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_ejb_ref_name_44; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,eref);
 				continue ;
 			}
@@ -530,7 +530,7 @@
 	
 				if (name.equals("")) { //$NON-NLS-1$
 					String[] parms = new String[1];
-					parms[0] = WARValidationResourceHandler.getString("of_Type_ejb-ref-name_44"); //$NON-NLS-1$
+					parms[0] = WARValidationResourceHandler.of_Type_ejb_ref_name_44; 
 					addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,eref);
 					continue ;
 				}
@@ -543,7 +543,7 @@
 				remember.put(name,"Yea") ; //$NON-NLS-1$
 			} else {
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_ejb-ref-name_44"); //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_ejb_ref_name_44; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,eref);
 				continue ;
 			}
@@ -568,12 +568,12 @@
 	String location = nextPage.getLocation() ;
 	if (location == null || location.equals("")) { //$NON-NLS-1$
 		String[] parms = new String[1];
-		parms[0] = WARValidationResourceHandler.getString("of_Type_Error_Location_47") ; //$NON-NLS-1$
+		parms[0] = WARValidationResourceHandler.of_Type_Error_Location_47 ; 
 		addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,nextPage);
 	}
 	if (!location.startsWith("/")){ //$NON-NLS-1$
 		String[] parms = new String[1];
-		parms[0] = WARValidationResourceHandler.getString("of_Type_Error_Location_49") ; //$NON-NLS-1$
+		parms[0] = WARValidationResourceHandler.of_Type_Error_Location_49 ; 
 		addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_INVALID_ERROR_PAGE, parms,nextPage);
 	}
 
@@ -686,7 +686,7 @@
   	if ( name != null ) {
   		if (remember.get(name) != null) {   // Check for dups
 		  String[] parms = new String[1];
-		  parms[0] = WARValidationResourceHandler.getString("of_Type_Env_Entry_Name___88") +  ": " + name; //$NON-NLS-1$  //$NON-NLS-2$
+		  parms[0] = WARValidationResourceHandler.of_Type_Env_Entry_Name___88 +  ": " + name; 
 		  addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms,entry);
 	    }
 	    else {
@@ -722,16 +722,16 @@
 	  if (ext == null || ext.equals("") || mtype == null || mtype.equals("")) { //$NON-NLS-1$ //$NON-NLS-2$
 		  String[] parms = new String[1];
 		  if (ext == null || ext.trim().equals("")) //$NON-NLS-1$
-			 parms[0] = WARValidationResourceHandler.getString("of_Type_Mime_Extension_54") ;    //$NON-NLS-1$
+			 parms[0] = WARValidationResourceHandler.of_Type_Mime_Extension_54 ;    
 		  else
-			 parms[0] = WARValidationResourceHandler.getString("of_Type_Mime_Type_55") ; //$NON-NLS-1$
+			 parms[0] = WARValidationResourceHandler.of_Type_Mime_Type_55 ; 
 		  addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,mimeMap);
 		  continue ;          
 	  }
 	  if (remember.get(ext) != null) {   // Check for dups
 
 		  String[] parms = new String[1];
-		  parms[0] = WARValidationResourceHandler.getString("of_Type_Mime_Extension___56") + ": " + ext ; //$NON-NLS-1$  //$NON-NLS-2$
+		  parms[0] = WARValidationResourceHandler.of_Type_Mime_Extension___56 + ": " + ext ; 
 		  addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms,mimeMap);
 		  continue ;
 	  }
@@ -975,7 +975,7 @@
 	  EList webResourceList = constraint.getWebResourceCollections() ;
 	  if (webResourceList == null || webResourceList.isEmpty()) {
 		  String[] parms = new String[1];
-		  parms[0] = WARValidationResourceHandler.getString("of_Type_Web_Resource_Collection_64") ; //$NON-NLS-1$
+		  parms[0] = WARValidationResourceHandler.of_Type_Web_Resource_Collection_64 ; 
 		  addError(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,constraint);
 		  continue ;          
 	  }   
@@ -1014,7 +1014,7 @@
 
 			if (name == null || name.equals("")) { //$NON-NLS-1$
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Filter_Name_66") ; //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_Filter_Name_66 ; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,nextFilter);
 				continue ;
 			}           
@@ -1056,7 +1056,7 @@
 		
 		// Is is a valid URI notation ?
 		try {
-		   if (url.equals("")) throw new Exception(WARValidationResourceHandler.getString("Invalid_URL_70")) ; //$NON-NLS-1$ //$NON-NLS-2$
+		   if (url.equals("")) throw new Exception(WARValidationResourceHandler.Invalid_URL_70) ; 
 		// You can't use com.ibm.webtools.URI here...
 		//       com.ibm.iwt.webtools.URI uri = new com.ibm.iwt.webtools.URI(url) ;
 		}
@@ -1139,7 +1139,7 @@
 
 	// Is is a valid URI notation ?
 	try {
-	   if (url.equals("")) throw new Exception(WARValidationResourceHandler.getString("Invalid_URL_75")) ; //$NON-NLS-1$ //$NON-NLS-2$
+	   if (url.equals("")) throw new Exception(WARValidationResourceHandler.Invalid_URL_75) ; 
 
 //
 // The spec does not prohibit whitespace in the url-patterns
@@ -1186,7 +1186,7 @@
 
 			if (name == null || name.equals("")) { //$NON-NLS-1$
 				String[] parms = new String[1];
-				parms[0] = WARValidationResourceHandler.getString("of_Type_Servlet_Name_77"); //$NON-NLS-1$
+				parms[0] = WARValidationResourceHandler.of_Type_Servlet_Name_77; 
 				addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms,nextServlet);
 				continue ;
 			}           
@@ -1244,14 +1244,14 @@
 
 		if (uri == null || uri.equals("")) { //$NON-NLS-1$
 			String[] parms = new String[1];
-			parms[0] = WARValidationResourceHandler.getString("of_Type_Taglib_80"); //$NON-NLS-1$
+			parms[0] = WARValidationResourceHandler.of_Type_Taglib_80; 
 			addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY, parms, taglib);
 			continue;
 		}
 		if (remember.get(uri) != null) { // Check for dups
 
 			String[] parms = new String[1];
-			parms[0] = WARValidationResourceHandler.getString("of_Type_TagLib___81") + ": " + uri; //$NON-NLS-1$  //$NON-NLS-2$
+			parms[0] = WARValidationResourceHandler.of_Type_TagLib___81 + ": " + uri; 
 			addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms, taglib);
 			continue;
 		}
@@ -1270,7 +1270,7 @@
 		  if (name != null) name = name.trim() ;
 		  if (name == null || name.equals("")) {  // should have a name //$NON-NLS-1$
 			  String[] parms = new String[1];
-			  parms[0] = WARValidationResourceHandler.getString("of_Type_Web_Resource_Name_84") ; //$NON-NLS-1$
+			  parms[0] = WARValidationResourceHandler.of_Type_Web_Resource_Name_84 ; 
 			  addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_EMPTY_ENTRY , parms,resource);             
 		  }
 
@@ -1320,7 +1320,7 @@
 	fileName = fileName.trim() ;
 	if (remember.get(fileName) != null) {
 		String[] parms = new String[1];
-		parms[0] = WARValidationResourceHandler.getString("of_Type_Welcome_File_Name__87") + ": " + fileName ; //$NON-NLS-1$  //$NON-NLS-2$
+		parms[0] = WARValidationResourceHandler.of_Type_Welcome_File_Name__87 + ": " + fileName ; 
 		addWarning(WAR_CATEGORY, MESSAGE_WAR_VALIDATION_DUPLICATE_ENTRY, parms,nextFile);
 		continue ;      
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/rarvalidation.properties b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/rarvalidation.properties
index 04cf6c6..3b8ccad 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/rarvalidation.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/rarvalidation.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/warvalidation.properties b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/warvalidation.properties
index b290e9b..f556fc4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/warvalidation.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/j2ee-validation/warvalidation.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -30,9 +30,9 @@
 #
 
 # 2-July-2001:
-#  This file has been tested using the ProcessMsgFile tool, written by 
-#  Hany Salem and owned by Dennis Hebert.  Any future changes should 
-#  also be verified using this tool.  Please contact Dennis 
+#  This file has been tested using the ProcessMsgFile tool, written by
+#  Hany Salem and owned by Dennis Hebert.  Any future changes should
+#  also be verified using this tool.  Please contact Dennis
 #  (hebert@us.ibm.com or T/L 543-2520) for more information.
 #
 
@@ -240,7 +240,7 @@
 of_Type_Parameter_Value_33=of Type Parameter Value
 of_Type_Parameter_Name_39=of Type Parameter Name
 of_Type_Parameter_Value_40=of Type Parameter Value
-of_Type_ejb-ref-name_44=of Type ejb-ref-name
+of_Type_ejb_ref_name_44=of Type ejb-ref-name
 of_Type_Error_Location_47=of Type Error Location
 of_Type_Error_Location_49=of Type Error Location
 of_Type_Mime_Extension_54=of Type Mime Extension
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/Assert.java b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/Assert.java
new file mode 100644
index 0000000..a797956
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/Assert.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.core.internal.plugin;
+
+/**
+ * <code>Assert</code> is useful for for embedding runtime sanity checks
+ * in code.
+ * The predicate methods all test a condition and throw some
+ * type of unchecked exception if the condition does not hold.
+ * <p>
+ * Assertion failure exceptions, like most runtime exceptions, are
+ * thrown when something is misbehaving. Assertion failures are invariably
+ * unspecified behavior; consequently, clients should never rely on
+ * these being thrown (and certainly should not being catching them
+ * specifically).
+ * </p>
+ */
+public final class Assert {
+	/* This class is not intended to be instantiated. */
+	private Assert() {
+		// not allowed
+	}
+
+	/** Asserts that an argument is legal. If the given boolean is
+	 * not <code>true</code>, an <code>IllegalArgumentException</code>
+	 * is thrown.
+	 *
+	 * @param expression the outcode of the check
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 * @exception IllegalArgumentException if the legality test failed
+	 */
+	public static boolean isLegal(boolean expression) {
+		return isLegal(expression, ""); //$NON-NLS-1$
+	}
+
+	/** Asserts that an argument is legal. If the given boolean is
+	 * not <code>true</code>, an <code>IllegalArgumentException</code>
+	 * is thrown.
+	 * The given message is included in that exception, to aid debugging.
+	 *
+	 * @param expression the outcode of the check
+	 * @param message the message to include in the exception
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 * @exception IllegalArgumentException if the legality test failed
+	 */
+	public static boolean isLegal(boolean expression, String message) {
+		if (!expression)
+			throw new IllegalArgumentException(message);
+		return expression;
+	}
+
+	/** Asserts that the given object is not <code>null</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 * 
+	 * @param object the value to test
+	 * @exception IllegalArgumentException if the object is <code>null</code>
+	 */
+	public static void isNotNull(Object object) {
+		isNotNull(object, ""); //$NON-NLS-1$
+	}
+
+	/** Asserts that the given object is not <code>null</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 * The given message is included in that exception, to aid debugging.
+	 *
+	 * @param object the value to test
+	 * @param message the message to include in the exception
+	 * @exception IllegalArgumentException if the object is <code>null</code>
+	 */
+	public static void isNotNull(Object object, String message) {
+		if (object == null)
+			throw new AssertionFailedException("null argument:" + message); //$NON-NLS-1$
+	}
+
+	/** Asserts that the given boolean is <code>true</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 *
+	 * @param expression the outcode of the check
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 */
+	public static boolean isTrue(boolean expression) {
+		return isTrue(expression, ""); //$NON-NLS-1$
+	}
+
+	/** Asserts that the given boolean is <code>true</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 * The given message is included in that exception, to aid debugging.
+	 *
+	 * @param expression the outcode of the check
+	 * @param message the message to include in the exception
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 */
+	public static boolean isTrue(boolean expression, String message) {
+		if (!expression)
+			throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$
+		return expression;
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/AssertionFailedException.java b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/AssertionFailedException.java
new file mode 100644
index 0000000..b349e1c
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/AssertionFailedException.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.core.internal.plugin;
+
+/**
+ * <code>AssertionFailedException</code> is a runtime exception thrown
+ * by some of the methods in <code>Assert</code>.
+ * <p>
+ * This class is not declared public to prevent some misuses; programs that catch 
+ * or otherwise depend on assertion failures are susceptible to unexpected
+ * breakage when assertions in the code are added or removed.
+ * </p>
+ */
+/* package */
+class AssertionFailedException extends RuntimeException {
+	/**
+	 * All serializable objects should have a stable serialVersionUID
+	 */
+	private static final long serialVersionUID = 1L;
+
+	/** Constructs a new exception with the given message.
+	 */
+	public AssertionFailedException(String detail) {
+		super(detail);
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/EclipseEJBModelExtenderProvider.java b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/EclipseEJBModelExtenderProvider.java
index e1f07b1..764522d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/EclipseEJBModelExtenderProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/EclipseEJBModelExtenderProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,6 @@
 import java.util.SortedSet;
 import java.util.TreeSet;
 
-import org.eclipse.core.internal.runtime.Assert;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.jem.util.RegistryReader;
diff --git a/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/J2EECorePlugin.java b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/J2EECorePlugin.java
index 57e368c..2ecb957 100644
--- a/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/J2EECorePlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.core/j2eeCorePlugin/org/eclipse/jst/j2ee/core/internal/plugin/J2EECorePlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/j2eexml.properties b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/j2eexml.properties
index 492f7aa..889a7b9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/j2eexml.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/j2eexml.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -25,4 +25,5 @@
 Failure_occurred_reading_x_EXC_=IWAE0092E Failure occurred reading xml:
 Invalid_value_for__EXC_=IWAE0093E Invalid value for
 Valid_values_are___EXC_=IWAE0094E Valid values are:
+Key1=
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/mofj2ee.properties b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/mofj2ee.properties
index 8745d94..497df93 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/mofj2ee.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/mofj2ee.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Application.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Application.java
index 7f4411b..f080706 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Application.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Application.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,13 +17,20 @@
 /**
  * The application element is the root element of a J2EE application deployment descriptor.
 
- */
+ * @since 1.0 */
 public interface Application extends CompatibilityDescriptionGroup{
 
 
+/**
+ * @param name - String role name
+ * @return if contains the role
+ */
 public boolean containsSecurityRole(String name);
 /**
  * Returns the first module matching the specified uri and altDD
+ * @param uri - String aURI
+ * @param altDD - String altDD
+ * @return the first module matching the specified uri and altDD
  */
 public Module getModule(String uri, String altDD);
 
@@ -31,36 +38,58 @@
  * Returns the first module matching the specified uri
  * @deprecated preferably use {@link #getModule(String, String)} or {@link #getFirstModule(String)}
  * There may be multiple modules with the same uri but different alt-dds
- **/
+ *
+ * @param uri - String uri
+ * @return the first module matching the specified uri
+ */
 public Module getModule(String uri);
 /**
  *This returns the j2ee version id. Compare with J2EEVersionConstants to determine j2ee level
+ *
+ * @return returns the j2ee version id
+ * @throws IllegalStateException - When resource is proxy
  */
+
 public int getJ2EEVersionID() throws IllegalStateException ;
 /**
  * This returns the module version id.  Compare with J2EEVersionConstants to determine module level
+ *
+ * @return returns the module version id
+ * @throws IllegalStateException - When resource is proxy
  */
 public int getVersionID() throws IllegalStateException ;
 
 /**
  * Returns the first module matching the specified uri
+ *
+ * @param uri - String uri path
+ * @return the first module matching the specified uri
  */
 public Module getFirstModule(String uri);
 /**
  * Returns the first module where the alt dd matches the specified uri
+ *
+ * @param uri - String uri path
+ * @return the first module where the alt dd matches the specified uri
  */
 public Module getModuleHavingAltDD(String uri);
+/**
+ * @param name - String role name
+ * @return security role with name
+ */
 public SecurityRole getSecurityRoleNamed(String name);
 /**
  * Return boolean indicating if this Application was populated from an Applcation1.2 compliant descriptor
  * @return boolean
  * @deprecated Use getVersionID() to determine module level
+ *
  */
 public boolean isVersion1_2Descriptor();
 /**
  * Return boolean indicating if this Application was populated from an Application1.3 compliant descriptor
  * @return boolean
  * @deprecated Use getVersionID() to determine module level
+ *
  */
 public boolean isVersion1_3Descriptor();
 	/**
@@ -80,6 +109,7 @@
 	 * @see org.eclipse.jst.j2ee.application.ApplicationPackage#getApplication_Version()
 	 * @model
 	 * @generated
+	 *
 	 */
 	String getVersion();
 
@@ -91,6 +121,7 @@
 	 * @see #getVersion()
 	 * @generated
 	 */
+
 	void setVersion(String value);
 
 	/**
@@ -99,12 +130,14 @@
 	 * Contains the definitions of security roles which are
 	 * global to the application. 
 	 */
+
 	EList getSecurityRoles();
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The list of Modules references
 	 */
+
 	EList getModules();
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationFactory.java
index 7c28dad..e24a231 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 import org.eclipse.emf.ecore.EFactory;
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface ApplicationFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -60,7 +60,13 @@
 	ConnectorModule createConnectorModule();
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @generated This field/method will be replaced during code generation.
+	 *
+	 * @return EMF package class
 	 */
 	ApplicationPackage getApplicationPackage();
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationPackage.java
index 016ddcc..5de31be 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,15 @@
 import org.eclipse.jst.j2ee.common.CommonPackage;
 
 
-
+/**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	@since 1.0
+ */
 public interface ApplicationPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationResource.java
index 1a8f4da..47eabe3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ApplicationResource.java
@@ -1,18 +1,28 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.application;
 
 import org.eclipse.jst.j2ee.internal.common.XMLResource;
+/**
+ * The represents the deployment descriptor of the EAR.
+
+ * @since 1.0 */
 
 public interface ApplicationResource extends XMLResource {
-public Application getApplication() ;
+	
+	  /**
+	   * The application deployment descriptor 
+	   * @since 1.0
+	   * @return The deployment descriptor of the EAR, application deployment descriptor
+	   */
+	public Application getApplication() ;
 }
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ConnectorModule.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ConnectorModule.java
index 2ced538..5920336 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ConnectorModule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/ConnectorModule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 
 /**
  * Specifies the URI of a resource adapter archive file, relative to the top level of the application package.
- */
+ * @since 1.0 */
 public interface ConnectorModule extends Module{
 	//ConnectorModule
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/EjbModule.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/EjbModule.java
index aedaeaf..fd3bb4a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/EjbModule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/EjbModule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 /**
  * Specifies the URI of a ejb-jar, relative to the top level of the application package.
 
- */
+ * @since 1.0 */
 public interface EjbModule extends Module{
 	//EjbModule
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/JavaClientModule.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/JavaClientModule.java
index c0a1a84..3f9162c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/JavaClientModule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/JavaClientModule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 /**
  * specifies the URI of a java application client module, relative to the top level of the application package.
 
- */
+ * @since 1.0 */
 public interface JavaClientModule extends Module{
 	//JavaClientModule
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Module.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Module.java
index 8735af6..e63a357 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Module.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/Module.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,13 +14,32 @@
 /**
  * The module element represents a single J2EE module and contains an ejb, java, or web element, which indicates the module type and contains a path to the module file, and an optional alt-dd element, which specifies an optional URI to the post-assembly version of the deployment descriptor. The application deployment descriptor must have one module element for each J2EE module in the application package.
 
- */
+ * @since 1.0 */
 public interface Module extends EObject{
 
-public boolean isConnectorModule();
-public boolean isEjbModule();
-public boolean isJavaModule();
-public boolean isWebModule();
+	/**
+	 * Returns boolean value if this Module represents a ConnectorModule
+	 * @return boolean value
+	 */
+	public boolean isConnectorModule();
+	
+	/**
+	 * Returns boolean value if this Module represents a EjbModule
+	 * @return boolean value
+	 */
+	public boolean isEjbModule();
+	
+	/**
+	 * Returns boolean value if this Module represents a JavaClientModule(ApplicationClient)
+	 * @return boolean value
+	 */
+	public boolean isJavaModule();
+	
+	/**
+	 * Returns boolean value if this Module represents a WebModule
+	 * @return boolean value
+	 */
+	public boolean isWebModule();
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the Uri attribute
@@ -63,7 +82,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Application reference
+	 * @param value The new value of the Application reference
 	 */
 	void setApplication(Application value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/WebModule.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/WebModule.java
index 70ee2d7..7dd1e0d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/WebModule.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/WebModule.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 /**
  * Contains the web-uri and context-root of a web application module.
 
- */
+ * @since 1.0 */
 public interface WebModule extends Module{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationFactoryImpl.java
index 618ff66..ea83836 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationImpl.java
index f790042..7a79948 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationPackageImpl.java
index dc45f9d..5f28d03 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceFactory.java
index 20b11c3..e462460 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceImpl.java
index dec94ed..c9fd96b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ApplicationResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ConnectorModuleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ConnectorModuleImpl.java
index db0148a..f555406 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ConnectorModuleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ConnectorModuleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/EjbModuleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/EjbModuleImpl.java
index 5103c96..57ce7be 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/EjbModuleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/EjbModuleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/JavaClientModuleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/JavaClientModuleImpl.java
index 5ea43ae..d947814 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/JavaClientModuleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/JavaClientModuleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ModuleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ModuleImpl.java
index 831575a..7e938a9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ModuleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/ModuleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/WebModuleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/WebModuleImpl.java
index aa0e157..7c350d1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/WebModuleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/impl/WebModuleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationAdapterFactory.java
index b4f2420..a03029e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationSwitch.java
index c48b830..f861066 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/application/internal/util/ApplicationSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClient.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClient.java
index 7bdf531..2a21e98 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClient.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClient.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,9 +18,13 @@
 /**
  * The application-client element is the root element of an application client deployment descriptor.  The application client deployment descriptor describes the EJB components and external resources referenced by the application client.
 
- */
+ * @since 1.0 */
 public interface ApplicationClient extends CompatibilityDescriptionGroup{
 
+/**
+ * Returns the String name of the call back handler
+ * @return the class name of the callback handler
+ */
 public String getCallbackHandlerClassName();
 /**
  * Return boolean indicating if this Application Client was populated from an Application Client 1.2 compliant descriptor
@@ -35,9 +39,16 @@
  */
 public boolean isVersion1_3Descriptor();
 /**
+ * Return boolean indicating if this Application client was populated from an Application Client 1.4 compliant descriptor
+ * @return boolean
  * @deprecated Use getVersionID() to determine module level
  * */
 public boolean isVersion1_4Descriptor();
+/**
+ * The class must have a no args constructor 
+ * and must implement the javax.security.auth.callback.CallbackHandler interface.
+ * @param callbackHandlerClassName the name of the class of the CallbackHandler reference
+ */
 public void setCallbackHandlerClassName(String callbackHandlerClassName);
 	/**
 	 * Returns the value of the '<em><b>Version</b></em>' attribute.
@@ -79,10 +90,15 @@
 
 	/**
 	 This returns the module version id. Compare with J2EEVersionConstants to determine module level
+	 *
+	 * @return the int representing the app client module version
+	 * @throws IllegalStateException - when EMF resource is not loaded
 	 */
 	public int getVersionID() throws IllegalStateException ;
 	/**
 	 *This returns the j2ee version id. Compare with J2EEVersionConstants to determine j2ee level
+	 * @return the int representing the J2EE spec version.
+	 * @throws IllegalStateException - when EMF resource is not loaded
 	 */
 	public int getJ2EEVersionID() throws IllegalStateException ;
 
@@ -137,7 +153,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the CallbackHandler reference
+	 * @param value The new value of the CallbackHandler reference
 	 */
 	void setCallbackHandler(JavaClass value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClientResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClientResource.java
index 85a2488..977143d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClientResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ApplicationClientResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -12,7 +12,15 @@
 
 import org.eclipse.jst.j2ee.internal.common.XMLResource;
 
+/**
+ * EMF Resource class the contrains App Client document
+ *	@since 1.0
+ */
 public interface ApplicationClientResource extends XMLResource {
+/**
+ * Returns the one contained object in this resource's collection of root objects
+ * @return ApplicationClient, the root object for the App Client document.
+ */
 public ApplicationClient getApplicationClient() ;
 }
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientFactory.java
index 5c32c79..71a6ef5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 import org.eclipse.emf.ecore.EFactory;
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface ClientFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -31,6 +31,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
+	 * @return ClientPackage value
 	 */
 	ClientPackage getClientPackage();
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientPackage.java
index cb404fa..7175147 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ClientPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,15 @@
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.jst.j2ee.common.CommonPackage;
 
-
+/**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	@since 1.0
+ */
 
 public interface ClientPackage extends EPackage{
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ResAuthApplicationType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ResAuthApplicationType.java
index 291ae6c..b8f96a1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ResAuthApplicationType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/ResAuthApplicationType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,7 +16,9 @@
 
 import org.eclipse.emf.common.util.AbstractEnumerator;
 
-
+/**
+ *@since 1.0
+ */
 
 public final class ResAuthApplicationType extends AbstractEnumerator{
 	/**
@@ -92,6 +94,8 @@
 	/**
 	 * Returns the '<em><b>Res Auth Application Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -108,6 +112,8 @@
 	/**
 	 * Returns the '<em><b>Res Auth Application Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientImpl.java
index 65c3206..999d9e9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceFactory.java
index cec03c2..24992c2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceImpl.java
index ba1d1ca..1105ea4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ApplicationClientResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientFactoryImpl.java
index 842fd08..3e20ba0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientPackageImpl.java
index cfd4e78..0a940a4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/impl/ClientPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientAdapterFactory.java
index 18e3c98..e87ff43 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientSwitch.java
index ff5e1fa..25aa598 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/client/internal/util/ClientSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonFactory.java
index d68c46f..5e7d85a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.common.CommonPackage
  * @generated
- */
+ * @since 1.0 */
 public interface CommonFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -221,6 +221,8 @@
 	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
 	 * <!-- end-user-doc -->
 	 * @return the package supported by this factory.
 	 * @generated
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonPackage.java
index 0609d5f..306020d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CommonPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,7 +16,15 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
 
-
+/**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	@since 1.0
+ */
 public interface CommonPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CompatibilityDescriptionGroup.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CompatibilityDescriptionGroup.java
index 8e8369b..776eebd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CompatibilityDescriptionGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/CompatibilityDescriptionGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -30,7 +30,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getCompatibilityDescriptionGroup()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface CompatibilityDescriptionGroup extends DescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Small Icon</b></em>' attribute.
@@ -58,6 +58,10 @@
 	 */
 	void setSmallIcon(String value);
 
+	/**
+	 * Sets the value of the Small Icon attribute
+	 * @param value the new value of the attribute
+	 */
 	void setSmallIconGen(String value);
 
 	/**
@@ -86,6 +90,10 @@
 	 */
 	void setLargeIcon(String value);
 
+	/**
+	 * Sets the value of the Large Icon
+	 * @param value the new value of the Large Icon
+	 */
 	void setLargeIconGen(String value);
 
 	/**
@@ -114,6 +122,10 @@
 	 */
 	void setDescription(String value);
 
+	/**
+	 * Sets the value of the Description 
+	 * @param value the new value of the Description attrbute
+	 */
 	void setDescriptionGen(String value);
 
 	/**
@@ -142,6 +154,10 @@
 	 */
 	void setDisplayName(String value);
 
+	/**
+	 * Sets the value of the Display Name
+	 * @param value the new value of the Display Name
+	 */
 	void setDisplayNameGen(String value);
 
 } // CompatibilityDescriptionGroup
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DeploymentExtension.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DeploymentExtension.java
index 1863410..7cfcb0b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DeploymentExtension.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DeploymentExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -30,7 +30,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getDeploymentExtension()
  * @model 
  * @generated
- */
+ * @since 1.0 */
 public interface DeploymentExtension extends EObject {
 	/**
 	 * Returns the value of the '<em><b>Namespace</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Description.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Description.java
index c6a79fa..d53cfb2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Description.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Description.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -44,7 +44,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getDescription()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface Description extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Lang</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DescriptionGroup.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DescriptionGroup.java
index b1f30c3..b1faaf5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DescriptionGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DescriptionGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -36,7 +36,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getDescriptionGroup()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface DescriptionGroup extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Icons</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DisplayName.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DisplayName.java
index 647629d..c97fa75 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DisplayName.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/DisplayName.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -42,7 +42,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getDisplayName()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface DisplayName extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Lang</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EJBLocalRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EJBLocalRef.java
index 94f84e0..9167e6f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EJBLocalRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EJBLocalRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,7 +16,7 @@
 /**
  * The ejb-local-ref element is used for the declaration of a reference to another enterprise bean's local home. The declaration consists of an optional description; the EJB reference name used in the code of the referencing enterprise bean; the expected type of the referenced enterprise bean; the expected local home and local interfaces of the referenced enterprise bean; and an optional ejb-link information. The optional ejb-link element is used to specify the referenced enterprise bean.
  * Used in: entity, session, message-driven
- */
+ * @since 1.0 */
 public interface EJBLocalRef extends EjbRef{
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRef.java
index cba808f..2aa3b22 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,7 @@
 
 /**
  * The ejb-ref element is used for the declaration of a reference to an enterprise bean's home. The declaration consists of an optional description; the EJB reference name used in the code of the referencing application client; the expected type of the referenced enterprise bean; the expected home and remote interfaces of the referenced enterprise bean; and an optional ejb-link information. The optional  ejb-link element is used to specify the referenced enterprise bean.
- */
+ * @since 1.0 */
 public interface EjbRef extends EObject{
 
 /**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRefType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRefType.java
index f4ded8a..84fb41a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRefType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EjbRefType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -86,6 +86,8 @@
 	/**
 	 * Returns the '<em><b>Ejb Ref Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +104,8 @@
 	/**
 	 * Returns the '<em><b>Ejb Ref Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntry.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntry.java
index 9b5a997..bbce2bf 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntry.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 
 /**
  * The env-entry element contains the declaration of an application client's environment entries. The declaration consists of an optional description, the name of the environment entry, and an optional value.
- */
+ * @since 1.0 */
 public interface EnvEntry extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntryType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntryType.java
index 989fa2b..029edb8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntryType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/EnvEntryType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -219,6 +219,8 @@
 	/**
 	 * Returns the '<em><b>Env Entry Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -235,6 +237,8 @@
 	/**
 	 * Returns the '<em><b>Env Entry Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ExtensibleType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ExtensibleType.java
index 5bcdec1..37b79a3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ExtensibleType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ExtensibleType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,7 +27,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getExtensibleType()
  * @model 
  * @generated
- */
+ * @since 1.0 */
 public interface ExtensibleType extends EObject {
 	/**
 	 * Returns the value of the '<em><b>Value</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/IconType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/IconType.java
index c090e39..7ba1c5b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/IconType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/IconType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -41,7 +41,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getIconType()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface IconType extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Small Icon</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Identity.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Identity.java
index 6c2f572..a24e90b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Identity.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Identity.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 /**
  * Specifies the run-as identity to be used for the execution of the methods of an enterprise bean. It contains an optional description, and the name of a security role.
 
- */
+ * @since 1.0 */
 public interface Identity extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/JNDIEnvRefsGroup.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/JNDIEnvRefsGroup.java
index 82514f6..5552cd4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/JNDIEnvRefsGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/JNDIEnvRefsGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -39,7 +39,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getJNDIEnvRefsGroup()
  * @model abstract="true"
  * @generated
- */
+ * @since 1.0 */
 public interface JNDIEnvRefsGroup extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Environment Properties</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Listener.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Listener.java
index bd5671b..2b3187d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Listener.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/Listener.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 import org.eclipse.jem.java.JavaClass;
 /**
  * Declares a class in the application must be registered as a web application listener bean.
- */
+ * @since 1.0 */
 public interface Listener extends CompatibilityDescriptionGroup{
 
 /**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestination.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestination.java
index da8d022..2c48dc8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestination.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestination.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -50,7 +50,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getMessageDestination()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface MessageDestination extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationRef.java
index 26e8b7c..370f690 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -61,7 +61,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getMessageDestinationRef()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface MessageDestinationRef extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationUsageType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationUsageType.java
index e55cdff..abb73ab 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationUsageType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/MessageDestinationUsageType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -24,6 +24,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getMessageDestinationUsageType()
  * @model
  * @generated
+ * @since 1.0
  */
 public final class MessageDestinationUsageType extends AbstractEnumerator {
 	/**
@@ -125,6 +126,8 @@
 	/**
 	 * Returns the '<em><b>Message Destination Usage Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -141,6 +144,8 @@
 	/**
 	 * Returns the '<em><b>Message Destination Usage Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ParamValue.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ParamValue.java
index fe8623e..40c7ce3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ParamValue.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ParamValue.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getParamValue()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ParamValue extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/QName.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/QName.java
index 61e2cec..acc1e89 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/QName.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/QName.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -30,7 +30,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getQName()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface QName extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Namespace URI</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResAuthTypeBase.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResAuthTypeBase.java
index 1285251..2617853 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResAuthTypeBase.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResAuthTypeBase.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -31,6 +31,7 @@
  * @see org.eclipse.jst.j2ee.common.CommonPackage#getResAuthTypeBase()
  * @model
  * @generated
+ * @since 1.0
  */
 public final class ResAuthTypeBase extends AbstractEnumerator {
 	/**
@@ -132,6 +133,8 @@
 	/**
 	 * Returns the '<em><b>Res Auth Type Base</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -148,6 +151,8 @@
 	/**
 	 * Returns the '<em><b>Res Auth Type Base</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResSharingScopeType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResSharingScopeType.java
index 8cbee4e..5a8001a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResSharingScopeType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResSharingScopeType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface ResSharingScopeType {}
+ * @since 1.0
  */
 public final class ResSharingScopeType extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Res Sharing Scope Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Res Sharing Scope Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceEnvRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceEnvRef.java
index af79203..edc676b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceEnvRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceEnvRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -23,11 +23,20 @@
  *     <resource-env-ref-name>jms//StockQueue<//resource-env-ref-name>
  *     <resource-env-ref-type>javax.jms.Queue<//resource-env-ref-type>
  * <//resource-env-ref>
- */
+ * @since 1.0 */
 public interface ResourceEnvRef extends EObject{
 
-public String getTypeName();
-public void setTypeName(String className);
+	/**
+	 * Gets the name for the type
+	 * @return String value
+	 */
+	public String getTypeName();
+	
+	/**
+	 * Sets the name of the type attribute
+	 * @param className sets the name for the type
+	 */
+	public void setTypeName(String className);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the Description attribute
@@ -71,7 +80,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Type reference
+	 * @param value The new value of the Type reference
 	 */
 	void setType(JavaClass value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceRef.java
index 67dc63b..8f79f2d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/ResourceRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,7 +21,7 @@
  * <res-type>javax.sql.DataSource<//res-type>
  * <res-auth>Container<//res-auth>
  * <//resource-ref>
- */
+ * @since 1.0 */
 public interface ResourceRef extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/RunAsSpecifiedIdentity.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/RunAsSpecifiedIdentity.java
index d39ecc4..c09d6f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/RunAsSpecifiedIdentity.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/RunAsSpecifiedIdentity.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 /**
  * The security-identity element specifies whether the caller's security identity is to be used for the execution of the methods of the enterprise bean or whether a specific run-as identity is to be used. It    contains an optional description and a specification of the security identity to be used.
 
- */
+ * @since 1.0 */
 public interface RunAsSpecifiedIdentity extends SecurityIdentity{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -28,7 +28,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Identity reference
+	 * @param value The new value of the Identity reference
 	 */
 	void setIdentity(Identity value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityIdentity.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityIdentity.java
index f7fbca2..9dbf090 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityIdentity.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityIdentity.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,7 +16,7 @@
  * The security-identity element specifies whether the caller's security identity is to be used for the execution of the methods of the enterprise bean or whether a specific run-as identity is to be used. It
  * contains an optional description and a specification of the security identity to be used.
 
- */
+ * @since 1.0 */
 public interface SecurityIdentity extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -49,8 +49,16 @@
 	 */
 	EList getDescriptions();
 
+	/**
+	 * Returns boolean value for the RunAsSpecifiedIdentity
+	 * @return boolean value
+	 */
 	boolean isRunAsSpecifiedIdentity();
 	
+	/**
+	 * Returns boolean value for the Caller Identity
+	 * @return boolean value
+	 */
 	boolean isUseCallerIdentity();
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRole.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRole.java
index d2aaf66..5bba8f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRole.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRole.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 /**
  * A semantic grouping of operations that may be performed by a subject.
  * The security-role element contains the declaration of a security role which is used in the security-constraints placed on the web application.
- */
+ * @since 1.0 */
 public interface SecurityRole extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRoleRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRoleRef.java
index 84cd42e..9eea669 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRoleRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/SecurityRoleRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface SecurityRoleRef extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/UseCallerIdentity.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/UseCallerIdentity.java
index 7e02824..90a8091 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/UseCallerIdentity.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/UseCallerIdentity.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 /**
  * The use-caller-identity element specifies that the caller's security identity be used as the security identity for the execution of the enterprise bean's methods.
 
- */
+ * @since 1.0 */
 public interface UseCallerIdentity extends SecurityIdentity{
 	//UseCallerIdentity
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonFactoryImpl.java
index 1eaa0f4..e2629a8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonPackageImpl.java
index 875668d..1e29120 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CommonPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CompatibilityDescriptionGroupImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CompatibilityDescriptionGroupImpl.java
index 9e02f06..b63ef2c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CompatibilityDescriptionGroupImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/CompatibilityDescriptionGroupImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupAdapter.java
index c7e755d..d87b2d7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -116,4 +116,4 @@
 		if (newTarget instanceof CompatibilityDescriptionGroup)
 			super.setTarget(newTarget);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupImpl.java
index 1545ca9..9cc21dd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionGroupImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionImpl.java
index ff132ec..85f256c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DescriptionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DisplayNameImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DisplayNameImpl.java
index 5eec394..ff4c302 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DisplayNameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/DisplayNameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EJBLocalRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EJBLocalRefImpl.java
index 322788d..8501ee2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EJBLocalRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EJBLocalRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EjbRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EjbRefImpl.java
index 58e6923..8ad023c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EjbRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EjbRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EnvEntryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EnvEntryImpl.java
index 88f8c94..4119c4a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EnvEntryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/EnvEntryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IconTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IconTypeImpl.java
index ef8e855..dee539e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IconTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IconTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IdentityImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IdentityImpl.java
index cf630f0..5bc4cca 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IdentityImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/IdentityImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResouceFactorySaxRegistry.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResouceFactorySaxRegistry.java
index d9e7638..4210a55 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResouceFactorySaxRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResouceFactorySaxRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryDomRegistry.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryDomRegistry.java
index d99420ef..8eb5915 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryDomRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryDomRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryRegistry.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryRegistry.java
index 151d258..3229aba 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/J2EEResourceFactoryRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/JNDIEnvRefsGroupImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/JNDIEnvRefsGroupImpl.java
index bc38b5c..c1019dc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/JNDIEnvRefsGroupImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/JNDIEnvRefsGroupImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ListenerImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ListenerImpl.java
index 4cd4b7f..8c55bf6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ListenerImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ListenerImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationImpl.java
index a99f7ef..8060831 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationRefImpl.java
index 03a212b..ff60b5b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/MessageDestinationRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ParamValueImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ParamValueImpl.java
index 4f3ac93..00cf3fe 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ParamValueImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ParamValueImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/QNameImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/QNameImpl.java
index 52f1bff..6df729c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/QNameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/QNameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceEnvRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceEnvRefImpl.java
index abbce64..c17ae90 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceEnvRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceEnvRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceRefImpl.java
index 0acc992..1d9e20a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/ResourceRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/RunAsSpecifiedIdentityImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/RunAsSpecifiedIdentityImpl.java
index 4dc2595..7cc442f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/RunAsSpecifiedIdentityImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/RunAsSpecifiedIdentityImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityIdentityImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityIdentityImpl.java
index 04e1866..bf6732a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityIdentityImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityIdentityImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleImpl.java
index 8d6d10c..6362c42 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleRefImpl.java
index 0c4654e..6192c9e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/SecurityRoleRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/UseCallerIdentityImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/UseCallerIdentityImpl.java
index b506749..48a8c1b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/UseCallerIdentityImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/UseCallerIdentityImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceFactory.java
index f6d4699..329b7af 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceImpl.java
index d8ba748..0b8dd06 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/impl/XMLResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonAdapterFactory.java
index fbe533a..a2f85d5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonSwitch.java
index 6ddec12..1eb01c6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonUtil.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonUtil.java
index f683a9d..56d1046 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/CommonUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,7 @@
 import org.eclipse.jst.j2ee.application.internal.impl.ApplicationFactoryImpl;
 import org.eclipse.jst.j2ee.client.internal.impl.ClientFactoryImpl;
 import org.eclipse.jst.j2ee.ejb.internal.impl.EjbFactoryImpl;
-import org.eclipse.jst.j2ee.internal.xml.J2EEXMLResourceHandler;
+import org.eclipse.jst.j2ee.internal.MOFJ2EEResourceHandler;
 import org.eclipse.jst.j2ee.jca.internal.impl.JcaFactoryImpl;
 import org.eclipse.jst.j2ee.webapplication.internal.impl.WebapplicationFactoryImpl;
 
@@ -64,10 +64,10 @@
 public static void checkDDObjectForVersion(EObject dd) {
 	if (dd.eIsProxy()) {
 		String proxyUri = ((InternalEObject)dd).eProxyURI().toString();
-		String message = J2EEXMLResourceHandler.getString("J2EE_VERSION_PROXY_ERROR", new Object[]{proxyUri}); //$NON-NLS-1$
+		String message = MOFJ2EEResourceHandler.getString(MOFJ2EEResourceHandler.J2EE_VERSION_PROXY_ERROR, new Object[]{proxyUri}); 
 		throw new IllegalStateException(message);
 	} else if (dd.eResource() == null) {
-		String message = J2EEXMLResourceHandler.getString("J2EE_VERSION_NULL_ERROR"); //$NON-NLS-1$
+		String message = MOFJ2EEResourceHandler.J2EE_VERSION_NULL_ERROR; 
 		throw new IllegalStateException(message);
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultable.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultable.java
index b4a0b98..4301ee4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultable.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultable.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 import org.eclipse.emf.common.notify.Notifier;
 /**
  * Interface used for objects that can be "fluffed up" on demand, but not serialized unless modified
- */
+ * @since 1.0 */
 public interface Defaultable extends Notifier {
 public boolean isDefault();
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/DefaultedAdapterImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/DefaultedAdapterImpl.java
index b070780..4054091 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/DefaultedAdapterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/DefaultedAdapterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultor.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultor.java
index ed7298f..3aadeb2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultor.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/Defaultor.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
  * Insert the type's description here.
  * Creation date: (6/15/2001 4:58:15 PM)
  * @author: Administrator
- */
+ * @since 1.0 */
 public interface Defaultor {
 /**
  * Returns true if this objects create @aDefaultable and it is still
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/IDUtility.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/IDUtility.java
index bde1d86..dfbcdd8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/IDUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/IDUtility.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/XmlSpecifiedDataAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/XmlSpecifiedDataAdapter.java
index 5d58b6a..67d1934 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/XmlSpecifiedDataAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/common/internal/util/XmlSpecifiedDataAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AcknowledgeMode.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AcknowledgeMode.java
index a7bee7f..1a9c5f6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AcknowledgeMode.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AcknowledgeMode.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface AcknowledgeMode {}
+ * @since 1.0
  */
 public final class AcknowledgeMode extends AbstractEnumerator{
 	/**
@@ -85,6 +86,8 @@
 	/**
 	 * Returns the '<em><b>Acknowledge Mode</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -103,6 +106,8 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
+	 * @param value passes literal value
+	 * @return literal instance
 	 */
 	public static AcknowledgeMode get(int value) {
 		switch (value) {
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfig.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfig.java
index b64d8ed..6d815ac 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfig.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfig.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -44,7 +44,7 @@
  * @see org.eclipse.jst.j2ee.ejb.EjbPackage#getActivationConfig()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ActivationConfig extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Config Properties</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfigProperty.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfigProperty.java
index d2195e4..9e0b7bc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfigProperty.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ActivationConfigProperty.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.ejb.EjbPackage#getActivationConfigProperty()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ActivationConfigProperty extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Value</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AssemblyDescriptor.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AssemblyDescriptor.java
index 6a9e699..c461721 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AssemblyDescriptor.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/AssemblyDescriptor.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,30 +18,44 @@
 
 /**
  * The assembly-descriptor element contains application-assembly information.  The application-assembly information consists of the following parts: the definition of security roles, the definition of method permissions, and the definition of transaction attributes for enterprise beans with container-managed transaction demarcation. All the parts are optional in the sense that they are omitted if the lists represented by them are empty. Providing an assembly-descriptor in the deployment descriptor is optional for the ejb-jar file producer.
- */
+ * @since 1.0 */
 public interface AssemblyDescriptor extends EObject{
 
-/**
- * Return the first method permission that contains all the roles in securityRoles and
- * is the same size
- */
-MethodPermission getMethodPermission(List securityRoles);
-/**
- * Return a List of MethodElements for @anEJB going
- * through the MethodPermissions.
- */
-List getMethodPermissionMethodElements(EnterpriseBean anEJB) ;
-/**
- * Return a List of MethodElements for @anEJB going
- * through the MethodTransactions.
- */
-List getMethodTransactionMethodElements(EnterpriseBean anEJB) ;
+	/**
+	 * Return the first method permission that contains all the roles in securityRoles and
+	 * is the same size
+	 * @param  securityRoles the list of SecurityRole
+	 * @return The MethodPermission
+	 */
+	MethodPermission getMethodPermission(List securityRoles);
+	/**
+	 * Return a List of MethodElements for @anEJB going
+	 * through the MethodPermissions.
+	 * @param anEJB the Enterprise Bean model
+	 * @return List of MethodElement
+	 */
+	List getMethodPermissionMethodElements(EnterpriseBean anEJB) ;
+	/**
+	 * Return a List of MethodElements for @anEJB going
+	 * through the MethodTransactions.
+	 * @param anEJB the Enterprise Bean model
+	 * @return List of MethodElement
+	 */
+	List getMethodTransactionMethodElements(EnterpriseBean anEJB) ;
+	
+	/**
+	 * Return the SecurityRole given a roleName
+	 * @param roleName the name of the role
+	 * @return SecurityRole
+	 */	
 	public SecurityRole getSecurityRoleNamed(String roleName);
 
-/**
- * Rename the security role, if it exists
- */
-public void renameSecurityRole(String existingRoleName, String newRoleName);
+	/**
+	 * Rename the security role, if it exists
+	 * @param existingRoleName the existing role name
+	 * @param newRoleName the new role name
+	 */
+	public void renameSecurityRole(String existingRoleName, String newRoleName);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The list of MethodPermissions references
@@ -66,7 +80,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the EjbJar reference
+	 * @param value the new value of the EjbJar reference
 	 */
 	void setEjbJar(EJBJar value);
 
@@ -84,7 +98,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the ExcludeList reference
+	 * @param value the new value of the ExcludeList reference
 	 */
 	void setExcludeList(ExcludeList value);
 
@@ -109,6 +123,7 @@
 
 	/**
 	 * Remove the MethodElements that are referencing @anEJB.
+	 * @param anEJB the Enterprise Bean model
 	 */
 	void removeData(EnterpriseBean anEJB) ;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMPAttribute.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMPAttribute.java
index 2552524..27444f7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMPAttribute.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMPAttribute.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,32 +17,65 @@
 /**
  * Describes a container-managed field. The field element includes an optional description of the field, and the name of the field.
 
- */
+ * @since 1.0 */
 public interface CMPAttribute extends EAttribute{
 
-/**
- * @deprecated - With EJB 2.0, assuming a Java field is no longer safe.
- * 		Use getType() and getName() to get the most common field info.
- *		Or use getEjbClass() to get additional Java info.
- */
+	/**
+	 * @deprecated - With EJB 2.0, assuming a Java field is no longer safe.
+	 * 		Use getType() and getName() to get the most common field info.
+	 *		Or use getEjbClass() to get additional Java info.
+	 *@return the Field value
+	 */
 
-Field getField() ;
-String getGetterName();
-/**
- * Return the type of this attribute in its original form (i.e., unwrapped if
- * the type has been wrapped).
- */
-public JavaHelpers getOriginatingType() ;
-String getSetterName();
-JavaHelpers getType() ;
-boolean isCMRField() ;
-boolean isKey() ;
-/**
- * Returns true if this field is a primkey-field in the deployment descriptor.
- * @return
- */
-public boolean isPrimKeyField();
-public void setOriginatingType(JavaHelpers newOriginatingType) ;
+	Field getField() ;
+	
+	/**
+	 * The name of the get method corresponding to this attrribute
+	 * @return the String value
+	 */
+	String getGetterName();
+	/**
+	 * Return the type of this attribute in its original form (i.e., unwrapped if
+	 * the type has been wrapped).
+	 * @return JavaHelpers value
+	 */
+	public JavaHelpers getOriginatingType() ;
+	
+	/**
+	 * The name of the set method corresponding to this attrribute
+	 * @return the String value
+	 */
+	String getSetterName();
+	
+	/**
+	 * Returns the Java Type of the attribute
+	 * @return the JavaHelpers
+	 */
+	JavaHelpers getType() ;
+	
+	/**
+	 * Returns true if the attribute is a CMR field
+	 * @return boolean value
+	 */
+	boolean isCMRField() ;
+	
+	/**
+	 * Returns true if the attribute is the key field of the bean
+	 * @return boolean value
+	 */
+	boolean isKey() ;
+	/**
+	 * Returns true if this field is a primkey-field in the deployment descriptor.
+	 * @return boolean value
+	 */
+	public boolean isPrimKeyField();
+	
+	/**
+	 * Sets the originating Java type
+	 * @param newOriginatingType the JavaHelpers
+	 */
+	public void setOriginatingType(JavaHelpers newOriginatingType) ;
+	
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the Description attribute
@@ -83,9 +116,14 @@
 
 	/**
 	 * Return true if a targetAttribute exists.
+	 * @return boolean value
 	 */
 	boolean isDerived();
 	
+	/**
+	 * Sets the attribute as a derived attribute
+	 * @param aBoolean the boolean value
+	 */
 	void setDerived(boolean aBoolean);
 	
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMRField.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMRField.java
index baf5ed1..38cdac9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMRField.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CMRField.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,11 +15,20 @@
  * Describes the bean provider's view of a relationship. It consists of an optional description, and the name and the class type of a field in the source of a role of a relationship. The CMRField::name element corresponds to the name used for the get and set accessor methods for the relationship. The CMRField::type element is used only for collection-valued CMRFields. It specifies the type of the collection that is used (a java class name).
  * 
 
- */
+ * @since 1.0 */
 public interface CMRField extends CMPAttribute{
 
-  public  String getCollectionTypeName();  
-public void setCollectionTypeName(String typeName);
+	/**
+	 * Returns the java CollectionType name
+	 * @return The name of the java collection type
+	 */
+	public  String getCollectionTypeName();  
+	
+	/**
+	 * Sets the java collection type name
+	 * @param typeName the name of the java collection type
+	 */
+	public void setCollectionTypeName(String typeName);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The Role reference
@@ -28,7 +37,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Role reference
+	 * @param value The new value of the Role reference
 	 */
 	void setRole(EJBRelationshipRole value);
 
@@ -40,7 +49,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the CollectionType reference
+	 * @param value The new value of the CollectionType reference
 	 */
 	void setCollectionType(JavaClass value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationship.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationship.java
index 3cee916..89c7320 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationship.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationship.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,13 +16,37 @@
  * Insert the type's description here.
  * Creation date: (10/26/2001 9:24:27 AM)
  * @author: Administrator
- */
+ * @since 1.0 */
 public interface CommonRelationship extends EObject {
-public EList getCommonRoles();
-public CommonRelationshipRole getFirstCommonRole();
-public CommonRelationshipRole getSecondCommonRole();
-public String getName();
-public void setName(String value);
+	/**
+	 * Returns the EList of the common roles
+	 * @return EList reference
+	 */
+	public EList getCommonRoles();
+	
+	/**
+	 * Gets the first common role
+	 * @return CommonRelationshipRole reference
+	 */
+	public CommonRelationshipRole getFirstCommonRole();
+	
+	/**
+	 * Gets the second common role
+	 * @return CommonRelationshipRole
+	 */
+	public CommonRelationshipRole getSecondCommonRole();
+	
+	/**
+	 * Returns the name of the CommonRelationship
+	 * @return String value
+	 */
+	public String getName();
+	
+	/**
+	 * Sets the name of the CommonRelationship
+	 * @param value the String value of the name
+	 */
+	public void setName(String value);
 }
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationshipRole.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationshipRole.java
index 498b0f0..3a25cba 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationshipRole.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/CommonRelationshipRole.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,47 +16,52 @@
  * Insert the type's description here.
  * Creation date: (10/26/2001 9:24:27 AM)
  * @author: Administrator
- */
+ * @since 1.0 */
 public interface CommonRelationshipRole extends EObject {
 /**
  * Return the persistentAttributes from my Entity that are used
  * by this role.
+ * @return the attributes of the CommonRelationshipRole
  */
 
 public EList getAttributes();
 /**
  * Return our parent relationship as a CommonRelationship
+ * @return the CommonRelationship reference
  */
 
 public CommonRelationship getCommonRelationship();
 
 
 /**
- * @return The value of the Name attribute
- * Defines a name for a role that is unique within an ejb-relation. Different relationships can use the same name for a role.
 
+ * Defines a name for a role that is unique within an ejb-relation. Different relationships can use the same name for a role.
+ * @return The value of the Name attribute
 	 */
 	public String getName();
 /**
  * Return the actual name of this role.  This is the name defined in the Deployment
  * Descriptor.  You should use <code>getName()</code> for the name to use in code
  * generation.
+ * @return the name of the CommonRelationshipRole 
  */
 String getRoleName();
 /**
  * Return the other role.
+ * @return CommonRelationshipRole reference
  */
 
 CommonRelationshipRole getOppositeAsCommonRole() ;
 /**
  * @return The Source ejb
- * Compute the ContainerManagedEntity which is the source of a role that participates in a relationship. 
+ * Compute the ContainerManagedEntity which is the source of a role that participates in a relationship.
+ * @return  ContainerManagedEntity reference
  */
 public ContainerManagedEntity getSourceEntity();
 
 /**
- * @return The type ejb
- * Compute the ContainerManagedEntity which is the type of a role that participates in a relationship. 
+ * Compute the ContainerManagedEntity which is the type of a role that participates in a relationship.
+ * @return The type ejb 
  */
 public ContainerManagedEntity getTypeEntity();
 /**
@@ -64,13 +69,16 @@
 * Specifies whether this role should be mapped to a persistent reference, such as a foreign key.
 */
 public boolean isForward();
+
 /**
-* @return The computed value isKey
-*/
+ * Returns true if this is a key 
+ * @return The computed value isKey
+ */
 public boolean isKey();
 
 /**
  * This method should be used as a hint about the key status of the role.
+ * @param aBoolean the boolean value
  */
 public void setKey(boolean aBoolean) ;
 /**
@@ -82,12 +90,14 @@
 /**
 * 
 * sets the upper limit of our multiplicity
+* @param upperBound the int value of the multiplicity
 */
 public void setUpper(int upperBound);
 
 /**
 * 
 * sets the lower limit of our multiplicity
+* @param lowerBound the int value if the multiplicity
 */
 public void setLower(int lowerBound);
 
@@ -96,12 +106,22 @@
 * Specifies that accessors should be generated for this relationship role.
 */
 public boolean isNavigable();
+
+/**
+ * Gets the attribute name of a given CMPAttribute
+ * @param roleAttribute the CMPAttribute
+ * @return the name of the targetAttribute
+ */
 public String getTargetAttributeName(CMPAttribute roleAttribute);
 
+/**
+ * Collects the attributes
+ *
+ */
 void reconcileAttributes();
 	/**
 	 * Method isRequired.
-	 * @return boolean
+	 * @return boolean value
 	 */
 	boolean isRequired();
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ContainerManagedEntity.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ContainerManagedEntity.java
index 2dd81c3..0e9bd21 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ContainerManagedEntity.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ContainerManagedEntity.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,63 +17,143 @@
 
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface ContainerManagedEntity extends Entity{
 
+	/**
+	 * Denotes 1.x version of the CMP Bean
+	 */
 	String VERSION_1_X = "1.x"; //$NON-NLS-1$
+	
+	/**
+	 * Denotes 2.x version of the CMP Bean
+	 */
 	String VERSION_2_X = "2.x"; //$NON-NLS-1$
+	
+	/**
+	 * 
+	 */
 	String WAS_GENERATED_STRING_KEY = "com.ibm.ws.ejbpersistence.dataaccess.GeneratedStringPK"; //$NON-NLS-1$
+	
+	/**
+	 * 
+	 */
 	String WAS_GENERATED_STRING_FIELD = "wasGenUnknownkeyValue"; //$NON-NLS-1$
+	
+	/**
+	 * Set to java.lang.Object
+	 */
 	String UNKNOWN_PRIMARY_KEY = "java.lang.Object"; //$NON-NLS-1$
+	
+	/**
+	 * Set to java.lang.String
+	 */
 	String JAVA_LANG_STRING = "java.lang.String"; //$NON-NLS-1$
+	
+	/**
+	 * 
+	 */
 	int DERIVED_FLAG_CHANGE = 301;
-public CMPAttribute addKeyAttributeName(String aName);
+	
+	/**
+	 * Create a new instance of CMPAttribute with aName and add it to the keyAttributes     
+	 * of the bean
+	 * @param aName the name of the key attribute
+	 * @return CMPAttribute
+	 */
+	public CMPAttribute addKeyAttributeName(String aName);
 
-public abstract CMPAttribute addPersistentAttribute(Field aField) ;
-public abstract CMPAttribute addPersistentAttributeName(String aName) ;
-/**
- * Return the keyAttribute with aName.
- * Creation date: (8/8/2000 9:25:27 PM)
- * @return EStructuralFeature
- * @param aName java.lang.String
- */
-CMPAttribute getKeyAttribute(String aName) ;
-/**
- * Return the persistentAttribute with aName.
- * Creation date: (8/8/2000 9:25:27 PM)
- * @return EStructuralFeature
- * @param aName java.lang.String
- */
-CMPAttribute getPersistentAttribute(String aName) ;
-/**
- * If a primary key exists, return the persistent attribute; the primary key is defined as one and only one
- * key attribute, whose type is the same as the key class
- * @deprecated - Use getPrimKeyField()
- */
-CMPAttribute getPrimaryKeyAttribute();
+	/**
+	 * Add a persistent attribute with the same name as the name for aField.
+	 * @param aField a reference of type Field
+	 * @return CMPAttribute
+	 */
+	public abstract CMPAttribute addPersistentAttribute(Field aField) ;
+	
+	/**
+	 * Create a new instance of CMPAttribute with aName and add it to the persistent attributes
+	 * @param aName the name of the persistent attribute
+	 * @return CMPAttribute
+	 */
+	public abstract CMPAttribute addPersistentAttributeName(String aName) ;
+	/**
+	 * Return the keyAttribute with aName.
+	 * Creation date: (8/8/2000 9:25:27 PM)
+	 * @return EStructuralFeature
+	 * @param aName java.lang.String
+	 */
+	CMPAttribute getKeyAttribute(String aName) ;
+	/**
+	 * Return the persistentAttribute with aName.
+	 * Creation date: (8/8/2000 9:25:27 PM)
+	 * @return EStructuralFeature
+	 * @param aName java.lang.String
+	 */
+	CMPAttribute getPersistentAttribute(String aName) ;
+	/**
+	 * If a primary key exists, return the persistent attribute; the primary key is defined as one and only one
+	 * key attribute, whose type is the same as the key class
+	 * @return a reference to the CMPAttribute
+	 * @deprecated - Use getPrimKeyField()
+	 */
+	CMPAttribute getPrimaryKeyAttribute();
 
-public boolean isContainerManagedEntity();
-public boolean isVersion1_X();
-public boolean isVersion2_X();
-public boolean isKeyAttribute(CMPAttribute anAttribute);
-/*
- * Return whether this bean represents an instance of the "unknown primary key" case
- * described in the specification.  This is identified by the primary key class
- * being specified as "java.lang.Object".
- * In order to deploy an unknown primary key bean, we must substitute a real key,
- * and add a corresponding field.
- */
-public boolean isUnknownPrimaryKey();
-public String[] listPersistentFieldNames();
+	/**
+	 * Returns true when invoked on the instance of this class
+	 * @return boolean value  
+	 */
+	public boolean isContainerManagedEntity();
+	
+	/**
+	 * Returns true if the CMP is of version 1.X
+	 * @return boolean value
+	 */
+	public boolean isVersion1_X();
+	
+	/**
+	 * Returns true if the CMP is of version 2.X
+	 * @return boolean value
+	 */
+	public boolean isVersion2_X();
+	
+	/**
+	 * Returns true if anAttribute is a key attribute of the CMP
+	 * @param anAttribute a attribute of the CMP of type CMPAttribute
+	 * @return boolean value
+	 */
+	public boolean isKeyAttribute(CMPAttribute anAttribute);
+	
+	/**
+	 * Return whether this bean represents an instance of the "unknown primary key" case
+	 * described in the specification.  This is identified by the primary key class
+	 * being specified as "java.lang.Object".
+	 * In order to deploy an unknown primary key bean, we must substitute a real key,
+	 * and add a corresponding field.
+	 * @return boolean value
+	 */
+	public boolean isUnknownPrimaryKey();
+	
+	/**
+	 * Returns the list of Persistent Field Names
+	 * @return an String array of names 
+	 */
+	public String[] listPersistentFieldNames();
+	
+	/**
+	 * Removes the attribute with the name specified in the aField from the list of persistent attributes
+	 * @param aField the Field reference
+	 * @return CMPAttribute reference
+	 */
 
-CMPAttribute removePersistentAttribute(Field aField) ;
-/**
- * Remove the persistentAttribute named aName.
- * Creation date: (8/2/2000 8:59:32 PM)
- * @param aName java.lang.String
- */
-CMPAttribute removePersistentAttribute(String aName) ;
-/**
+	CMPAttribute removePersistentAttribute(Field aField) ;
+	/**
+	 * Remove the persistentAttribute named aName.
+	 * Creation date: (8/2/2000 8:59:32 PM)
+	 * @param aName java.lang.String
+	 * @return CMPAttribute reference
+	 */
+	CMPAttribute removePersistentAttribute(String aName) ;
+	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the Version attribute
 	 * Specifies the version of an entity bean with container-managed persistence.
@@ -86,6 +166,8 @@
 
 	/**
 	* This returns the module version id. Compare with J2EEVersionConstants to determine module level
+	* @throws IllegalStateException throws this exception when an error is encountered in getting version of the CMP
+	* @return the version of CMP represented in int type 
 	*/
 	public int getCMPVersionID() throws IllegalStateException ;
 
@@ -196,20 +278,35 @@
 
 	/**
 	 * Return a List of all the available Query methods for the Home and Local Home interfaces.
+	 * @return List of Find Query Methods
 	 */
 	List getAvailableFindQueryMethods() ;
 	/**
 	 * Return a List of all the available Query methods for the Bean class.
+	 * @return List of Select Query Methods
 	 */
 	List getAvailableSelectQueryMethods();
 	/**
 	 * Return a List, sorted by signature, of all the available Query methods 
 	 * on the remote Home, local Home, or ejbSelect methods on the bean class
+	 * @return List of Query methods
 	 */
 	List getAllAvailableQueryMethods();
+	
+	/**
+	 * Returns the list of EJBExtensionFilter
+	 * @param aFilter a reference of type EJBExtensionFilter
+	 * @return List of filtered features
+	 */
 	public List getFilteredFeatures(EJBExtensionFilter aFilter);
+	
+	/**
+	 * Makes the primary Key Field proxy.
+	 *
+	 */
 	public void makePrimKeyFieldProxy();
 	/**
+	 * Gets the list of CMR Fields
 	 * @return The list of all CMR fields for this bean.
 	 */
 	public List getCMRFields();
@@ -223,6 +320,8 @@
 	 * Return a specific CommonRelationshipRole which has a named role
 	 * that is equal to <code>roleName</code>.
 	 * @see CommonRelationshipRole
+	 * @param roleName the role name 
+	 * @return a reference to CommonRelationshipRole instance
 	 */
 	public CommonRelationshipRole getRole(String roleName);
 	
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/DestinationType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/DestinationType.java
index a017f85..4b3f334 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/DestinationType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/DestinationType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface DestinationType {}
+ * @since 1.0
  */
 public final class DestinationType extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Destination Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Destination Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -116,6 +121,7 @@
 	/**
 	 * Only this class can construct instances.
 	 * <!-- begin-user-doc -->
+	 * 
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBExtensionFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBExtensionFilter.java
index abec447..e8d2102 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBExtensionFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBExtensionFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,9 +16,15 @@
  * Insert the type's description here.
  * Creation date: (11/28/2000 5:31:53 PM)
  * @author: Administrator
- */
+ * @since 1.0 */
 public interface EJBExtensionFilter {
-List filter(EnterpriseBean ejb) ;
+	
+	/**
+	 * Return a List of one of the properties using a Filter
+	 * @param ejb reference to the Enterprise Bean model
+	 * @return List
+	 */	
+	List filter(EnterpriseBean ejb) ;
 }
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBJar.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBJar.java
index a4e36ce..dbadea1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBJar.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBJar.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,13 +20,20 @@
 /**
  * The root element of the EJB deployment descriptor. It contains an optional description of the ejb-jar file; optional display name; optional small icon file name; optional large icon file
  * name; mandatory structural information about all included enterprise beans; a descriptor for container managed relationships, if any; an optional application-assembly descriptor; and an optional name of an ejb-client-jar file for the ejb-jar.
- */
+ * @since 1.0 */
 public interface EJBJar extends CompatibilityDescriptionGroup{
 
 /**
  * Return true if there are any ContainerManagedEntity beans in this jar.
+ * @return boolean value
  */
 boolean containsContainerManagedBeans() ;
+
+/**
+ * Returns true if there is security role with the name specified in the argument
+ * @param name the name of the security role
+ * @return boolean value
+ */
 public boolean containsSecurityRole(String name);
 /**
  * Return List of BeanManaged beans in this jar.
@@ -53,31 +60,43 @@
  * @return java.util.List
  */
 List getMessageDrivenBeans() ;
-	/**
-	 * @return The list of EjbRelations references
-	 * A list of ejb-relation elements, which specify the container managed relationships.
-	 */
-	public List getEjbRelations();
+/**
+ * @return The list of EjbRelations references
+ * A list of ejb-relation elements, which specify the container managed relationships.
+ */
+public List getEjbRelations();
 /**
  * Return an enterprise bean referenced by the EjbRef, if one exists.  The ejb-link value
  * of the ref must equate to a named enterprise bean contained in the jar; otherwise return
  * null
+ * @param ref reference to the EjbRef
+ * @return reference to the EnterpriseBean model
  */
 public EnterpriseBean getEnterpiseBeanFromRef(EjbRef ref);
-	public EnterpriseBean getEnterpriseBeanNamed(String ejbName);
+
+/**
+ * Return the enterprise bean model which has the bean name of ejbName
+ * @param ejbName the name of the Enterprise Bean
+ * @return reference to the EnterpriseBean model
+ */
+public EnterpriseBean getEnterpriseBeanNamed(String ejbName);
 /**
  * Return ALL EnterpriseBean(s) that are referencing @aJavaClass as a
  * home, remote, bean class, or key class.
+ * @param aJavaClass a reference of type JavaClass
+ * @return java.util.List of EnterpriseBean
  */
 List getEnterpriseBeansWithReference(JavaClass aJavaClass) ;
 /**
  * Return the *FIRST* EnterpriseBean that is referencing @aJavaClass as its
  * home, remote, bean class, or key class.
+ * @param aJavaClass a refernce of type JavaClass
+ * @return reference to EnterpriseBean model
  */
 EnterpriseBean getEnterpriseBeanWithReference(JavaClass aJavaClass) ;
 /**
  * Return List of Session beans in this jar.
- * @return java.util.List
+ * @return java.util.List of EnterpriseBean
  */
 List getSessionBeans() ;
 /**
@@ -95,10 +114,14 @@
 /**
  * Rename the security role contained in the assembly descriptor; for each enterprise bean, fix the role-link on any contained role
  * refs
+ * @param existingRoleName the old name of the Security Role
+ * @param newRoleName the new name of the Security Role
  */
 public void renameSecurityRole(String existingRoleName, String newRoleName);
 	/**
 	 *This returns the j2ee version id. Compare with J2EEVersionConstants to determine j2ee level
+	 *@throws IllegalStateException when an error is encountered while getting the version
+	 *@return the j2ee version of the Enterprise Bean in int
 	 */
 	public int getJ2EEVersionID() throws IllegalStateException ;
 
@@ -147,6 +170,8 @@
 
 	/**
 	 * This returns the module version id.  Compare with J2EEVersionConstants to determine module level
+	 * @throws IllegalStateException when an error is encountered while getting the spec version of the bean 
+	 * @return the spec version of the EnterpriseBean, 11, 20, 21 
 	 */
 	public int getVersionID() throws IllegalStateException ;
 
@@ -168,7 +193,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the AssemblyDescriptor reference
+	 * @param value The new value of the AssemblyDescriptor reference
 	 */
 	void setAssemblyDescriptor(AssemblyDescriptor value);
 
@@ -196,30 +221,39 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the RelationshipList reference
+	 * @param value The new value of the RelationshipList reference
 	 */
 	void setRelationshipList(Relationships value);
 
 	/**
 	 * Return the EJBRelationshipRole with the same name as <code>aRoleName</code>
 	 * that has <code>sourceCMP</code> as its source bean.
+	 * @param aRoleName the role name
+	 * @param sourceCMP reference to ContainerManagedEntity
+	 * @return a reference to EJBRelationshipRole
 	 */
 	EJBRelationshipRole getRelationshipRole(String aRoleName, ContainerManagedEntity sourceCMP) ;
 	
 	/**
 	 * Return the first EJBRelation with the same name as <code>aRelationName</code>.
+	 * @param aRelationName the name of the relation
+	 * @return a reference to EJBRelation
 	 */
 	EJBRelation getEJBRelation(String aRelationName) ;
 	
 	/**
 	 * Return all EJBRelation objects that have an EJBRelationshipRole with a
 	 * source EJB of <code>cmp</code>.
+	 * @param cmp reference to ContainerManagedEntity
+	 * @return List of EJBRelation
 	 */
 	List getEJBRelationsForSource(ContainerManagedEntity cmp);
 	
 	/**
 	 * Return all EJBRelationshipRole objects that have an EJBRelationshipRole with a
 	 * type EJB of <code>cmp</code>.
+	 * @param cmp reference to ContainerManagedEntit
+	 * @return List of EJBRelationshipRole
 	 */
 	List getEJBRelationshipRolesForType(ContainerManagedEntity cmp) ;
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBMethodCategory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBMethodCategory.java
index 11ce7d0..a42f70a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBMethodCategory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBMethodCategory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The valid EJB method category names are: EJBHOMEMETHOD, EJBCREATEMETHOD, EJBFINDERMETHOD, EJBREMOTEMETHOD.
- */
+ * @since 1.0 */
 public interface EJBMethodCategory extends EObject{
 	//EJBMethodCategory
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelation.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelation.java
index 16da0b8..63bd7ae 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelation.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -22,7 +22,7 @@
  * @migration EJB1.1 Moved from ejbext::EjbRelationshipRole contained under ejbext::EJBJarExtension
  * @migration EJB1.1 added optional attribute, description:String
  * @migration EJB1.1 added optional attribute, name:String (May have been inherited from EObject previously)
- */
+ * @since 1.0 */
 public interface EJBRelation extends EObject,CommonRelationship{
 
 boolean containsRelationshipRole(EJBRelationshipRole aRole) ;
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelationshipRole.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelationshipRole.java
index 589d79e..8a00cfa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelationshipRole.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBRelationshipRole.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -34,7 +34,7 @@
  *     <//relationship-role-source>
  *   <//ejb-relationship-role>
  * ...
- */
+ * @since 1.0 */
 public interface EJBRelationshipRole extends EObject,CommonRelationshipRole{
 
 /**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBResource.java
index 9bf3a8d..7ea1b4b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EJBResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,7 @@
 
 /**
  * @author schacher
- */
+ * @since 1.0 */
 public interface EJBResource extends XMLResource {
 	EJBJar getEJBJar();
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbFactory.java
index 259acf4..824abef 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 import org.eclipse.jem.java.Method;
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface EjbFactory extends EFactory{
 
 	/**
@@ -25,9 +25,26 @@
 	 */
 	EjbFactory eINSTANCE = new org.eclipse.jst.j2ee.ejb.internal.impl.EjbFactoryImpl();
 
-MethodElement createMethodElement(String aSignature) ;
-MethodElement createMethodElementFrom(Method method) ;
-MethodElement createMethodElementFrom(java.lang.reflect.Method method) ;
+	/**
+	 * Creates and returns a reference to a MethodElement from the given signature
+	 * @param aSignature the signature of the MethodElement
+	 * @return MethodElement reference
+	 */
+	MethodElement createMethodElement(String aSignature) ;
+	
+	/**
+	 * Creates and returns a reference to a MethodElement from the given reference of a Method
+	 * @param method the reference of a Method
+	 * @return MethodElement reference
+	 */
+	MethodElement createMethodElementFrom(Method method) ;
+	
+	/**
+	 * Creates and returns a reference to a MethodElement from the given reference of a java.lang.reflect.Method
+	 * @param method reference of a java.lang.reflect.Method
+	 * @return MethodElement reference
+	 */
+	MethodElement createMethodElementFrom(java.lang.reflect.Method method) ;
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return MethodPermission value
@@ -167,7 +184,12 @@
 	EJBMethodCategory createEJBMethodCategory();
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @generated This field/method will be replaced during code generation.
+	 * @return EjbPackage
 	 */
 	EjbPackage getEjbPackage();
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementComparator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementComparator.java
index ea8ba2a..0a1e928 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementComparator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementComparator.java
@@ -12,6 +12,10 @@
 
 import java.util.Comparator;
 
+/**
+ * @since 1.0
+ */
+
 public class EjbMethodElementComparator implements Comparator {
 	static final int HOME = MethodElementKind.HOME;
 	static final int REMOTE = MethodElementKind.REMOTE;
@@ -26,8 +30,12 @@
 		super();
 	}
 
-	/*
+	/**
+	 * Compares two arguments for order.
 	 * @see Comparator#compare(Object, Object)
+	 *@param o1 the first object to be compared
+	 *@param 02 the second object to be compared
+	 *@return a negative integer, zero, or a positive integer
 	 */
 	public int compare(Object o1, Object o2) {
 		return compare((MethodElement) o1, (MethodElement) o2);
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementHelper.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementHelper.java
index a5022e2..7439363 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbMethodElementHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbPackage.java
index 2d7dd7b..90a9633 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EjbPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,15 @@
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.jst.j2ee.common.CommonPackage;
-
+/**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	@since 1.0
+ */
 public interface EjbPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EnterpriseBean.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EnterpriseBean.java
index 7cc5da2..641d59f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EnterpriseBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/EnterpriseBean.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -31,7 +31,7 @@
  * In this light, even Session Beans can have associations and properties implemented by their bean.  For example, it would be meaningful to describe associations from a Session to the Entities which it uses to perform its work.
  * @extends ENamedElement
  *
- **/
+ ** @since 1.0 */
 public interface EnterpriseBean extends JNDIEnvRefsGroup, ENamedElement{
 
 /**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Entity.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Entity.java
index 996de93..30a9ad3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Entity.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Entity.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,7 +20,7 @@
  * The optional query elements must be present if the persistence-type is Container and the cmp-version is 2.x and query methods other than findByPrimaryKey have been defined for the entity bean.
  * The other elements that are optional are "optional" in the sense that they are omitted if the lists represented by them are empty. At least one cmp-field element must be present in the descriptor if
  * the entity's persistence-type is Container and the cmp-version is 1.x, and none must not be present if the entity's persistence-type is Bean.
- */
+ * @since 1.0 */
 public interface Entity extends EnterpriseBean{
 
 public String getPrimaryKeyName();
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ExcludeList.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ExcludeList.java
index 2d0ec27..e8df1f6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ExcludeList.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ExcludeList.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * 
  * If the method permission relation contains methods that are in the exclude list, the Deployer must consider those methods to be uncallable.
 
- */
+ * @since 1.0 */
 public interface ExcludeList extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/IRoleShapeStrategy.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/IRoleShapeStrategy.java
index 5b42cfd..306edf0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/IRoleShapeStrategy.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/IRoleShapeStrategy.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,7 +20,7 @@
  * Insert the type's description here.
  * Creation date: (11/6/2000 11:40:16 AM)
  * @author: Administrator
- */
+ * @since 1.0 */
 public interface IRoleShapeStrategy {
 	String ATTRIBUTE_NAME_JOINER = "_"; //$NON-NLS-1$
 	String ROLE_GET_PREFIX = "get"; //$NON-NLS-1$
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDriven.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDriven.java
index bd48318..a84ecc2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDriven.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDriven.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,7 +16,7 @@
 
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface MessageDriven extends EnterpriseBean{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -147,7 +147,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Destination reference
+	 * @param value The new value of the Destination reference
 	 */
 	void setDestination(MessageDrivenDestination value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDrivenDestination.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDrivenDestination.java
index b632dfb..e23e2c5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDrivenDestination.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MessageDrivenDestination.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 
 /**
  * The message-driven-destination element provides advice to the Deployer as to whether a message-driven bean is intended for a Queue or a Topic. The declaration consists of: the type of the message-driven bean's intended destination and an optional declaration of whether a durable or non-durable subscription should be used if the destination-type is javax.jms.Topic.
- */
+ * @since 1.0 */
 public interface MessageDrivenDestination extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -120,7 +120,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Bean reference
+	 * @param value The new value of the Bean reference
 	 */
 	void setBean(MessageDriven value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElement.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElement.java
index 1570514..ed70544 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElement.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElement.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -151,7 +151,7 @@
  * 			<//method-params>
  * 		<//method>
 
- */
+ * @since 1.0 */
 public interface MethodElement extends EObject{
 
 	public static final String RIGHT_PAREN = "("; //$NON-NLS-1$
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElementKind.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElementKind.java
index 6071f4f..f938210 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElementKind.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodElementKind.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface MethodElementKind {}
+ * @since 1.0
  */
 public final class MethodElementKind extends AbstractEnumerator{
 	/**
@@ -168,6 +169,8 @@
 	/**
 	 * Returns the '<em><b>Method Element Kind</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -184,6 +187,8 @@
 	/**
 	 * Returns the '<em><b>Method Element Kind</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodPermission.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodPermission.java
index 3d58997..fd6953f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodPermission.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodPermission.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,7 @@
 
 /**
  * The method-permission element specifies that one or more security roles are allowed to invoke one or more enterprise bean methods. The method-permission element consists of an optional description, a list of security role names, and a list of method elements.  The security roles used in the method-permission element must be defined in the security-role element of the deployment descriptor, and the methods must be methods defined in the enterprise bean's remote and//or home interfaces.
- */
+ * @since 1.0 */
 public interface MethodPermission extends EObject{
 
 /**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodTransaction.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodTransaction.java
index 1464f07..abaa7c8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodTransaction.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MethodTransaction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,7 @@
 import org.eclipse.jem.java.Method;
 /**
  * Specifies how the container must manage transaction scopes for the enterprise bean's method invocations.  It consists of an optional description, a list of method elements, and a transaction attribute.The transaction attribute is to be applied to all the specified methods.
- */
+ * @since 1.0 */
 public interface MethodTransaction extends EObject{
 
 /**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MultiplicityKind.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MultiplicityKind.java
index 1a365e8..3a088b3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MultiplicityKind.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/MultiplicityKind.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface MultiplicityKind {}
+ * @since 1.0
  */
 public final class MultiplicityKind extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Multiplicity Kind</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Multiplicity Kind</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Query.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Query.java
index 56f62fe..2e859b3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Query.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Query.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,10 +16,19 @@
 /**
  * The query element is used to specify a finder or select query. It contains an optional description of the query; the specification of the finder or select method it is used by; a specification of the return type mapping, if any, if the query is for a select method; and the EJB QL query string that defines the query. Queries that are expressible in EJB QL must use the ejb-ql element to specify the query. If a query
  * is not expressible in EJB QL, the description element should be used to describe the semantics of the query and the ejb-ql element should be empty.
- */
+ * @since 1.0 */
 public interface Query extends EObject{
 
+	/**
+	 * Returns boolean value for ReturnTypeMapping, checks if it is of type ReturnTypeMapping.LOCAL
+	 * @return boolean value
+	 */
 	public boolean isLocalResultMapping();
+	
+	/**
+	 * Returns boolean value for ReturnTypeMapping, checks if it is of type ReturnTypeMapping.REMOTE
+	 * @return boolean value
+	 */
 	public boolean isRemoteResultMapping();
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -153,7 +162,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the QueryMethod reference
+	 * @param value The new value of the QueryMethod reference
 	 */
 	void setQueryMethod(QueryMethod value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/QueryMethod.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/QueryMethod.java
index 64980f3..d1ffa85 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/QueryMethod.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/QueryMethod.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,9 +13,17 @@
 import org.eclipse.jem.java.JavaClass;
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface QueryMethod extends MethodElement{
+	
+	/**
+	 * 
+	 */
 	public static final String SELECT_PREFIX = "ejbSelect"; //$NON-NLS-1$
+	
+	/**
+	 * 
+	 */
 	public static final String FIND_PREFIX = "find"; //$NON-NLS-1$
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -25,7 +33,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Query reference
+	 * @param value The new value of the Query reference
 	 */
 	void setQuery(Query value);
 
@@ -35,6 +43,7 @@
 	 * it if a find both home interfaces will be returned if they exist.
 	 * 
 	 * May return null.
+	 * @return array of JavaClass
 	 */
 	JavaClass[] getClientTypeJavaClasses() ;
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Relationships.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Relationships.java
index 5e48967..5e36b53 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Relationships.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Relationships.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The relationships describes the relationships in which entity beans with container managed persistence participate. The relationships element contains an optional description; and a list of ejb-relation elements, which specify the container managed relationships.
- */
+ * @since 1.0 */
 public interface Relationships extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -43,7 +43,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the EjbJar reference
+	 * @param value The new value of the EjbJar reference
 	 */
 	void setEjbJar(EJBJar value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ReturnTypeMapping.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ReturnTypeMapping.java
index 57c575c..1764aee 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ReturnTypeMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/ReturnTypeMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface ReturnTypeMapping {}
+ * @since 1.0
  */
 public final class ReturnTypeMapping extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Return Type Mapping</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Return Type Mapping</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/RoleSource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/RoleSource.java
index 32ba5ce..499950f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/RoleSource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/RoleSource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 /**
  * Designates the source of a role that participates in a relationship. A relationship-role-source element uniquely identifies an entity bean.
  * @invariant The content of each role-source element shall refer to an existing entity bean, entity bean reference.
- */
+ * @since 1.0 */
 public interface RoleSource extends EObject{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -37,7 +37,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Role reference
+	 * @param value The new value of the Role reference
 	 */
 	void setRole(EJBRelationshipRole value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Session.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Session.java
index 90a22d1..c1017b0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Session.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/Session.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,7 @@
 /**
  * The session element declares an session bean. The declaration consists of: an optional description; optional display name; optional small icon file name; optional large icon file name; a name assigned
  * to the enterprise bean in the deployment description; the names of the session bean's home and remote interfaces, if any; the names of the session bean's local home and local interfaces, if any; the session bean's implementation class; the session bean's state management type; the session bean's transaction management type; an optional declaration of the bean's environment entries; an optional declaration of the bean's EJB references; an optional declaration of the bean's local EJB references; an optional declaration of the security role references; an optional declaration of the security identity to be used for the execution of the bean's methods; an optional declaration of the bean's resource manager connection factory references; and an optional declaration of the bean's resource environment references. The elements that are optional are "optional" in the sense that they are omitted when if lists represented by them are empty.
- */
+ * @since 1.0 */
 public interface Session extends EnterpriseBean{
 	/**
 	 * @generated This field/method will be replaced during code generation 
@@ -144,15 +144,18 @@
 
 	/**
 	 * Helper method to set Java Class name via String
+	 * @param serviceEndpointName the name of the ServiceEndpoint
 	 */
 	public void setServiceEndpointName(String serviceEndpointName);
 	/**
 	 * Return true if this Session bean has a service endpoint interface
 	 * interface.
+	 * @return boolean value
 	 */
 	public boolean hasServiceEndpoint() ;
 	/**
 	 * Helper method to get Java Class name 
+	 * @return String value
 	 */
 	public String getServiceEndpointName();
 	
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SessionType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SessionType.java
index 539add5..38f5447 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SessionType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SessionType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface SessionType {}
+ * @since 1.0
  */
 public final class SessionType extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Session Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Session Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SubscriptionDurabilityKind.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SubscriptionDurabilityKind.java
index f866a5f..9ae5fd4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SubscriptionDurabilityKind.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/SubscriptionDurabilityKind.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface SubscriptionDurabilityKind {}
+ * @since 1.0
  */
 public final class SubscriptionDurabilityKind extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Subscription Durability Kind</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Subscription Durability Kind</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionAttributeType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionAttributeType.java
index ddc5ded..e629727 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionAttributeType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionAttributeType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface TransactionAttributeType {}
+ * @since 1.0
  */
 public final class TransactionAttributeType extends AbstractEnumerator{
 	/**
@@ -162,6 +163,8 @@
 	/**
 	 * Returns the '<em><b>Transaction Attribute Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -178,6 +181,8 @@
 	/**
 	 * Returns the '<em><b>Transaction Attribute Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionType.java
index 43fe0a3..078d90d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/TransactionType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface TransactionType {}
+ * @since 1.0
  */
 public final class TransactionType extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Transaction Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -102,6 +105,8 @@
 	/**
 	 * Returns the '<em><b>Transaction Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRelationshipRoleAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRelationshipRoleAttributeFilter.java
index 7a7734a..a05f6ee 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRelationshipRoleAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRelationshipRoleAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRequiredRelationshipRoleFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRequiredRelationshipRoleFilter.java
index e1aab6c..765ec1e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRequiredRelationshipRoleFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AbstractRequiredRelationshipRoleFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigImpl.java
index e722c7e..59e73fc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigPropertyImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigPropertyImpl.java
index 73edfb8..7f07868 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigPropertyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ActivationConfigPropertyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AssemblyDescriptorImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AssemblyDescriptorImpl.java
index 3516577..0b851c2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AssemblyDescriptorImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/AssemblyDescriptorImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMPAttributeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMPAttributeImpl.java
index 9e36be1..14032b8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMPAttributeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMPAttributeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMRFieldImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMRFieldImpl.java
index fa57795..8ef01ef 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMRFieldImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/CMRFieldImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityFilter.java
index d694200..206558b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityImpl.java
index 944a36e..85bff19 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ContainerManagedEntityImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJB20FlattenedRoleShapeStrategy.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJB20FlattenedRoleShapeStrategy.java
index fcaaff5..f0920df 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJB20FlattenedRoleShapeStrategy.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJB20FlattenedRoleShapeStrategy.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarImpl.java
index 20d6693..86cc7eb 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarResourceFactory.java
index ffe8235..1f13571 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBJarResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBMethodCategoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBMethodCategoryImpl.java
index 04ff8c8..03d4158 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBMethodCategoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBMethodCategoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationImpl.java
index 2689fa5..535584b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationshipRoleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationshipRoleImpl.java
index 686a531..5cbb370 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationshipRoleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBRelationshipRoleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBResourceImpl.java
index b6bbcb9..3791abf 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EJBResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbFactoryImpl.java
index 51dfb4d..87ed435 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbPackageImpl.java
index a70a49d..70ed5a7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EjbPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EnterpriseBeanImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EnterpriseBeanImpl.java
index 4b07778..95870b1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EnterpriseBeanImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EnterpriseBeanImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -337,6 +337,19 @@
 		result.addAll(getAvailableLocalMethodElements());
 		result.addAll(getAvailableServiceEndpointMethodElements());
 		result.addAll(getAvailableUnspecifiedMethodElements());
+		
+		List list = getEjbClass().getImplementsInterfaces();
+		Iterator it = list.iterator();
+		while( it.hasNext()){
+			JavaClass  interfaceClass = (JavaClass)it.next();
+			String interfaceName = interfaceClass.getQualifiedName();
+			if( !interfaceName.equals("javax.ejb.MessageDrivenBean") && 
+					!interfaceName.equals("javax.ejb.EntityBean")&&
+					!interfaceName.equals("javax.ejb.SessionBean")){
+				result.addAll( getAvailableMethodElements(interfaceClass, MethodElementKind.UNSPECIFIED_LITERAL));
+			}
+		}
+		
 		unionMethodElements(result, getExistingMethodElements(refObject));
 		Collections.sort(result, comparator);
 		return result;
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EntityImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EntityImpl.java
index 41fd521..21b6cb3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EntityImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/EntityImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ExcludeListImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ExcludeListImpl.java
index eb5c595..0877ac7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ExcludeListImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ExcludeListImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleAttributeFilter.java
index 02e65df..19436c1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleFilter.java
index a85904b..01b7bea 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/KeyRelationshipRoleFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalKeyAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalKeyAttributeFilter.java
index 12dd55c..6d80bfc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalKeyAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalKeyAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalModelledPersistentAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalModelledPersistentAttributeFilter.java
index 192ba7c..189535d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalModelledPersistentAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalModelledPersistentAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalOppositeRelationshipRoleFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalOppositeRelationshipRoleFilter.java
index 4bbc466..0348357 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalOppositeRelationshipRoleFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalOppositeRelationshipRoleFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalPersistentAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalPersistentAttributeFilter.java
index 36e0c02..b1c55ba 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalPersistentAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalPersistentAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleAttributeFilter.java
index 884d538..79ee214 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleKeyAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleKeyAttributeFilter.java
index 9a91b19..b9a5b7d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleKeyAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/LocalRelationshipRoleKeyAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenDestinationImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenDestinationImpl.java
index b177851..7c82e6f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenDestinationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenDestinationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenImpl.java
index fd7033e..ef45731 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MessageDrivenImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodElementImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodElementImpl.java
index ad7444b..9ce764b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodElementImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodElementImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodPermissionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodPermissionImpl.java
index a983f01..5107e44 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodPermissionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodPermissionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodTransactionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodTransactionImpl.java
index a6a4201..a730458 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodTransactionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/MethodTransactionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledKeyAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledKeyAttributeFilter.java
index 625610a..aef838d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledKeyAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledKeyAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledPersistentAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledPersistentAttributeFilter.java
index aa8c7b4..e68e8d0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledPersistentAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/ModelledPersistentAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/NonKeyRequiredRoleFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/NonKeyRequiredRoleFilter.java
index 6363a43..e31f73c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/NonKeyRequiredRoleFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/NonKeyRequiredRoleFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryImpl.java
index 1e7620c..b447f79 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryMethodImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryMethodImpl.java
index df77e20..51ca365 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryMethodImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/QueryMethodImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipRoleAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipRoleAttributeFilter.java
index 5e5dbaf..c6fb84d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipRoleAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipRoleAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipsImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipsImpl.java
index 586fca3..cb40d59 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipsImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RelationshipsImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredLocalRelationshipRoleFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredLocalRelationshipRoleFilter.java
index fc71fc2..f67cb99 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredLocalRelationshipRoleFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredLocalRelationshipRoleFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredRelationshipRoleFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredRelationshipRoleFilter.java
index 2248d72..1404f3c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredRelationshipRoleFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RequiredRelationshipRoleFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleShapeStrategy.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleShapeStrategy.java
index e04cdcc..4195c1c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleShapeStrategy.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleShapeStrategy.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleSourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleSourceImpl.java
index adb5775..7008bc4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleSourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/RoleSourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SessionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SessionImpl.java
index 21f757e..dbdc4cc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SessionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SessionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SupertypeCMPAttributeFilter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SupertypeCMPAttributeFilter.java
index dc77cd6..7e203cd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SupertypeCMPAttributeFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/impl/SupertypeCMPAttributeFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPFieldDescriptor.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPFieldDescriptor.java
index 0a4ae9e..8c6d067 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPFieldDescriptor.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPFieldDescriptor.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPHelper.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPHelper.java
index 4c38222..06c45af 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPKeySynchronizationAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPKeySynchronizationAdapter.java
index 38084bb..b04238c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPKeySynchronizationAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CMPKeySynchronizationAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CommonRelationshipAttributeMaintenanceAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CommonRelationshipAttributeMaintenanceAdapter.java
index ae49f80..4ad56a3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CommonRelationshipAttributeMaintenanceAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/CommonRelationshipAttributeMaintenanceAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/ConvertedEJBAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/ConvertedEJBAdapter.java
index 41e2b03..d2ac77f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/ConvertedEJBAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/ConvertedEJBAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBAttributeMaintenanceFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBAttributeMaintenanceFactoryImpl.java
index 72468f1..ca55591 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBAttributeMaintenanceFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBAttributeMaintenanceFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBRelationAttributeMaintenanceAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBRelationAttributeMaintenanceAdapter.java
index 38d8a0c..ebcf718 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBRelationAttributeMaintenanceAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EJBRelationAttributeMaintenanceAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbAdapterFactory.java
index 29ebdf1..43614fe 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,8 +13,6 @@
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EModelElement;
 import org.eclipse.emf.ecore.ENamedElement;
 import org.eclipse.emf.ecore.EObject;
@@ -135,18 +133,12 @@
 		public Object caseEJBMethodCategory(EJBMethodCategory object) {
 			return createEJBMethodCategoryAdapter();
 		}
-		public Object caseEClass(EClass object) {
-			return createEClassAdapter();
-		}
 		public Object caseEAttribute(EAttribute object) {
 			return createEAttributeAdapter();
 		}
 		public Object caseEStructuralFeature(EStructuralFeature object) {
 			return createEStructuralFeatureAdapter();
 		}
-		public Object caseEClassifier(EClassifier object) {
-			return createEClassifierAdapter();
-		}
 		public Object caseEModelElement(EModelElement object) {
 			return createEModelElementAdapter();
 		}
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbSwitch.java
index 9d9cd2e..4ea702a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/EjbSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/MethodElementHelper.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/MethodElementHelper.java
index 6a346d1..768ec9c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/MethodElementHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/MethodElementHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/RelationshipsAttributeMaintenanceAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/RelationshipsAttributeMaintenanceAdapter.java
index 492114f..2a0ae88 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/RelationshipsAttributeMaintenanceAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/ejb/internal/util/RelationshipsAttributeMaintenanceAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEConstants.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEConstants.java
index ac78bdd..5aa2fe4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -29,6 +29,7 @@
 	String META_INF						=	"META-INF"; //$NON-NLS-1$
 	/** "WEB-INF"  															*/
 	String WEB_INF						= 	"WEB-INF"; //$NON-NLS-1$
+	String WEB_INF_CLASSES				=	"WEB-INF/classes"; //$NON-NLS-1$
 	/** "ALT-INF"  															*/
 	String ALT_INF						= 	"ALT-INF"; //$NON-NLS-1$
 	//Application client info
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEInit.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEInit.java
index 2b584ce..b8a4ddc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEInit.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEInit.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEMultiStatus.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEMultiStatus.java
index b579920..11f91db 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEMultiStatus.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEMultiStatus.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EESpecificationConstants.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EESpecificationConstants.java
index 9c6dbfe..6136035 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EESpecificationConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EESpecificationConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,22 +17,22 @@
 	String J2EE_VERSION_1_3 = "J2EE_1.3";  //$NON-NLS-1$
 	String J2EE_VERSION_1_4 = "J2EE_1.4";  //$NON-NLS-1$
 
-	String DEFAULT_COMPLETED_STATUS_MSG = MOFJ2EEResourceHandler.getString("DEFAULT_COMPLETED_STATUS_MSG"); //$NON-NLS-1$
-	String DEFAULT_NOT_NEEDED_STATUS_MSG = MOFJ2EEResourceHandler.getString("DEFAULT_NOT_NEEDED_STATUS_MSG"); //$NON-NLS-1$
-	String DEFAULT_NOT_POSSIBLE_STATUS_MSG = MOFJ2EEResourceHandler.getString("DEFAULT_NOT_POSSIBLE_STATUS_MSG"); //$NON-NLS-1$
-	String DEFAULT_ERROR_STATUS_MSG = MOFJ2EEResourceHandler.getString("DEFAULT_ERROR_STATUS_MSG"); //$NON-NLS-1$
+	String DEFAULT_COMPLETED_STATUS_MSG = MOFJ2EEResourceHandler.DEFAULT_COMPLETED_STATUS_MSG; 
+	String DEFAULT_NOT_NEEDED_STATUS_MSG = MOFJ2EEResourceHandler.DEFAULT_NOT_NEEDED_STATUS_MSG; 
+	String DEFAULT_NOT_POSSIBLE_STATUS_MSG = MOFJ2EEResourceHandler.DEFAULT_NOT_POSSIBLE_STATUS_MSG; 
+	String DEFAULT_ERROR_STATUS_MSG = MOFJ2EEResourceHandler.DEFAULT_ERROR_STATUS_MSG; 
 	
-	String REMOVED_LOCAL_CLIENT_MSG = MOFJ2EEResourceHandler.getString("REMOVED_LOCAL_CLIENT_MSG"); //$NON-NLS-1$
-	String REMOVED_ACCESS_INTENTS_MSG = MOFJ2EEResourceHandler.getString("REMOVED_ACCESS_INTENTS_MSG"); //$NON-NLS-1$
-	String REMOVED_ISOLATION_LEVELS_MSG = MOFJ2EEResourceHandler.getString("REMOVED_ISOLATION_LEVELS_MSG"); //$NON-NLS-1$
-	String CONVERTED_FINDER_MSG = MOFJ2EEResourceHandler.getString("CONVERTED_FINDER_MSG"); //$NON-NLS-1$
-	String UNNAMED_EJB = MOFJ2EEResourceHandler.getString("UNNAMED_EJB"); //$NON-NLS-1$
-	String CONVERTED_QUERY_DESCRIPTION = MOFJ2EEResourceHandler.getString("CONVERTED_QUERY_DESCRIPTION"); //$NON-NLS-1$
-	String MIGRATED_DEFAULT_DATASOURCE_JAR_MSG = MOFJ2EEResourceHandler.getString("MIGRATED_DEFAULT_DATASOURCE_JAR_MSG"); //$NON-NLS-1$
-	String MIGRATED_DEFAULT_DATASOURCE_MSG 	   = MOFJ2EEResourceHandler.getString("MIGRATED_DEFAULT_DATASOURCE_MSG"); //$NON-NLS-1$
-	String ERROR_TEXT = MOFJ2EEResourceHandler.getString("ERROR"); //$NON-NLS-1$
-	String WARNING_TEXT = MOFJ2EEResourceHandler.getString("WARNING"); //$NON-NLS-1$
-	String INFO_TEXT = MOFJ2EEResourceHandler.getString("INFO"); //$NON-NLS-1$
+	String REMOVED_LOCAL_CLIENT_MSG = MOFJ2EEResourceHandler.REMOVED_LOCAL_CLIENT_MSG; 
+	String REMOVED_ACCESS_INTENTS_MSG = MOFJ2EEResourceHandler.REMOVED_ACCESS_INTENTS_MSG; 
+	String REMOVED_ISOLATION_LEVELS_MSG = MOFJ2EEResourceHandler.REMOVED_ISOLATION_LEVELS_MSG; 
+	String CONVERTED_FINDER_MSG = MOFJ2EEResourceHandler.CONVERTED_FINDER_MSG; 
+	String UNNAMED_EJB = MOFJ2EEResourceHandler.UNNAMED_EJB; 
+	String CONVERTED_QUERY_DESCRIPTION = MOFJ2EEResourceHandler.CONVERTED_QUERY_DESCRIPTION; 
+	String MIGRATED_DEFAULT_DATASOURCE_JAR_MSG = MOFJ2EEResourceHandler.MIGRATED_DEFAULT_DATASOURCE_JAR_MSG; 
+	String MIGRATED_DEFAULT_DATASOURCE_MSG 	   = MOFJ2EEResourceHandler.MIGRATED_DEFAULT_DATASOURCE_MSG; 
+	String ERROR_TEXT = MOFJ2EEResourceHandler.ERROR; 
+	String WARNING_TEXT = MOFJ2EEResourceHandler.WARNING; 
+	String INFO_TEXT = MOFJ2EEResourceHandler.INFO; 
 }
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEStatus.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEStatus.java
index ef4116e..3b9b2bd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEStatus.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEStatus.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEVersionConstants.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEVersionConstants.java
index b9e776b..ed8bfd3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEVersionConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/J2EEVersionConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/MOFJ2EEResourceHandler.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/MOFJ2EEResourceHandler.java
index c39d9eb..41d839a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/MOFJ2EEResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/MOFJ2EEResourceHandler.java
@@ -1,57 +1,49 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
- * IBM Corporation - initial API and implementation
+ *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-public class MOFJ2EEResourceHandler {
+public final class MOFJ2EEResourceHandler extends NLS {
 
-	private static ResourceBundle fgResourceBundle;
+	private static final String BUNDLE_NAME = "mofj2ee";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("mofj2ee");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private MOFJ2EEResourceHandler() {
+		// Do not instantiate
 	}
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle= getResourceBundle();
-		}
-		
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		} 
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-		
+
+	public static String Stack_trace_of_nested_exce;
+	public static String ERROR;
+	public static String WARNING;
+	public static String INFO;
+	public static String DEFAULT_COMPLETED_STATUS_MSG;
+	public static String DEFAULT_NOT_NEEDED_STATUS_MSG;
+	public static String DEFAULT_NOT_POSSIBLE_STATUS_MSG;
+	public static String DEFAULT_ERROR_STATUS_MSG;
+	public static String REMOVED_LOCAL_CLIENT_MSG;
+	public static String REMOVED_ACCESS_INTENTS_MSG;
+	public static String REMOVED_ISOLATION_LEVELS_MSG;
+	public static String CONVERTED_FINDER_MSG;
+	public static String UNNAMED_EJB;
+	public static String CONVERTED_QUERY_DESCRIPTION;
+	public static String MIGRATED_DEFAULT_DATASOURCE_JAR_MSG;
+	public static String MIGRATED_DEFAULT_DATASOURCE_MSG;
+	public static String J2EE_VERSION_NULL_ERROR;
+	public static String J2EE_VERSION_PROXY_ERROR;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, MOFJ2EEResourceHandler.class);
 	}
-public static String getString(String key, Object[] args) {
 
-	try {return MessageFormat.format(getString(key), args);}
-	catch (IllegalArgumentException e) {return getString(key);}
-
-}
-}
-
-
+	public static String getString(String key, Object[] args) {
+		return NLS.bind(key, args);
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedException.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedException.java
index 8ed1152..0041a56 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedException.java
@@ -1,15 +1,14 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal;
-import org.eclipse.jst.j2ee.internal.xml.J2EEXMLResourceHandler;
 
 
 
@@ -64,7 +63,7 @@
 public void printStackTrace(java.io.PrintStream s) {
 	if (nestedException != null) {
 		s.println(this);
-		s.println(J2EEXMLResourceHandler.getString("Stack_trace_of_nested_exce")); //$NON-NLS-1$ = "Stack trace of nested exception:"
+		s.println(MOFJ2EEResourceHandler.Stack_trace_of_nested_exce); // = "Stack trace of nested exception:"
 		nestedException.printStackTrace(s);
 	} else {
 		super.printStackTrace(s);
@@ -77,7 +76,7 @@
 public void printStackTrace(java.io.PrintWriter s) {
 	if (nestedException != null) {
 		s.println(this);
-		s.println(J2EEXMLResourceHandler.getString("Stack_trace_of_nested_exce")); //$NON-NLS-1$ = "Stack trace of nested exception:"
+		s.println(MOFJ2EEResourceHandler.Stack_trace_of_nested_exce); // = "Stack trace of nested exception:"
 		nestedException.printStackTrace(s);
 	} else {
 		super.printStackTrace(s);
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedRuntimeException.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedRuntimeException.java
index 1c0019e..5949505 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedRuntimeException.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/WrappedRuntimeException.java
@@ -1,21 +1,24 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal;
 
-import org.eclipse.jst.j2ee.internal.xml.J2EEXMLResourceHandler;
 
 
 
 
 public class WrappedRuntimeException extends RuntimeException implements IWrappedException {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -8926753082721271021L;
 	/** The exception which necessitated this runtime exception, if one exists */
 	protected Exception nestedException;
 public WrappedRuntimeException() {
@@ -64,7 +67,7 @@
 public void printStackTrace(java.io.PrintStream s) {
 	if (nestedException != null) {
 		s.println(this);
-		s.println(J2EEXMLResourceHandler.getString("Stack_trace_of_nested_exce")); //$NON-NLS-1$ = "Stack trace of nested exception:"
+		s.println(MOFJ2EEResourceHandler.Stack_trace_of_nested_exce); // = "Stack trace of nested exception:"
 		nestedException.printStackTrace(s);
 	} else {
 		super.printStackTrace(s);
@@ -77,7 +80,7 @@
 public void printStackTrace(java.io.PrintWriter s) {
 	if (nestedException != null) {
 		s.println(this);
-		s.println(J2EEXMLResourceHandler.getString("Stack_trace_of_nested_exce")); //$NON-NLS-1$ = "Stack trace of nested exception:"
+		s.println(MOFJ2EEResourceHandler.Stack_trace_of_nested_exce); // = "Stack trace of nested exception:"
 		nestedException.printStackTrace(s);
 	} else {
 		super.printStackTrace(s);
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEVersionResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEVersionResource.java
index f67c66d..b791f56 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEVersionResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEVersionResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResource.java
index d5db0a3..600158a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResourceFactory.java
index c7308d4..c3562d2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/J2EEXMIResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/XMLResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/XMLResource.java
index c5d4ce1..d0cb95b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/XMLResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/common/XMLResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ApplicationTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ApplicationTranslator.java
index 75c07b2..6385efc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ApplicationTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ApplicationTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ModuleTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ModuleTranslator.java
index 4029ced..1ffd1e9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ModuleTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/application/ModuleTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/client/ApplicationClientTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/client/ApplicationClientTranslator.java
index 8d1a737..76f1f6e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/client/ApplicationClientTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/client/ApplicationClientTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/BooleanTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/BooleanTranslator.java
index 39eeb7d..f460b86 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/BooleanTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/BooleanTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/CommonTranslators.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/CommonTranslators.java
index 5780500..f2f7233 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/CommonTranslators.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/CommonTranslators.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -360,7 +360,7 @@
 		result.setChildren(new Translator[] {
 			IDTranslator.INSTANCE,
 			new Translator(LANG, COMMON_PKG.getDescription_Lang(), Translator.DOM_ATTRIBUTE),
-			new Translator(Translator.TEXT_ATTRIBUTE_VALUE, COMMON_PKG.getDescription_Value()) //$NON-NLS-1$
+			new Translator(Translator.TEXT_ATTRIBUTE_VALUE, COMMON_PKG.getDescription_Value()) 
 		});
 		return result;
 	}
@@ -373,7 +373,7 @@
 		result.setChildren(new Translator[] {
 			IDTranslator.INSTANCE,
 			new Translator(LANG, COMMON_PKG.getDisplayName_Lang(), Translator.DOM_ATTRIBUTE),
-			new Translator(Translator.TEXT_ATTRIBUTE_VALUE, COMMON_PKG.getDisplayName_Value()) //$NON-NLS-1$
+			new Translator(Translator.TEXT_ATTRIBUTE_VALUE, COMMON_PKG.getDisplayName_Value()) 
 		});
 		return result;
 	}
@@ -387,8 +387,8 @@
 		result.setChildren(new Translator[] {
 			new Translator(LANG, COMMON_PKG.getIconType_Lang(), Translator.DOM_ATTRIBUTE),
 			IDTranslator.INSTANCE,
-			new Translator(SMALL_ICON, COMMON_PKG.getIconType_SmallIcon()), //$NON-NLS-1$
-			new Translator(LARGE_ICON, COMMON_PKG.getIconType_LargeIcon()) //$NON-NLS-1$
+			new Translator(SMALL_ICON, COMMON_PKG.getIconType_SmallIcon()), 
+			new Translator(LARGE_ICON, COMMON_PKG.getIconType_LargeIcon()) 
 		});
 		return result;
 	}
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTranslator.java
index 65313f9..cf6ec62 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTypeTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTypeTranslator.java
index f9b7066..afecd56 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTypeTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/EnvEntryTypeTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -38,7 +38,7 @@
 	 */
 	public String convertValueToString(Object value, EObject owner) {
 		if (value != null) 
-			return JAVA_LANG + ((Enumerator)value).getName(); //$NON-NLS-1$
+			return JAVA_LANG + ((Enumerator)value).getName(); 
 		return null;
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/JavaClassTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/JavaClassTranslator.java
index 375d9fc..e8d24f9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/JavaClassTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/JavaClassTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/ResAuthTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/ResAuthTranslator.java
index c410ff4..fdf8b98 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/ResAuthTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/common/ResAuthTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/connector/ConnectorTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/connector/ConnectorTranslator.java
index 6d8e5d7..82616b8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/connector/ConnectorTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/connector/ConnectorTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AbstractEJBTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AbstractEJBTranslator.java
index 094fb10..896d4ac 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AbstractEJBTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AbstractEJBTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AcknowledgeModeTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AcknowledgeModeTranslator.java
index 972e77a..c8fef25 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AcknowledgeModeTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/AcknowledgeModeTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPFieldTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPFieldTranslator.java
index 332e7d0..7861a6f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPFieldTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPFieldTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPVersionTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPVersionTranslator.java
index 897ea30..f1743cd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPVersionTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/CMPVersionTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EJBJarTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EJBJarTranslator.java
index 96c0e29..49afd53 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EJBJarTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EJBJarTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EnterpriseBeansTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EnterpriseBeansTranslator.java
index 1cdc1ff..eba27c1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EnterpriseBeansTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/EnterpriseBeansTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MessageDrivenDestinationTypeTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MessageDrivenDestinationTypeTranslator.java
index aafe1be..7249028 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MessageDrivenDestinationTypeTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MessageDrivenDestinationTypeTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodElementKindTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodElementKindTranslator.java
index 1347327..668735a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodElementKindTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodElementKindTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodParamsTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodParamsTranslator.java
index c2d8163..988252f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodParamsTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MethodParamsTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MultiplicityTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MultiplicityTranslator.java
index 3ec01f3..ddd1b5b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MultiplicityTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/MultiplicityTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/PrimKeyFieldTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/PrimKeyFieldTranslator.java
index bc6c825..20d3124 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/PrimKeyFieldTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/PrimKeyFieldTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/SecurityIdentityTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/SecurityIdentityTranslator.java
index 1385f60..c219b77 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/SecurityIdentityTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/ejb/SecurityIdentityTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/ErrorPageTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/ErrorPageTranslator.java
index feac170..45c0577 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/ErrorPageTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/ErrorPageTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebAppTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebAppTranslator.java
index dd7d050..86a6452 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebAppTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebAppTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -244,8 +244,8 @@
 	private Translator createLocaleEncodingMapping() {
 		GenericTranslator result = new GenericTranslator(LOCALE_ENCODING_MAPPING, WEBAPP_PKG.getLocalEncodingMappingList_LocalEncodingMappings());
 		result.setChildren(new Translator[] {
-			new Translator(LOCALE, WEBAPP_PKG.getLocalEncodingMapping_Locale()), //$NON-NLS-1$
-			new Translator(ENCODING, WEBAPP_PKG.getLocalEncodingMapping_Encoding()) //$NON-NLS-1$
+			new Translator(LOCALE, WEBAPP_PKG.getLocalEncodingMapping_Locale()), 
+			new Translator(ENCODING, WEBAPP_PKG.getLocalEncodingMapping_Encoding()) 
 		});
 		return result;
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebTypeTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebTypeTranslator.java
index 3d11e06..22027b2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebTypeTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webapplication/WebTypeTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/EJBLinkTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/EJBLinkTranslator.java
index 53a62fa..8fe6d8d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/EJBLinkTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/EJBLinkTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ElementNameTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ElementNameTranslator.java
index 6461b2a..dd3913e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ElementNameTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ElementNameTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/InterfaceMappingTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/InterfaceMappingTranslator.java
index c37c7dc..15bd4a1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/InterfaceMappingTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/InterfaceMappingTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/JaxrpcmapTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/JaxrpcmapTranslator.java
index 9c6c8cb..2a38377 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/JaxrpcmapTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/JaxrpcmapTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/SOAPRoleTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/SOAPRoleTranslator.java
index 41353e1..fd0a35a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/SOAPRoleTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/SOAPRoleTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ServletLinkTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ServletLinkTranslator.java
index 78d0a42..cf3abda 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ServletLinkTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/ServletLinkTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WebServicesTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WebServicesTranslator.java
index b15f643..a223ee7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WebServicesTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WebServicesTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WsddTranslator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WsddTranslator.java
index de6d735..1ffa29a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WsddTranslator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/model/translator/webservices/WsddTranslator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/GeneralXmlDocumentReader.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/GeneralXmlDocumentReader.java
index fdd61f7..4cba97a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/GeneralXmlDocumentReader.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/GeneralXmlDocumentReader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -105,7 +105,7 @@
         }
         catch (Exception ie)
         {
-            handleException(J2EEXMLResourceHandler.getString("failed_instantiating_EXC_", (new Object[] {"Failed to instantiate parser"})), ie); //$NON-NLS-1$ //$NON-NLS-2$ = "Failed instantiating: "
+            handleException(J2EEXMLResourceHandler.getString(XMLParseResourceHandler.failed_instantiating_EXC_, (new Object[] {"Failed to instantiate parser"})), ie); //$NON-NLS-1$ // = "Failed instantiating: "
         }
         return null;
     }
@@ -209,12 +209,12 @@
         }
         catch (org.xml.sax.SAXException ex)
         {
-            handleException(J2EEXMLResourceHandler.getString("failed_instantiating_EXC_", (new Object[] {"SAX Parser error"})), ex); //$NON-NLS-1$ //$NON-NLS-2$ = "Failed instantiating: "
+            handleException(J2EEXMLResourceHandler.getString(XMLParseResourceHandler.failed_instantiating_EXC_, (new Object[] {"SAX Parser error"})), ex); //$NON-NLS-1$ // = "Failed instantiating: "
 
         }
         catch (java.io.IOException ex)
         {
-            handleException(J2EEXMLResourceHandler.getString("failed_instantiating_EXC_", (new Object[] {"IO Exception on input stream"})), ex); //$NON-NLS-1$ //$NON-NLS-2$ = "Failed instantiating: "
+            handleException(J2EEXMLResourceHandler.getString(XMLParseResourceHandler.failed_instantiating_EXC_, (new Object[] {"IO Exception on input stream"})), ex); //$NON-NLS-1$ // = "Failed instantiating: "
         }
         return null;
     }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXMLResourceHandler.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXMLResourceHandler.java
index 8419f9f..92f8095 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXMLResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXMLResourceHandler.java
@@ -1,57 +1,48 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.xml;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-public class J2EEXMLResourceHandler {
+public class J2EEXMLResourceHandler extends NLS {
+	private static final String BUNDLE_NAME = "j2eexml";//$NON-NLS-1$
 
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("j2eexml");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private J2EEXMLResourceHandler() {
+		// Do not instantiate
 	}
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle= getResourceBundle();
-		}
-		
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		} 
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-		
+
+	public static String Valid_values_are___EXC_;
+	public static String RAR_file_support__IO_excep_EXC_;
+	public static String Failure_occurred_reading_x_EXC_;
+	public static String missing_req_field_EXC_;
+	public static String An_IO_Exception_occurred_w_EXC_;
+	public static String must_be_boolean_EXC_;
+	public static String unsupported_encoding_EXC_;
+	public static String rar_dtd_not_found_EXC_;
+	public static String empty_collection_EXC_;
+	public static String must_be_int_EXC_;
+	public static String Invalid_value_for__EXC_;
+	public static String An_Exception_occurred_whil_EXC_;
+	public static String dtd_not_found_EXC_;
+	public static String Not_supported_in_this_rele_EXC_;
+	public static String io_ex_saving_EXC_;
+	public static String could_not_create_file_EXC_;
+	public static String unsupported_type_EXC_;
+	public static String Key1;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, J2EEXMLResourceHandler.class);
 	}
-public static String getString(String key, Object[] args) {
 
-	try {return MessageFormat.format(getString(key), args);}
-	catch (IllegalArgumentException e) {return getString(key);}
-
+	public static String getString(String key, Object[] args) {
+		return NLS.bind(key, args);
+	}
 }
-}
-
-
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXmlDtDEntityResolver.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXmlDtDEntityResolver.java
index ca8ce4c..ec6b64d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXmlDtDEntityResolver.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/J2EEXmlDtDEntityResolver.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -74,10 +74,10 @@
  */
 public org.xml.sax.InputSource resolveEntity(String publicId, String systemId) throws java.io.IOException, org.xml.sax.SAXException {
 	String localResourceName = null;
-	boolean isJavaSytemId = false;
+	//boolean isJavaSytemId = false;
 	if (shouldBeRegistered(systemId)) {
 		localResourceName = (String)getSupportedDtDs().get(systemId);
-		isJavaSytemId = true;	
+		//isJavaSytemId = true;	
 	} else {
 		String shortName = getShortName(systemId);
 		localResourceName = (String)getSupportedDtDs().get(shortName);
@@ -98,7 +98,7 @@
 	
 	
 	if (url == null) {
-		String message = J2EEXMLResourceHandler.getString("dtd_not_found_EXC_", (new Object[] {localResourceName}));//$NON-NLS-1$ = "Could not parse xml because the resolved resource "{0}" could not be found in classpath"
+		String message = J2EEXMLResourceHandler.getString(J2EEXMLResourceHandler.dtd_not_found_EXC_, (new Object[] {localResourceName}));// = "Could not parse xml because the resolved resource "{0}" could not be found in classpath"
 		throw new java.io.FileNotFoundException(message);
 	}
 	
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XMLParseResourceHandler.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XMLParseResourceHandler.java
index 385620f..e7ef7b7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XMLParseResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XMLParseResourceHandler.java
@@ -1,58 +1,32 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
- * IBM Corporation - initial API and implementation
+ *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.xml;
 
+import org.eclipse.osgi.util.NLS;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+public final class XMLParseResourceHandler extends NLS {
 
-public class XMLParseResourceHandler {
+	private static final String BUNDLE_NAME = "xmlparse";//$NON-NLS-1$
 
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("xmlparse");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private XMLParseResourceHandler() {
+		// Do not instantiate
 	}
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle= getResourceBundle();
-		}
-		
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		} 
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-		
+
+	public static String method_invoke_failed_EXC_;
+	public static String failed_to_load_EXC_;
+	public static String method_not_found_EXC_;
+	public static String failed_instantiating_EXC_;
+	public static String parse_exception_occured_EXC_;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, XMLParseResourceHandler.class);
 	}
-public static String getString(String key, Object[] args) {
-
-	try {return MessageFormat.format(getString(key), args);}
-	catch (IllegalArgumentException e) {return getString(key);}
-
-}
-}
-
-
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XmlDocumentReader.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XmlDocumentReader.java
index a3baeb7..9a75760 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XmlDocumentReader.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/internal/xml/XmlDocumentReader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -58,7 +58,7 @@
 		super.handleException(aMessage, anException);
 }
 protected void handleException(String aMessage, SAXParseException parseException) {
-	primHandleException(J2EEXMLResourceHandler.getString("parse_exception_occured_EXC_", (new Object[] {new Integer(parseException.getLineNumber()), new Integer(parseException.getColumnNumber()) })), parseException);  //$NON-NLS-1$
+	primHandleException(J2EEXMLResourceHandler.getString(XMLParseResourceHandler.parse_exception_occured_EXC_, (new Object[] {new Integer(parseException.getLineNumber()), new Integer(parseException.getColumnNumber()) })), parseException);  
 	//$NON-NLS-1$ = "An Exception occurred while parsing xml: {0} Line #: {1} :Column #: "
 }
 protected void primHandleException(String aMessage, Throwable anException) {
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ActivationSpec.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ActivationSpec.java
index 2f15e93..a7e54f0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ActivationSpec.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ActivationSpec.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getActivationSpec()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ActivationSpec extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Activation Spec Class</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AdminObject.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AdminObject.java
index 64239a2..376ac13 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AdminObject.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AdminObject.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getAdminObject()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface AdminObject extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Admin Object Interface</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanism.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanism.java
index 4e528cf..82b8988 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanism.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanism.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,7 +21,7 @@
  * The Kerbv5 mechanism type should support the
  * javax.resource.spi.security.GenericCredential interface.
 
- */
+ * @since 1.0 */
 public interface AuthenticationMechanism extends EObject{
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanismType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanismType.java
index 77ff455..0d96e05 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanismType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/AuthenticationMechanismType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface AuthenticationMechanismType {}
+ * @since 1.0
  */
 public final class AuthenticationMechanismType extends AbstractEnumerator{
 	/**
@@ -86,6 +87,8 @@
 	/**
 	 * Returns the '<em><b>Authentication Mechanism Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -104,6 +107,8 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
+	 * @param value passes literal value
+	 * @return literal instance
 	 */
 	public static AuthenticationMechanismType get(int value) {
 		switch (value) {
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConfigProperty.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConfigProperty.java
index dc6a383..eff06d1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConfigProperty.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConfigProperty.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -25,7 +25,7 @@
  * 
  * Any bounds or well-defined values of properties should be described in the description.
 
- */
+ * @since 1.0 */
 public interface ConfigProperty extends EObject{
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectionDefinition.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectionDefinition.java
index 910e9b2..b510a44 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectionDefinition.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectionDefinition.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -42,7 +42,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getConnectionDefinition()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ConnectionDefinition extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Managed Connection Factory Class</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/Connector.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/Connector.java
index b8e6c1c..9e1586d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/Connector.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/Connector.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,12 +14,14 @@
 /**
  * The connector element is the root element of the deployment descriptor for the resource adapter. This element includes general information - vendor name, version, specification version supported, icon -  about the resource adapter module. It also includes information specific to the implementation of the resource adapter library as specified through the element resourceadapter.
 
- */
+ * @since 1.0 */
 public interface Connector extends CompatibilityDescriptionGroup{
 
 
 	/**
 	* This returns the module version id.  Compare with J2EEVersionConstants to determine module level
+	* @throws IllegalStateException if calling this function fails
+	* @return the version of the J2C module 
 	*/
 	public int getVersionID() throws IllegalStateException ;
 
@@ -102,7 +104,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the License reference
+	 * @param value The new value of the License reference
 	 */
 	void setLicense(License value);
 
@@ -114,7 +116,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the ResourceAdapter reference
+	 * @param value The new value of the ResourceAdapter reference
 	 */
 	void setResourceAdapter(ResourceAdapter value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectorResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectorResource.java
index 6e52db3..510e569 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectorResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ConnectorResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,14 @@
 
 import org.eclipse.jst.j2ee.internal.common.XMLResource;
 
+/**
+ *@since 1.0
+ */
 public interface ConnectorResource extends XMLResource {
+	
+	/**
+	 * Returns the deployment descriptor model
+	 * @return Connector
+	 */
 	public Connector getConnector() ;
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/InboundResourceAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/InboundResourceAdapter.java
index 5a9431f..1aeb246 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/InboundResourceAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/InboundResourceAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -35,7 +35,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getInboundResourceAdapter()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface InboundResourceAdapter extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Message Adapter</b></em>' containment reference.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaFactory.java
index b2df210..5d00f31 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,7 +13,7 @@
 import org.eclipse.emf.ecore.EFactory;
 /**
  * @generated
- */
+ * @since 1.0 */
 public interface JcaFactory extends EFactory{
 
 	/**
@@ -134,6 +134,10 @@
 	ConfigProperty createConfigProperty();
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @generated This field/method will be replaced during code generation.
 	 */
 	JcaPackage getJcaPackage();
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaPackage.java
index 91d7b86..c2c7682 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/JcaPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,15 @@
 import org.eclipse.jst.j2ee.common.CommonPackage;
 
 
-
+/**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	@since 1.0
+ */
 public interface JcaPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/License.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/License.java
index 9437f33..dbb20a7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/License.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/License.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,7 +14,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * Specifies licensing requirements for the resource adapter module. Specifies whether a license is required to deploy and use this resource adapter, and an optional description of the licensing terms (examples: duration of license, number of connection restrictions).
- */
+ * @since 1.0 */
 public interface License extends EObject{
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageAdapter.java
index 88bd844..2af4e03 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getMessageAdapter()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface MessageAdapter extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Message Listeners</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageListener.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageListener.java
index 5e4d1a7..082ebf8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageListener.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/MessageListener.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getMessageListener()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface MessageListener extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Message Listener Type</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/OutboundResourceAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/OutboundResourceAdapter.java
index 15b5c73..1488436 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/OutboundResourceAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/OutboundResourceAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -48,7 +48,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getOutboundResourceAdapter()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface OutboundResourceAdapter extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Reauthentication Support</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/RequiredConfigPropertyType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/RequiredConfigPropertyType.java
index 430982f..6e1a97c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/RequiredConfigPropertyType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/RequiredConfigPropertyType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -41,7 +41,7 @@
  * @see org.eclipse.jst.j2ee.jca.JcaPackage#getRequiredConfigPropertyType()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface RequiredConfigPropertyType extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ResourceAdapter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ResourceAdapter.java
index 10a35af..43cabee 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ResourceAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/ResourceAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -22,7 +22,7 @@
  * of security contract. The application server ignores the security
  * part of the system contracts in this case.
 
- */
+ * @since 1.0 */
 public interface ResourceAdapter extends EObject{
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/SecurityPermission.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/SecurityPermission.java
index 343ebb5..3bd82bd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/SecurityPermission.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/SecurityPermission.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,7 @@
  * 
  * The security permission listed in the deployment descriptor are ones that are different from those required by the default permission set as specified in the connector specification. The optional description can mention specific reason that resource adapter requires a given security permission.
 
- */
+ * @since 1.0 */
 public interface SecurityPermission extends EObject{
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/TransactionSupportKind.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/TransactionSupportKind.java
index 83b9dda..4025856 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/TransactionSupportKind.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/TransactionSupportKind.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,6 +21,7 @@
 
 /**
  * @lastgen interface TransactionSupportKind {}
+ * @since 1.0
  */
 public final class TransactionSupportKind extends AbstractEnumerator{
 	/**
@@ -105,6 +106,8 @@
 	/**
 	 * Returns the '<em><b>Transaction Support Kind</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -121,6 +124,8 @@
 	/**
 	 * Returns the '<em><b>Transaction Support Kind</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ActivationSpecImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ActivationSpecImpl.java
index 60540b8..b4baa30 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ActivationSpecImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ActivationSpecImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AdminObjectImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AdminObjectImpl.java
index a38df95..d40d430 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AdminObjectImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AdminObjectImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AuthenticationMechanismImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AuthenticationMechanismImpl.java
index 7c35aa0..ff32467 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AuthenticationMechanismImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/AuthenticationMechanismImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConfigPropertyImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConfigPropertyImpl.java
index 208df18..db8bc90 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConfigPropertyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConfigPropertyImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectionDefinitionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectionDefinitionImpl.java
index 1be500f..c6f6142 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectionDefinitionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectionDefinitionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorImpl.java
index 30350ec..8279024 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceFactory.java
index 8143d92..6970677 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceImpl.java
index 149a7f2..8e5cf62 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ConnectorResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/InboundResourceAdapterImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/InboundResourceAdapterImpl.java
index cc72561..80e5bd4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/InboundResourceAdapterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/InboundResourceAdapterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaFactoryImpl.java
index 90b357a..e7b1ebc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaPackageImpl.java
index cd63e2c..faa339b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/JcaPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/LicenseImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/LicenseImpl.java
index c27eabd..a726ef1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/LicenseImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/LicenseImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageAdapterImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageAdapterImpl.java
index 94cd149..e768c6c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageAdapterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageAdapterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageListenerImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageListenerImpl.java
index b34b4a7..2b000cb 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageListenerImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/MessageListenerImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/OutboundResourceAdapterImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/OutboundResourceAdapterImpl.java
index 89923c1..bdd51d2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/OutboundResourceAdapterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/OutboundResourceAdapterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/RequiredConfigPropertyTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/RequiredConfigPropertyTypeImpl.java
index 9ed40ec..2c31798 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/RequiredConfigPropertyTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/RequiredConfigPropertyTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ResourceAdapterImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ResourceAdapterImpl.java
index c3946b1..7ffb209 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ResourceAdapterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/ResourceAdapterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/SecurityPermissionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/SecurityPermissionImpl.java
index 0c90eb9..f3f6178 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/SecurityPermissionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/impl/SecurityPermissionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JCADescriptionHelper.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JCADescriptionHelper.java
index e24f18f..686e4f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JCADescriptionHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JCADescriptionHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaAdapterFactory.java
index b62b496..7f1916a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaSwitch.java
index 7a211bf..2ee9c41 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jca/internal/util/JcaSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPConfig.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPConfig.java
index 9ca203d..295cfbb 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPConfig.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPConfig.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -36,7 +36,7 @@
  * @see org.eclipse.jst.j2ee.jsp.JspPackage#getJSPConfig()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface JSPConfig extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Tag Libs</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPPropertyGroup.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPPropertyGroup.java
index b5650ea..11e9dda 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPPropertyGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JSPPropertyGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -49,7 +49,7 @@
  * @see org.eclipse.jst.j2ee.jsp.JspPackage#getJSPPropertyGroup()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface JSPPropertyGroup extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Url Pattern</b></em>' attribute list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspFactory.java
index ff43196..b739ef8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.jsp.JspPackage
  * @generated
- */
+ * @since 1.0 */
 public interface JspFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -59,6 +59,8 @@
 	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
 	 * <!-- end-user-doc -->
 	 * @return the package supported by this factory.
 	 * @generated
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspPackage.java
index 8d9ff7c..ece1d60 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/JspPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,11 +27,19 @@
  *   <li>each enum,</li>
  *   <li>and each data type</li>
  * </ul>
+ * /**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.jsp.JspFactory
  * @model kind="package"
  * @generated
- */
+ * @since 1.0 */
 public interface JspPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/TagLibRefType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/TagLibRefType.java
index f720637..186a5df 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/TagLibRefType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/TagLibRefType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -35,7 +35,7 @@
  * @see org.eclipse.jst.j2ee.jsp.JspPackage#getTagLibRefType()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface TagLibRefType extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Taglib URI</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPConfigImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPConfigImpl.java
index e9c1646..f04d95a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPConfigImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPConfigImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPPropertyGroupImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPPropertyGroupImpl.java
index b02d235..bb93db6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPPropertyGroupImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JSPPropertyGroupImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspFactoryImpl.java
index d55d6ca..1d92f92 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspPackageImpl.java
index f9b8265..23de29c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/JspPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/TagLibRefTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/TagLibRefTypeImpl.java
index 6a806e7..fe6ac80 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/TagLibRefTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/impl/TagLibRefTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspAdapterFactory.java
index 6b3f10f..ce370d8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspSwitch.java
index 5b465d1..376dcd8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/jsp/internal/util/JspSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/BodyContentType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/BodyContentType.java
index b3238f8..abc933b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/BodyContentType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/BodyContentType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -127,6 +127,8 @@
 	/**
 	 * Returns the '<em><b>Body Content Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -143,6 +145,8 @@
 	/**
 	 * Returns the '<em><b>Body Content Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/ExtensibleType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/ExtensibleType.java
index ad803bb..5be9312 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/ExtensibleType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/ExtensibleType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Function.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Function.java
index 7a98f75..1399c58 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Function.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Function.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPScriptingVariableScope.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPScriptingVariableScope.java
index 2663d12..4941974 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPScriptingVariableScope.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPScriptingVariableScope.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -101,6 +101,8 @@
 	/**
 	 * Returns the '<em><b>JSP Scripting Variable Scope</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -117,6 +119,8 @@
 	/**
 	 * Returns the '<em><b>JSP Scripting Variable Scope</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTag.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTag.java
index db51399..77f773f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTag.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTag.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTagAttribute.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTagAttribute.java
index 2749471..26e3a78 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTagAttribute.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPTagAttribute.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPVariable.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPVariable.java
index 9455d53..bbc3b34 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPVariable.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/JSPVariable.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagFile.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagFile.java
index bce3638..51d5823 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagFile.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagFile.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagLib.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagLib.java
index b7994f9..bcb33cc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagLib.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TagLib.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibFactory.java
index a22deef..88da38c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibPackage.java
index 4429c69..32f5dff 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TaglibPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TldExtension.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TldExtension.java
index b73d5d6..08104ea 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TldExtension.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/TldExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Validator.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Validator.java
index 7a05011..6f676d3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Validator.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/Validator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ExtensibleTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ExtensibleTypeImpl.java
index 3a6220e..1670847 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ExtensibleTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ExtensibleTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/FunctionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/FunctionImpl.java
index 39b9e9c..74455dd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/FunctionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/FunctionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagAttributeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagAttributeImpl.java
index 8328916..508a5d6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagAttributeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagAttributeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagImpl.java
index 7a682ff..1a440fb 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPTagImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPVariableImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPVariableImpl.java
index dbb0c64..c416fe8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPVariableImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/JSPVariableImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagFileImpl.java
index a623730..4b1956b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagLibImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagLibImpl.java
index c29613a..c316122 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagLibImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TagLibImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibFactoryImpl.java
index f2dbb66..c95ec53 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibPackageImpl.java
index cd0cea3..02a74b9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TaglibPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TldExtensionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TldExtensionImpl.java
index 82539a9..92ba8b0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TldExtensionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/TldExtensionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ValidatorImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ValidatorImpl.java
index 1d26d1c..4df3ac4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ValidatorImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/impl/ValidatorImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibAdapterFactory.java
index a39d3c8..597eff5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibSwitch.java
index 77cfce7..c80ae0e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/taglib/internal/util/TaglibSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthConstraint.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthConstraint.java
index daee526..c98191d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthConstraint.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthConstraint.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,6 +14,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The auth-constraint element indicates the user roles that should be permitted access to this resource collection. The role used here must appear in a security-role-ref element.
+ * @since 1.0 
  */
 public interface AuthConstraint extends EObject{
 	/**
@@ -46,7 +47,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the SecConstraint reference
+	 * @param value the new value of the SecConstraint reference
 	 */
 	void setSecConstraint(SecurityConstraint value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthMethodKind.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthMethodKind.java
index 7b40f92..5b8d75e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthMethodKind.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/AuthMethodKind.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,7 +16,11 @@
 import org.eclipse.emf.common.util.AbstractEnumerator;
 
 
-
+/**
+ * 
+ * @since 1.0
+ *
+ */
 
 
 public final class AuthMethodKind extends AbstractEnumerator{
@@ -139,6 +143,8 @@
 	/**
 	 * Returns the '<em><b>Auth Method Kind</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -157,6 +163,8 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
+	 * @param value passes literal value
+	 * @return literal instance
 	 */
 	public static AuthMethodKind get(int value) {
 		switch (value) {
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ContextParam.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ContextParam.java
index 0cbd49f..b62c641 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ContextParam.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ContextParam.java
@@ -13,6 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The context-param element contains the declaration of a web application's servlet context initialization parameters.
+ * @since 1.0
  */
 public interface ContextParam extends EObject{
 	/**
@@ -61,7 +62,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/DispatcherType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/DispatcherType.java
index f64c3b2..73b473f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/DispatcherType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/DispatcherType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -24,6 +24,7 @@
  * @see org.eclipse.jst.j2ee.webapplication.WebapplicationPackage#getDispatcherType()
  * @model
  * @generated
+ * @since 1.0
  */
 public final class DispatcherType extends AbstractEnumerator
 {
@@ -152,6 +153,8 @@
 	/**
 	 * Returns the '<em><b>Dispatcher Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -168,6 +171,8 @@
 	/**
 	 * Returns the '<em><b>Dispatcher Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Filter.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Filter.java
index 3e49f92..770b6d9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Filter.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Filter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/FilterMapping.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/FilterMapping.java
index c0e2a9e..5b688bb 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/FilterMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/FilterMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodType.java
index 7f43441..b252d8d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodTypeEnum.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodTypeEnum.java
index e98be92..461dea8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodTypeEnum.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/HTTPMethodTypeEnum.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -232,6 +232,8 @@
 	/**
 	 * Returns the '<em><b>HTTP Method Type Enum</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -248,6 +250,8 @@
 	/**
 	 * Returns the '<em><b>HTTP Method Type Enum</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/JSPType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/JSPType.java
index b5a25e6..e0c2c70 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/JSPType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/JSPType.java
@@ -13,6 +13,7 @@
 
 /**
  * @generated
+ * @since 1.0
  */
 public interface JSPType extends WebType{
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMapping.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMapping.java
index 43781ca..72a0d32 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,6 +28,7 @@
  * @see org.eclipse.jst.j2ee.webapplication.WebapplicationPackage#getLocalEncodingMapping()
  * @model
  * @generated
+ * @since 1.0
  */
 public interface LocalEncodingMapping extends EObject{
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMappingList.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMappingList.java
index e4d58a5..daaaeae 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMappingList.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LocalEncodingMappingList.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,6 +28,7 @@
  * @see org.eclipse.jst.j2ee.webapplication.WebapplicationPackage#getLocalEncodingMappingList()
  * @model
  * @generated
+ * @since 1.0
  */
 public interface LocalEncodingMappingList extends EObject{
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LoginConfig.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LoginConfig.java
index c2c9a76..8ab8da0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LoginConfig.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/LoginConfig.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/MimeMapping.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/MimeMapping.java
index 8c4989b..23b1438 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/MimeMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/MimeMapping.java
@@ -13,7 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The mime-mapping element defines a mapping between an extension and a mime type.
-
+ *@since 1.0
  */
 public interface MimeMapping extends EObject{
 	/**
@@ -50,7 +50,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ResAuthServletType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ResAuthServletType.java
index 9d6f256..a471e50 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ResAuthServletType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ResAuthServletType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,9 @@
 import org.eclipse.emf.common.util.AbstractEnumerator;
 
 
-
+/**
+ *@since 1.0
+ */
 public final class ResAuthServletType extends AbstractEnumerator{
 	/**
 	 * @generated This field/method will be replaced during code generation.
@@ -81,6 +83,8 @@
 	/**
 	 * Returns the '<em><b>Res Auth Servlet Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -97,6 +101,8 @@
 	/**
 	 * Returns the '<em><b>Res Auth Servlet Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/RoleNameType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/RoleNameType.java
index a5ef1f7..4222050 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/RoleNameType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/RoleNameType.java
@@ -13,6 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * @generated
+ * @since  1.0
  */
 public interface RoleNameType extends EObject {
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SecurityConstraint.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SecurityConstraint.java
index c7da127..ea53b91 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SecurityConstraint.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SecurityConstraint.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,6 +14,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The security-constraint element is used to associate security constraints with one or more web resource collections
+ * @since 1.0
  */
 public interface SecurityConstraint extends EObject{
 	/**
@@ -53,7 +54,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
@@ -71,7 +72,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the AuthConstraint reference
+	 * @param value The new value of the AuthConstraint reference
 	 */
 	void setAuthConstraint(AuthConstraint value);
 
@@ -83,7 +84,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the UserDataConstraint reference
+	 * @param value The new value of the UserDataConstraint reference
 	 */
 	void setUserDataConstraint(UserDataConstraint value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Servlet.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Servlet.java
index 88f4086..8c43cd5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Servlet.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/Servlet.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,23 +20,31 @@
 
 /**
  * The servlet element contains the declarative data of a servlet. If a jsp-file is specified and the load-on-startup element is present, then the JSP should be precompiled and loaded.
+ * @since 1.0
  */
 public interface Servlet extends CompatibilityDescriptionGroup{
 
 
-/**
- * Returns an unmodifiable list of the mappings that this
- * servlet participates in.  Since servletMappings is not
- * a bi-directional attribute, if you want to add or delete a
- * mapping, this must be done in the web-app.
- * @return java.util.List
- */
-public List getMappings();
-public Properties getParamsAsProperties() ;
-/**
- * Fix the role-link on any contained role refs
- */
-public void reSyncSecurityRoleRef(String existingRoleName, String newRoleName);
+	/**
+	 * Returns an unmodifiable list of the mappings that this
+	 * servlet participates in.  Since servletMappings is not
+	 * a bi-directional attribute, if you want to add or delete a
+	 * mapping, this must be done in the web-app.
+	 * @return java.util.List
+	 */
+	public List getMappings();
+	
+	/**
+	 * Gets the Servlet parameters in  java.util.Properties
+	 * @return java.util.Properties
+	 */
+	public Properties getParamsAsProperties() ;
+	/**
+	 * Fix the role-link on any contained role refs
+	 * @param existingRoleName existing role name
+	 * @param newRoleName new role name
+	 */
+	public void reSyncSecurityRoleRef(String existingRoleName, String newRoleName);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the ServletName attribute
@@ -106,7 +114,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
@@ -118,7 +126,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebType reference
+	 * @param value The new value of the WebType reference
 	 */
 	void setWebType(WebType value);
 
@@ -145,7 +153,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the RunAs reference
+	 * @param value The new value of the RunAs reference
 	 */
 	void setRunAs(RunAsSpecifiedIdentity value);
 
@@ -167,6 +175,7 @@
 
 	/**
 	 * return the java servlet class associated with this servlet
+	 * @return reference to JavaClass
 	 */
 	public JavaClass getServletClass();
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletMapping.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletMapping.java
index bed02b9..42ce1f2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,6 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The servlet-mapping element defines a mapping between a servlet and a url pattern
+ * @since 1.0
  */
 public interface ServletMapping extends EObject{
 	/**
@@ -69,7 +70,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
@@ -81,7 +82,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the Servlet reference
+	 * @param value The new value of the Servlet reference
 	 */
 	void setServlet(Servlet value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletType.java
index bc8884f..1a634b3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/ServletType.java
@@ -13,6 +13,7 @@
 
 /**
  * @generated
+ * @since 1.0
  */
 public interface ServletType extends WebType{
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SessionConfig.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SessionConfig.java
index 583d1ce..88bdaa0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SessionConfig.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/SessionConfig.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,6 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The session-config element defines the session parameters for this web application.
+ * @since 1.0
  */
 public interface SessionConfig extends EObject{
 	/**
@@ -61,7 +62,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TagLibRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TagLibRef.java
index 26930ca..eee5c9d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TagLibRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TagLibRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -14,6 +14,7 @@
 /**
  * The taglib element is used to describe a JSP tag library.
  * @version since J2EE1.4 deprecated, use org.eclipse.jst.j2ee.internal.jsp.TagLibRef
+ * @since 1.0
  */
 public interface TagLibRef extends EObject{
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TransportGuaranteeType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TransportGuaranteeType.java
index e9f875c..f5455f0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TransportGuaranteeType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/TransportGuaranteeType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,7 +17,9 @@
 
 
 
-
+/**
+ *@since 1.0
+ */
 
 public final class TransportGuaranteeType extends AbstractEnumerator{
 	/**
@@ -101,6 +103,8 @@
 	/**
 	 * Returns the '<em><b>Transport Guarantee Type</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
@@ -117,6 +121,8 @@
 	/**
 	 * Returns the '<em><b>Transport Guarantee Type</b></em>' literal with the specified value.
 	 * <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/URLPatternType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/URLPatternType.java
index fec6d7c..748cce6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/URLPatternType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/URLPatternType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,6 +27,7 @@
  * @see org.eclipse.jst.j2ee.webapplication.WebapplicationPackage#getURLPatternType()
  * @model
  * @generated
+ * @since 1.0
  */
 public interface URLPatternType extends EObject{
 	/**
@@ -49,7 +50,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the ResCollection reference
+	 * @param value The new value of the ResCollection reference
 	 */
 	void setResCollection(WebResourceCollection value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/UserDataConstraint.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/UserDataConstraint.java
index a8f5ade..ebf2282 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/UserDataConstraint.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/UserDataConstraint.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,6 +15,7 @@
 
 /**
  * The user-data-constraint element is used to indicate how data communicated between the client and container should be protected
+ * @since 1.0
  */
 public interface UserDataConstraint extends EObject{
 	/**
@@ -89,7 +90,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the SecConstraint reference
+	 * @param value The new value of the SecConstraint reference
 	 */
 	void setSecConstraint(SecurityConstraint value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebApp.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebApp.java
index 22c3d58..b6abae2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebApp.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebApp.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,66 +20,104 @@
 /**
  * The web-app element is the root of the deployment descriptor for
  * a web application.
+ * @since 1.0
  */
 public interface WebApp extends JNDIEnvRefsGroup{
 
-public boolean containsSecurityRole(String name);
-ErrorPage getErrorPageByCode(Integer code) ;
-ErrorPage getErrorPageByExceptionType(String exceptionType) ;
-/**
- * Finds a filter mapping for a specified filter.
- * @param filter The filter to find the mappings for.
- * @return The filter mapping for the specified filter, or null if no
- * mapping exists for the filter.
- */
+	/**
+	 * Returns true if there is a SecurityRole with the name passed
+	 * @param name name of the SecurityRole
+	 * @return boolean value
+	 */
+	public boolean containsSecurityRole(String name);
+	
+	/**
+	 * Returns an ErrorPage if it has the specified error code
+	 * @param code the error code
+	 * @return refernce to ErrorPage
+	 */
+	ErrorPage getErrorPageByCode(Integer code) ;
+	
+	/**
+	 * Returns an ErrorPage given an exceptionType
+	 * @param exceptionType the java Exception Type
+	 * @return refernce to ErrorPage
+	 */
+	ErrorPage getErrorPageByExceptionType(String exceptionType) ;
+	/**
+	 * Finds a filter mapping for a specified filter.
+	 * @param aFilter The filter to find the mappings for.
+	 * @return The filter mapping for the specified filter, or null if no
+	 * mapping exists for the filter.
+	 */
 
-FilterMapping getFilterMapping(Filter aFilter);
-public Filter getFilterNamed(String name);
-/**
- * Gets the names of the filters defined for this web application.
- * @return A list of filter names (Strings).
- */
+	FilterMapping getFilterMapping(Filter aFilter);
+	
+	/**
+	 * Gets refernce to the instance of Filter which has the specified name
+	 * @param name the name of the Filter to look for
+	 * @return refernce to teh Filter
+	 */
+	public Filter getFilterNamed(String name);
+	/**
+	 * Gets the names of the filters defined for this web application.
+	 * @return A list of filter names (Strings).
+	 */
 
-List getFilterNames() ;
-/**
- * Returns the mime type for the specified extension
- * @param An extension to find the mime type for.
- */
- 
-String getMimeType(String extension);
+	List getFilterNames() ;
+	/**
+	 * Returns the mime type for the specified extension
+	 * @param extension to find the mime type for.
+	 * @return String value
+	 */
+	String getMimeType(String extension);
+	
+	/**
+	 * Returns the SecurityRole with the specified name
+	 * @param roleName the name of the SecurityRole to be searched for
+	 * @return reference to the model object SecurityRole
+	 */
 	public SecurityRole getSecurityRoleNamed(String roleName);
-/**
- * Finds a servlet mapping for a specified servlet.
- * @param servlet The servlet to find the mappings for.
- * @return The servlet mapping for the specified servlet, or null if no
- * mapping exists for the servlet.
- */
-
-ServletMapping getServletMapping(Servlet aServlet);
-public Servlet getServletNamed(String name);
-/**
- * Gets the names of the servlets defined for this web application.
- * @return A list of servlet names (Strings).
- */
-
-List getServletNames() ;
-/**
- * Return boolean indicating if this Web App was populated from an Servlet2.2 compliant descriptor
- * @return boolean
- * @deprecated Use getVersionID() to determine module level
- */
-public boolean isVersion2_2Descriptor();
-/**
- * Return boolean indicating if this Web App was populated from an Servlet2.3 compliant descriptor
- * @return boolean
- * @deprecated Use getVersionID() to determine module level
- */
-public boolean isVersion2_3Descriptor();
-/**
- * Rename the security role if it exists; for each servlet, fix the role-link on any contained role
- * refs
- */
-public void renameSecurityRole(String existingRoleName, String newRoleName);
+	
+	/**
+	 * Finds a servlet mapping for a specified servlet.
+	 * @param aServlet The servlet to find the mappings for.
+	 * @return The servlet mapping for the specified servlet, or null if no
+	 * mapping exists for the servlet.
+	 */
+	ServletMapping getServletMapping(Servlet aServlet);
+	
+	/**
+	 * Returns a Servlet with the specified name 
+	 * @param name the name of the Servlet to search for
+	 * @return reference to the model object Servlet
+	 */
+	public Servlet getServletNamed(String name);
+	
+	/**
+	 * Gets the names of the servlets defined for this web application.
+	 * @return A list of servlet names (Strings).
+	 */
+	List getServletNames() ;
+	/**
+	 * Return boolean indicating if this Web App was populated from an Servlet2.2 compliant descriptor
+	 * @return boolean
+	 * @deprecated Use getVersionID() to determine module level
+	 */
+	public boolean isVersion2_2Descriptor();
+	/**
+	 * Return boolean indicating if this Web App was populated from an Servlet2.3 compliant descriptor
+	 * @return boolean
+	 * @deprecated Use getVersionID() to determine module level
+	 */
+	public boolean isVersion2_3Descriptor();
+	/**
+	 * Rename the security role if it exists; for each servlet, fix the role-link on any contained role
+	 * refs
+	 * @param existingRoleName curent security role name
+	 * @param newRoleName new security role name
+	 */
+	public void renameSecurityRole(String existingRoleName, String newRoleName);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the Distributable attribute
@@ -136,10 +174,16 @@
 
 	/**
 	* This returns the module version id. Compare with J2EEVersionConstants to determine module level
+	 *@throws IllegalStateException the exception is thrown if a problem is encountered in finding the 
+	 *module version. 	* 
+	* @return the module version id represented in the int e.g. 22, 23, 24
 	*/
 	public int getVersionID() throws IllegalStateException ;
 	/**
 	 *This returns the j2ee version id. Compare with J2EEVersionConstants to determine j2ee level
+	 *@throws IllegalStateException the exception is thrown if a problem is encountered in finding the 
+	 *j2ee version. 
+	 *@return the j2ee version represented in the int
 	 */
 	public int getJ2EEVersionID() throws IllegalStateException ;
 	/**
@@ -172,12 +216,13 @@
 
 	/**
 	 * @deprecated : Use getEnvironmentProperties()
+	 * @return reference to EList
 	 */
 	EList getEnvEntries();
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the FileList reference
+	 * @param value The new value of the FileList reference
 	 */
 	void setFileList(WelcomeFileList value);
 
@@ -201,7 +246,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the LoginConfig reference
+	 * @param value The new value of the LoginConfig reference
 	 */
 	void setLoginConfig(LoginConfig value);
 
@@ -219,7 +264,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the SessionConfig reference
+	 * @param value The new value of the SessionConfig reference
 	 */
 	void setSessionConfig(SessionConfig value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebAppResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebAppResource.java
index b7eeeba..d87771c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebAppResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebAppResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,22 +20,28 @@
 
 /**
  * @author schacher
- *
- * To change this generated comment go to 
- * Window>Preferences>Java>Code Generation>Code and Comments
+ * @since 1.0
  */
 public interface WebAppResource extends XMLResource {
+	
+	/**
+	 * Returns reference to the model object WebApp
+	 * @return reference to  model object WebApp
+	 */
 	WebApp getWebApp();
 	/**
 	 * Return true if this Resource supports the Web 2.2 spec.
+	 * @return boolean value
 	 */
 	boolean isWeb2_2();
 	/**
 	 * Return true if this Resource supports the Web 2.3 spec.
+	 * @return boolean value
 	 */
 	boolean isWeb2_3();
 	/**
 	 * Return true if this Resource supports the Web 2.4 spec.
+	 * @return boolean value
 	 */
 	boolean isWeb2_4();
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebResourceCollection.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebResourceCollection.java
index 21e3594..6112ee7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebResourceCollection.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebResourceCollection.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,12 +15,21 @@
 /**
  * @generated
  * The web-resource-collection element is used to identify a subset of the resources and HTTP methods on those resources within a web application to which a security constraint applies. If no HTTP methods are specified, then the security constraint applies to all HTTP methods.
-
+ * @since 1.0
  */
 public interface WebResourceCollection extends EObject{
 
-public void addHTTP(String httpMethod);
-public void addURL(String urlPattern);
+	/**
+	 * Adds instance of HTTPMethodType
+	 * @param httpMethod name of the httpMethod to add
+	 */
+	public void addHTTP(String httpMethod);
+	
+	/**
+	 * Adds instance of URLPatternType
+	 * @param urlPattern name of the url to add
+	 */
+	public void addURL(String urlPattern);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The value of the WebResourceName attribute
@@ -88,6 +97,7 @@
 
 	/**
 	 * @deprecated : Use getHttpMethod();
+	 * @return List of HttpMethods
 	 */
 	EList getHTTPs();
 	
@@ -101,7 +111,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the SecConstraint reference
+	 * @param value The new value of the SecConstraint reference
 	 */
 	void setSecConstraint(SecurityConstraint value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebType.java
index 7b58f23..1144e64 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebType.java
@@ -13,11 +13,21 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * @generated
+ * @since 1.0
  */
 public interface WebType extends EObject {
 
-public boolean isJspType();
-public boolean isServletType();
+	/**
+	 * Returns true if the type denotes a JSP
+	 * @return boolean value
+	 */
+	public boolean isJspType();
+	
+	/**
+	 * Returns true if the type denotes a servlet
+	 * @return boolean value
+	 */
+	public boolean isServletType();
 }
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationFactory.java
index 1def263..95ed9df 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,6 +13,7 @@
 import org.eclipse.emf.ecore.EFactory;
 /**
  * @generated
+ * @since 1.0
  */
 public interface WebapplicationFactory extends EFactory{
 	/**
@@ -201,7 +202,12 @@
 	RoleNameType createRoleNameType();
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @generated This field/method will be replaced during code generation.
+	 * @return reference to WebapplicationPackage
 	 */
 	WebapplicationPackage getWebapplicationPackage();
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationPackage.java
index 420d90c..5ef5add 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WebapplicationPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,15 @@
 import org.eclipse.jst.j2ee.common.CommonPackage;
 
 
-
+/**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	@since 1.0
+ */
 public interface WebapplicationPackage extends EPackage{
 	/**
 	 * The package name.
@@ -1230,6 +1238,9 @@
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EAttribute getWebApp_Distributable();
 
 	/**
@@ -1241,76 +1252,121 @@
 	 * @see #getWebApp()
 	 * @generated
 	 */
+	/**
+	 * @return
+	 */
 	EAttribute getWebApp_Version();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_Contexts();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_ErrorPages();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_FileList();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_TagLibs();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_Constraints();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_LoginConfig();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_MimeMappings();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_SessionConfig();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_ServletMappings();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_Servlets();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_SecurityRoles();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_Filters();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_FilterMappings();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_Listeners();
 
 	/**
@@ -1322,6 +1378,9 @@
 	 * @see #getWebApp()
 	 * @generated
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_ContextParams();
 
 	/**
@@ -1333,6 +1392,9 @@
 	 * @see #getWebApp()
 	 * @generated
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_JspConfig();
 
 	/**
@@ -1344,6 +1406,9 @@
 	 * @see #getWebApp()
 	 * @generated
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_MessageDestinations();
 
 	/**
@@ -1355,6 +1420,9 @@
 	 * @see #getWebApp()
 	 * @generated
 	 */
+	/**
+	 * @return
+	 */
 	EReference getWebApp_LocalEncodingMappingList();
 
 	/**
@@ -1366,21 +1434,33 @@
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return Name
+	 */
 	EAttribute getContextParam_ParamName();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return Value
+	 */
 	EAttribute getContextParam_ParamValue();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return Description
+	 */
 	EAttribute getContextParam_Description();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return WebApp
+	 */
 	EReference getContextParam_WebApp();
 
 	/**
@@ -1392,11 +1472,17 @@
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return Location
+	 */
 	EAttribute getErrorPage_Location();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return WebApp
+	 */
 	EReference getErrorPage_WebApp();
 
 	/**
@@ -1414,11 +1500,17 @@
 	 * @generated This field/method will be replaced during code generation 
 	 * @return ErrorCodeErrorPage object
 	 */
+	/**
+	 * @return ErrorCodeErrorPage object
+	 */
 	EClass getErrorCodeErrorPage();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return ErrorCode
+	 */
 	EAttribute getErrorCodeErrorPage_ErrorCode();
 
 	/**
@@ -1648,16 +1740,25 @@
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return Description
+	 */
 	EAttribute getAuthConstraint_Description();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return Roles
+	 */
 	EAttribute getAuthConstraint_Roles();
 
 	/**
 	 * @generated This field/method will be replaced during code generation.
 	 */
+	/**
+	 * @return SecConstraint object
+	 */
 	EReference getAuthConstraint_SecConstraint();
 
 	/**
@@ -1669,6 +1770,9 @@
 	 * @see #getAuthConstraint()
 	 * @generated
 	 */
+	/**
+	 * @return Descriptions
+	 */
 	EReference getAuthConstraint_Descriptions();
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFile.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFile.java
index e2eba57..3c5ca84 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFile.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFile.java
@@ -13,7 +13,7 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The welcome-file element contains file name to use as a default welcome file, such as index.html
-
+ * @since 1.0
  */
 public interface WelcomeFile extends EObject{
 	/**
@@ -36,7 +36,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the FileList reference
+	 * @param value The new value of the FileList reference
 	 */
 	void setFileList(WelcomeFileList value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFileList.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFileList.java
index e248b58..5fe6576 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFileList.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/WelcomeFileList.java
@@ -14,10 +14,15 @@
 import org.eclipse.emf.ecore.EObject;
 /**
  * The welcome-file-list contains an ordered list of welcome files elements.
+ * @since 1.0
  */
 public interface WelcomeFileList extends EObject{
 
-public void addFileNamed(String name);
+	/**
+	 * Adds the file whose name is specified in the parameter
+	 * @param name the name of the file to be added
+	 */
+	public void addFileNamed(String name);
 	/**
 	 * @generated This field/method will be replaced during code generation 
 	 * @return The WebApp reference
@@ -26,7 +31,7 @@
 
 	/**
 	 * @generated This field/method will be replaced during code generation 
-	 * @param l The new value of the WebApp reference
+	 * @param value The new value of the WebApp reference
 	 */
 	void setWebApp(WebApp value);
 
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/AuthConstraintImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/AuthConstraintImpl.java
index d457431..8b9eb73 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/AuthConstraintImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/AuthConstraintImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ContextParamImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ContextParamImpl.java
index 9c55ee1..05e984f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ContextParamImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ContextParamImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorCodeErrorPageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorCodeErrorPageImpl.java
index c12895b..9cdd2e7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorCodeErrorPageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorCodeErrorPageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorPageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorPageImpl.java
index ac5efbb..1de1c12 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorPageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ErrorPageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ExceptionTypeErrorPageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ExceptionTypeErrorPageImpl.java
index e3ccb25..2ecd0b7 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ExceptionTypeErrorPageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ExceptionTypeErrorPageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterImpl.java
index 0b69b21..6b2523a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterMappingImpl.java
index 7b10df5..df2cd47 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FilterMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FormLoginConfigImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FormLoginConfigImpl.java
index 44c4011..e2fe772 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FormLoginConfigImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/FormLoginConfigImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/HTTPMethodTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/HTTPMethodTypeImpl.java
index 539c8d3..aa85fce 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/HTTPMethodTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/HTTPMethodTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/InitParamImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/InitParamImpl.java
index 5618bd1..ac412f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/InitParamImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/InitParamImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/JSPTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/JSPTypeImpl.java
index 991a612..281b716 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/JSPTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/JSPTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingImpl.java
index 413625c..bf28991 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingListImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingListImpl.java
index 70c9f6d..4dd2d72 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingListImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LocalEncodingMappingListImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LoginConfigImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LoginConfigImpl.java
index f986588..a0e0863 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LoginConfigImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/LoginConfigImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/MimeMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/MimeMappingImpl.java
index 0acb820..ed541a2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/MimeMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/MimeMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/RoleNameTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/RoleNameTypeImpl.java
index db886f8..e054e3b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/RoleNameTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/RoleNameTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SecurityConstraintImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SecurityConstraintImpl.java
index c5688a6..0193329 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SecurityConstraintImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SecurityConstraintImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletImpl.java
index 60d2965..a1ff941 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletMappingImpl.java
index d74dd96..9f4e0fa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletTypeImpl.java
index 2d7d778..fa31ed2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/ServletTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SessionConfigImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SessionConfigImpl.java
index 55389bf..15520c1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SessionConfigImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/SessionConfigImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/TagLibRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/TagLibRefImpl.java
index 1616dc7..b0cec43 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/TagLibRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/TagLibRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/URLPatternTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/URLPatternTypeImpl.java
index 5dd1468..a48bdaa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/URLPatternTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/URLPatternTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/UserDataConstraintImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/UserDataConstraintImpl.java
index 0e43599..e3a17ca 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/UserDataConstraintImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/UserDataConstraintImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppImpl.java
index 2997897..c9b9e6b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceFactory.java
index a632c03..a9d2bf5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceImpl.java
index 3fa96d1..ca1050f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebAppResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebResourceCollectionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebResourceCollectionImpl.java
index aea3399..7278163 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebResourceCollectionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebResourceCollectionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebTypeImpl.java
index 894bf33..a4682d8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationFactoryImpl.java
index eb17aef..c7c39b8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationPackageImpl.java
index 07cdea8..d07f3c6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WebapplicationPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileImpl.java
index 915f0b7..5aedf21 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileListImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileListImpl.java
index eb97ae3..76b94af 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileListImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/impl/WelcomeFileListImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationAdapterFactory.java
index d46c198..e120435 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,6 @@
 import org.eclipse.jst.j2ee.common.CompatibilityDescriptionGroup;
 import org.eclipse.jst.j2ee.common.DescriptionGroup;
 import org.eclipse.jst.j2ee.common.JNDIEnvRefsGroup;
-import org.eclipse.jst.j2ee.common.Listener;
 import org.eclipse.jst.j2ee.webapplication.AuthConstraint;
 import org.eclipse.jst.j2ee.webapplication.ContextParam;
 import org.eclipse.jst.j2ee.webapplication.ErrorCodeErrorPage;
@@ -149,9 +148,6 @@
 		public Object caseFilterMapping(FilterMapping object) {
 			return createFilterMappingAdapter();
 		}
-		public Object caseListener(Listener object) {
-			return createListenerAdapter();
-		}
 		public Object caseRoleNameType(RoleNameType object) {
 			return createRoleNameTypeAdapter();
 		}
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationSwitch.java
index 3e6a8e0..e6531f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webapplication/internal/util/WebapplicationSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceConstants.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceConstants.java
index 1091bef..b4fa661 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceInit.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceInit.java
index 05a6fc1..f818636 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceInit.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/WebServiceInit.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupHelper.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupHelper.java
index 3442eff..f13c5c4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupItem.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupItem.java
index a72908b..1c35915 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupItem.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/DescriptionGroupItem.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -43,6 +43,15 @@
 
   public static final List VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
 
+  /**
+	 * Returns the '<em><b>Dependency Type</b></em>' literal with the specified value. 
+	 *  <!-- begin-user-doc -->
+	 * @param name passes literal name
+	 * @return literal instance
+	 *  <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
   public static DescriptionGroupItem get(String name)
   {
     for (int i = 0; i < VALUES_ARRAY.length; ++i)
@@ -55,7 +64,15 @@
     }
     return null;
   }
-
+  /**
+	 * Returns the '<em><b>Dependency Type</b></em>' literal with the specified value. 
+	 *  <!-- begin-user-doc -->
+	 * @param value passes literal value
+	 * @return literal instance
+	 *  <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
   public static DescriptionGroupItem get(int value)
   {
     switch (value)
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/QNameHelper.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/QNameHelper.java
index 61d3825..aee7c6d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/QNameHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/util/QNameHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/wsdd/WsddResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/wsdd/WsddResourceFactory.java
index 06ecb48..9e5ce14 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/wsdd/WsddResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/internal/wsdd/WsddResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ComponentScopedRefs.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ComponentScopedRefs.java
index b9edd31..b70474b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ComponentScopedRefs.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ComponentScopedRefs.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -33,7 +33,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientPackage#getComponentScopedRefs()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ComponentScopedRefs extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Component Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Handler.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Handler.java
index 082a31b..7dc7152 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Handler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Handler.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -44,7 +44,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientPackage#getHandler()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface Handler extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Handler Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/PortComponentRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/PortComponentRef.java
index ed8ae9f..a52b733 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/PortComponentRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/PortComponentRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientPackage#getPortComponentRef()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface PortComponentRef extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Port Component Link</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ServiceRef.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ServiceRef.java
index 49cb882..450d93e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ServiceRef.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/ServiceRef.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -47,7 +47,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientPackage#getServiceRef()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ServiceRef extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Service Ref Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesClient.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesClient.java
index edda4cd..a919e20 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesClient.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesClient.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -33,7 +33,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientPackage#getWebServicesClient()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WebServicesClient extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Component Scoped Refs</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesResource.java
index cfe98a5..f943427 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/WebServicesResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,6 +18,14 @@
 
 import org.eclipse.jst.j2ee.internal.common.XMLResource;
 
+/**
+ *@since 1.0
+ */
 public interface WebServicesResource extends XMLResource{
+	
+	/**
+	 * Returns reference to the model object WebServicesClient
+	 * @return reference to the model object WebServicesClient
+	 */
 	public WebServicesClient getWebServicesClient();
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientFactory.java
index 408cd78..e2c8f8c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientPackage
  * @generated
- */
+ * @since 1.0 */
 public interface Webservice_clientFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -77,6 +77,8 @@
 	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
 	 * <!-- end-user-doc -->
 	 * @return the package supported by this factory.
 	 * @generated
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientPackage.java
index d040d6f..ae01f05 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/Webservice_clientPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,11 +27,20 @@
  *   <li>each enum,</li>
  *   <li>and each data type</li>
  * </ul>
+ * /**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	
+ *
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.wsclient.Webservice_clientFactory
  * @model kind="package"
  * @generated
- */
+ * @since 1.0 */
 public interface Webservice_clientPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ComponentScopedRefsImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ComponentScopedRefsImpl.java
index 1a69f53..b997b9c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ComponentScopedRefsImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ComponentScopedRefsImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/HandlerImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/HandlerImpl.java
index 1089ad4..3fb63ca 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/HandlerImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/HandlerImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/PortComponentRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/PortComponentRefImpl.java
index 9e6bfed..2568f51 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/PortComponentRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/PortComponentRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ServiceRefImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ServiceRefImpl.java
index 69a81e9..1dc330e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ServiceRefImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/ServiceRefImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientImpl.java
index dfe74f0..07903ba 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientResourceFactory.java
index 1c3c9db..5ecb690 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesClientResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesResourceImpl.java
index ea22ddd..d6b5c04 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/WebServicesResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientFactoryImpl.java
index 13cbc65..ac63b49 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientPackageImpl.java
index ed49b5d..a795043 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/impl/Webservice_clientPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientAdapterFactory.java
index 7a17a8c..e4d9fb8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientSwitch.java
index af1035e..ef21019 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsclient/internal/util/Webservice_clientSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DescriptionType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DescriptionType.java
index 23a2c5c..1b9f09a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DescriptionType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DescriptionType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,7 +21,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage#getDescriptionType()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface DescriptionType extends Description{
 // DescriptionType
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DisplayNameType.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DisplayNameType.java
index 7f8ddcf..c130561 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DisplayNameType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/DisplayNameType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,7 +21,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage#getDisplayNameType()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface DisplayNameType extends DisplayName{
 // DisplayNameType
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/InitParam.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/InitParam.java
index bc66ead..488581d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/InitParam.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/InitParam.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -31,7 +31,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage#getInitParam()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface InitParam extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Param Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/PortName.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/PortName.java
index 04ecd73..da84a95 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/PortName.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/PortName.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,7 +27,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage#getPortName()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface PortName extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Port Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPHeader.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPHeader.java
index 5fd4797..09dc599 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPHeader.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPHeader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -26,7 +26,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage#getSOAPHeader()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface SOAPHeader extends QName{
 // SOAPHeader
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPRole.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPRole.java
index 1aea7fd..3114f6e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPRole.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/SOAPRole.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -32,7 +32,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage#getSOAPRole()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface SOAPRole extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Soap Role</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonFactory.java
index 6d8a136..db9c06d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonPackage
  * @generated
- */
+ * @since 1.0 */
 public interface WscommonFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -86,7 +86,9 @@
 	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @return the package supported by this factory.
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonPackage.java
index 610b22b..208125f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/WscommonPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,11 +27,20 @@
  *   <li>each enum,</li>
  *   <li>and each data type</li>
  * </ul>
+ * **
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *	
+ *
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.wscommon.WscommonFactory
  * @model kind="package"
  * @generated
- */
+ * @since 1.0 */
 public interface WscommonPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DescriptionTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DescriptionTypeImpl.java
index 249e13e..7e81561 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DescriptionTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DescriptionTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DisplayNameTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DisplayNameTypeImpl.java
index 2616829..3cb9663 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DisplayNameTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/DisplayNameTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/InitParamImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/InitParamImpl.java
index 133ac58..5b8d04d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/InitParamImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/InitParamImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/PortNameImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/PortNameImpl.java
index 7e6463f..68dd861 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/PortNameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/PortNameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPHeaderImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPHeaderImpl.java
index 73fb791..34105fd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPHeaderImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPHeaderImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPRoleImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPRoleImpl.java
index 3cfe63e..6133293 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPRoleImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/SOAPRoleImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonFactoryImpl.java
index 85f742d..de90c42 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonPackageImpl.java
index 1e5743f..6b7f8a4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/impl/WscommonPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonAdapterFactory.java
index 6df281b..1ae3895 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonSwitch.java
index 6de7418..de51595 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wscommon/internal/util/WscommonSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/BeanLink.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/BeanLink.java
index 0df37b0..4f98b03 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/BeanLink.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/BeanLink.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,7 +21,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getBeanLink()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface BeanLink extends EObject{
  // BeanLink
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/EJBLink.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/EJBLink.java
index 95d6d5a..9b64028 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/EJBLink.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/EJBLink.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getEJBLink()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface EJBLink extends BeanLink{
 	/**
 	 * Returns the value of the '<em><b>Ejb Link</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/Handler.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/Handler.java
index b77dc28..c0db51b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/Handler.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/Handler.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getHandler()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface Handler extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Handler Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/PortComponent.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/PortComponent.java
index 197ef2a..95c61b5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/PortComponent.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/PortComponent.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -48,7 +48,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getPortComponent()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface PortComponent extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Port Component Name</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServiceImplBean.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServiceImplBean.java
index c003ddf..b0036b2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServiceImplBean.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServiceImplBean.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -36,7 +36,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getServiceImplBean()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ServiceImplBean extends EObject{
 	/**
 	 * Returns the value of the '<em><b>EEJB Link</b></em>' containment reference.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServletLink.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServletLink.java
index 6514172..94640df 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServletLink.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/ServletLink.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -36,7 +36,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getServletLink()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ServletLink extends BeanLink{
 	/**
 	 * Returns the value of the '<em><b>Servlet Link</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WSDLPort.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WSDLPort.java
index 6e357ad..277f49d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WSDLPort.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WSDLPort.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -26,7 +26,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getWSDLPort()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLPort extends QName{
  // WSDLPort
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServiceDescription.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServiceDescription.java
index 1f7cbb7..0519c9d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServiceDescription.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServiceDescription.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -51,7 +51,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getWebServiceDescription()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WebServiceDescription extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Jaxrpc Mapping File</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServices.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServices.java
index 0f1e233..1a24dcf 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServices.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WebServices.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -34,7 +34,7 @@
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage#getWebServices()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WebServices extends CompatibilityDescriptionGroup{
 	/**
 	 * Returns the value of the '<em><b>Web Service Descriptions</b></em>' containment reference list.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddFactory.java
index 8860cb2..88060b2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddPackage
  * @generated
- */
+ * @since 1.0 */
 public interface WsddFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -111,9 +111,10 @@
 	BeanLink createBeanLink();
 
 	/**
-	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @return the package supported by this factory.
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddPackage.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddPackage.java
index 5ceb7e7..9628586 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,11 +27,20 @@
  *   <li>each enum,</li>
  *   <li>and each data type</li>
  * </ul>
+ * /**
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made 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.
+ * </p>
+ *
+ *
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.wsdd.WsddFactory
  * @model kind="package"
  * @generated
- */
+ * @since 1.0 */
 public interface WsddPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddResource.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddResource.java
index 2d567c8..98ce79e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/WsddResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,12 +13,33 @@
 
 import org.eclipse.jst.j2ee.internal.common.XMLResource;
 
+/**
+ *@since 1.0
+ */
 public interface WsddResource extends XMLResource
 {
-  public static final int WEB_SERVICE_TYPE = 6;
 
-  WebServices getWebServices();
-  public boolean isWebService1_0();
-  public boolean isWebService1_1();
+	/**
+	 * 
+	 */
+	public static final int WEB_SERVICE_TYPE = 6;
+
+	/**
+	 * Returns reference to the model object WebServices
+	 * @return reference to the model object WebServices 
+	 */
+	WebServices getWebServices();
+	
+	/**
+	 * Returns true if the WebService is of version 1.0
+	 * @return boolean value
+	 */
+	public boolean isWebService1_0();
+	
+	/**
+	 * Returns true if the WebService is of version 1.1
+	 * @return boolean value
+	 */
+	public boolean isWebService1_1();
   
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/BeanLinkImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/BeanLinkImpl.java
index 47e9fc0..0463b16 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/BeanLinkImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/BeanLinkImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/EJBLinkImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/EJBLinkImpl.java
index fb627b6..9a30957 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/EJBLinkImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/EJBLinkImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/HandlerImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/HandlerImpl.java
index 3c20366..63aae1f 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/HandlerImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/HandlerImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/PortComponentImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/PortComponentImpl.java
index 272876f..2b8a1c5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/PortComponentImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/PortComponentImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServiceImplBeanImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServiceImplBeanImpl.java
index 3d9cfc9..e61e173 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServiceImplBeanImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServiceImplBeanImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServletLinkImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServletLinkImpl.java
index 08ea9a4..4b0717a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServletLinkImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/ServletLinkImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WSDLPortImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WSDLPortImpl.java
index 5c0e403..612c3e9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WSDLPortImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WSDLPortImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServiceDescriptionImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServiceDescriptionImpl.java
index b54062d..39349f0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServiceDescriptionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServiceDescriptionImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServicesImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServicesImpl.java
index 3853da9..0355ee6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServicesImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WebServicesImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddFactoryImpl.java
index 5bfba73..85403d0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddPackageImpl.java
index 50640d6..942f5e4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddResourceImpl.java
index 50627eb..a2e3232 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/impl/WsddResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddAdapterFactory.java
index fcbaa77..d718d73 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddSwitch.java b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddSwitch.java
index 272cae4..32d3bc2 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/org/eclipse/jst/j2ee/webservice/wsdd/internal/util/WsddSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/xmlparse.properties b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/xmlparse.properties
index e59a583..a5799e8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/mofj2ee/xmlparse.properties
+++ b/plugins/org.eclipse.jst.j2ee.core/mofj2ee/xmlparse.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2001, 2004 IBM Corporation and others.
+# Copyright (c) 2001, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.core/plugin.xml b/plugins/org.eclipse.jst.j2ee.core/plugin.xml
index d2e8307..b281c5e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.core/plugin.xml
@@ -2,7 +2,7 @@
 <?eclipse version="3.0"?>
 <plugin>
 
-     <extension-point id="ejbModelExtender" name="ejbModelExtender"/>
+     <extension-point id="ejbModelExtender" name="ejbModelExtender" schema="schema/ejbModelExtender.exsd"/>
 
 <!--J2EEInit-->
 <!--============================-->
diff --git a/plugins/org.eclipse.jst.j2ee.core/schema/ejbModelExtender.exsd b/plugins/org.eclipse.jst.j2ee.core/schema/ejbModelExtender.exsd
new file mode 100644
index 0000000..78c0005
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.core/schema/ejbModelExtender.exsd
@@ -0,0 +1,111 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- Schema file written by PDE -->
+<schema targetNamespace="org.eclipse.jst.j2ee.core">
+<annotation>
+      <appInfo>
+         <meta.schema plugin="org.eclipse.jst.j2ee.core" id="ejbModelExtender" name="EJB Model Extender"/>
+      </appInfo>
+      <documentation>
+         This extension point allows for a helper to be contributed for deriving the JNDI name of enterprise beans, and for inheritance support.  The helper can be plugged in by application
+server vendors.
+      </documentation>
+   </annotation>
+
+   <element name="extension">
+      <complexType>
+         <sequence>
+            <element ref="ejbModelExtender"/>
+         </sequence>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+                  a fully qualified identifier of the target extension point
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  an optional identifier of the extension instance
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+                  an optional name of the extension instance
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="ejbModelExtender">
+      <complexType>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="extensionClass" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="since"/>
+      </appInfo>
+      <documentation>
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="examples"/>
+      </appInfo>
+      <documentation>
+         
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="apiInfo"/>
+      </appInfo>
+      <documentation>
+         
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="implementation"/>
+      </appInfo>
+      <documentation>
+         
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="copyright"/>
+      </appInfo>
+      <documentation>
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
+      </documentation>
+   </annotation>
+
+</schema>
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ConstructorParameterOrder.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ConstructorParameterOrder.java
index f905a8d..d6df64a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ConstructorParameterOrder.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ConstructorParameterOrder.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -35,7 +35,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getConstructorParameterOrder()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ConstructorParameterOrder extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ElementName.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ElementName.java
index 1f32e08..8059fd3 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ElementName.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ElementName.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -34,7 +34,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getElementName()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ElementName extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ExceptionMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ExceptionMapping.java
index 6b96671..5a1f246 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ExceptionMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ExceptionMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getExceptionMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ExceptionMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/InterfaceMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/InterfaceMapping.java
index 1d40f40..b6a996a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/InterfaceMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/InterfaceMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -21,7 +21,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getInterfaceMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface InterfaceMapping extends EObject{
  // InterfaceMapping
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaWSDLMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaWSDLMapping.java
index 9387618..208d931 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaWSDLMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaWSDLMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getJavaWSDLMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface JavaWSDLMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaXMLTypeMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaXMLTypeMapping.java
index c6d22fe..157a289 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaXMLTypeMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JavaXMLTypeMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getJavaXMLTypeMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface JavaXMLTypeMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapFactory.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapFactory.java
index bdc0b95..6039bde 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,7 @@
  * <!-- end-user-doc -->
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage
  * @generated
- */
+ * @since 1.0 */
 public interface JaxrpcmapFactory extends EFactory{
 	/**
 	 * The singleton instance of the factory.
@@ -230,7 +230,9 @@
 	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
-   * <!-- end-user-doc -->
+	 * This method is NOT api, and may change in future releases.  
+	 * EMF package classes should be access via their "eINSTANCE" static fields
+	 * <!-- end-user-doc -->
 	 * @return the package supported by this factory.
 	 * @generated
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapPackage.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapPackage.java
index 9e03cd6..75b7097 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapPackage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -30,7 +30,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapFactory
  * @model kind="package"
  * @generated
- */
+ * @since 1.0 */
 public interface JaxrpcmapPackage extends EPackage{
 	/**
 	 * The package name.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResource.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResource.java
index 4b55750..e907d86 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResource.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResource.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResourceFactory.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResourceFactory.java
index 4ad3711..7a71c79 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResourceFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/JaxrpcmapResourceFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/MethodParamPartsMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/MethodParamPartsMapping.java
index a2d8e72..c144730 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/MethodParamPartsMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/MethodParamPartsMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -36,7 +36,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getMethodParamPartsMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface MethodParamPartsMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PackageMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PackageMapping.java
index 81ce446..b1239f6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PackageMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PackageMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -35,7 +35,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getPackageMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface PackageMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PortMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PortMapping.java
index f887103..7941c05 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PortMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/PortMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -35,7 +35,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getPortMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface PortMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/RootTypeQname.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/RootTypeQname.java
index b7e0b14..f79e3ff 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/RootTypeQname.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/RootTypeQname.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,7 +27,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getRootTypeQname()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface RootTypeQname extends QName{
 // RootTypeQname
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointInterfaceMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointInterfaceMapping.java
index 12f7423..a7ad0c8 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointInterfaceMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointInterfaceMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,7 +40,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getServiceEndpointInterfaceMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ServiceEndpointInterfaceMapping extends InterfaceMapping{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointMethodMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointMethodMapping.java
index 0983bd1..3a55943 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointMethodMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceEndpointMethodMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -42,7 +42,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getServiceEndpointMethodMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ServiceEndpointMethodMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceInterfaceMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceInterfaceMapping.java
index 2ce06ac..dfa97dc 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceInterfaceMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/ServiceInterfaceMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getServiceInterfaceMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface ServiceInterfaceMapping extends InterfaceMapping{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/VariableMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/VariableMapping.java
index 3de95cb..65cc577 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/VariableMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/VariableMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -39,7 +39,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getVariableMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface VariableMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLBinding.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLBinding.java
index 07e2892..9323e26 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLBinding.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLBinding.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,7 +28,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLBinding()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLBinding extends QName{
 // WSDLBinding
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessage.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessage.java
index a195855..b3278a0 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessage.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,7 +27,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLMessage()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLMessage extends QName{
 // WSDLMessage
 }
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessageMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessageMapping.java
index 6e4892f..5b662fa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessageMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessageMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -42,7 +42,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLMessageMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLMessageMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessagePartName.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessagePartName.java
index 620ef6a..21ce4c9 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessagePartName.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLMessagePartName.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,7 +28,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLMessagePartName()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLMessagePartName extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLOperation.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLOperation.java
index 85ef670..278b01b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,7 +28,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLOperation()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLOperation extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLPortType.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLPortType.java
index a519d06..57a0a82 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLPortType.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLPortType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,7 +28,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLPortType()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLPortType extends QName{
 //	 WSDLPortType
 } 
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLReturnValueMapping.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLReturnValueMapping.java
index 48afa76..3caa873 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLReturnValueMapping.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLReturnValueMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -38,7 +38,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLReturnValueMapping()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLReturnValueMapping extends EObject{
 	/**
 	 * Returns the value of the '<em><b>Id</b></em>' attribute.
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLServiceName.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLServiceName.java
index 2545e24..9e73d70 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLServiceName.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/WSDLServiceName.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,7 +27,7 @@
  * @see org.eclipse.jst.j2ee.webservice.jaxrpcmap.JaxrpcmapPackage#getWSDLServiceName()
  * @model
  * @generated
- */
+ * @since 1.0 */
 public interface WSDLServiceName extends QName{
 	//Default
 } // WSDLServiceName
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ConstructorParameterOrderImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ConstructorParameterOrderImpl.java
index ea4cc67..5cd93cd 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ConstructorParameterOrderImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ConstructorParameterOrderImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ElementNameImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ElementNameImpl.java
index 374f964..b87f782 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ElementNameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ElementNameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ExceptionMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ExceptionMappingImpl.java
index c0fc387..486b3db 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ExceptionMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ExceptionMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/InterfaceMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/InterfaceMappingImpl.java
index 7372d3e..6751e12 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/InterfaceMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/InterfaceMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaWSDLMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaWSDLMappingImpl.java
index 695de66..cb4fb3e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaWSDLMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaWSDLMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaXMLTypeMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaXMLTypeMappingImpl.java
index 0bf19b4..fe14218 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaXMLTypeMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JavaXMLTypeMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapFactoryImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapFactoryImpl.java
index 81db4d3..a2d2e80 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapPackageImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapPackageImpl.java
index 5cc39b3..4a20afa 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapResourceImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapResourceImpl.java
index 0df71a8..ab78fec 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapResourceImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/JaxrpcmapResourceImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/MethodParamPartsMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/MethodParamPartsMappingImpl.java
index 133753f..a00628d 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/MethodParamPartsMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/MethodParamPartsMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PackageMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PackageMappingImpl.java
index 2db72de..fdce857 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PackageMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PackageMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PortMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PortMappingImpl.java
index 3377e1b..062428c 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PortMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/PortMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/RootTypeQnameImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/RootTypeQnameImpl.java
index c0c0043..e98bea6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/RootTypeQnameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/RootTypeQnameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointInterfaceMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointInterfaceMappingImpl.java
index e4dc934..a04fc2a 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointInterfaceMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointInterfaceMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointMethodMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointMethodMappingImpl.java
index e53f62a..d4f16c4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointMethodMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceEndpointMethodMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceInterfaceMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceInterfaceMappingImpl.java
index 65832ea..6c3eb1e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceInterfaceMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/ServiceInterfaceMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/VariableMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/VariableMappingImpl.java
index 637b330..4be70cf 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/VariableMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/VariableMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLBindingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLBindingImpl.java
index 85a1d26..d5216f1 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLBindingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLBindingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageImpl.java
index 99e2ecc..3496947 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageMappingImpl.java
index b6ed1b9..b131ad6 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessageMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessagePartNameImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessagePartNameImpl.java
index 114aa2f..8e9019b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessagePartNameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLMessagePartNameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLOperationImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLOperationImpl.java
index 83a296c..e86751b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLOperationImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLOperationImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLPortTypeImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLPortTypeImpl.java
index 749e436..847aa5e 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLPortTypeImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLPortTypeImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLReturnValueMappingImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLReturnValueMappingImpl.java
index 237e4c1..ac5247b 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLReturnValueMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLReturnValueMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLServiceNameImpl.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLServiceNameImpl.java
index ad74056..bcf33e5 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLServiceNameImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/impl/WSDLServiceNameImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapAdapterFactory.java
index 326e947..a8419f4 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapSwitch.java b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapSwitch.java
index 6052dcb..b43e557 100644
--- a/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee.core/webservices/org/eclipse/jst/j2ee/webservice/jaxrpcmap/internal/util/JaxrpcmapSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/.cvsignore b/plugins/org.eclipse.jst.j2ee.jca.ui/.cvsignore
index 7259af6..ec7a42c 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/.cvsignore
@@ -3,3 +3,4 @@
 jcaui.jar
 temp.folder
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.j2ee.jca.ui/META-INF/MANIFEST.MF
index 8db4ff2..49c35a3 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/META-INF/MANIFEST.MF
@@ -21,5 +21,8 @@
  org.eclipse.jst.j2ee.jca,
  org.eclipse.jst.j2ee.core,
  org.eclipse.core.resources,
- org.eclipse.wst.common.navigator.workbench
+ org.eclipse.wst.common.navigator.workbench,
+ org.eclipse.wst.common.project.facet.core,
+ org.eclipse.wst.common.project.facet.ui,
+ org.eclipse.wst.web.ui
 Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/build.properties b/plugins/org.eclipse.jst.j2ee.jca.ui/build.properties
index 8bebbfa..f57586f 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/build.properties
@@ -1,3 +1,13 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
 source.. = jca_ui/,\
                    property_files/
 output.. = bin/
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ExportRARAction.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ExportRARAction.java
index e87156f..b970f25 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ExportRARAction.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ExportRARAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -31,7 +31,7 @@
  */
 public class ExportRARAction extends BaseAction {
 
-	private String label = JCAUIMessages.getResourceString(IConnectorArchiveConstants.CONNECTOR_EXPORT_ACTION_LABEL);
+	private String label = JCAUIMessages.connector_export_action_label_ui_;
 	private static final String ICON = "export_rar_wiz"; //$NON-NLS-1$
 
 	public ExportRARAction() {
@@ -56,4 +56,4 @@
 		dialog.open();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ImportRARAction.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ImportRARAction.java
index 4ed33c1..93d0d66 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ImportRARAction.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/ImportRARAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -56,4 +56,4 @@
 		dialog.create();
 		dialog.open();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/NewConnectorComponentAction.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/NewConnectorComponentAction.java
index 37a7b62..884a2f9 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/NewConnectorComponentAction.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/actions/NewConnectorComponentAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 import org.eclipse.jst.j2ee.internal.actions.AbstractOpenWizardWorkbenchAction;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
 import org.eclipse.jst.j2ee.jca.ui.internal.util.JCAUIMessages;
-import org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorComponentCreationWizard;
+import org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorProjectWizard;
 import org.eclipse.ui.IWorkbench;
 
 
@@ -26,7 +26,7 @@
 public class NewConnectorComponentAction extends AbstractOpenWizardWorkbenchAction {
 
 	// TODO MDE 02-28 Find correct label
-	public static String LABEL = JCAUIMessages.getResourceString(JCAUIMessages.JCA_MODULE_WIZ_TITLE); //$NON-NLS-1$
+	public static String LABEL = JCAUIMessages.JCA_MODULE_WIZ_TITLE;
 	private static final String ICON = "newear_wiz"; //$NON-NLS-1$
 
 	/**
@@ -58,7 +58,7 @@
 	 * @return Wizard
 	 */
 	protected Wizard createWizard() {
-		return new ConnectorComponentCreationWizard();
+		return new ConnectorProjectWizard();
 	}// createWizard
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/plugin/JCAUIPlugin.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/plugin/JCAUIPlugin.java
index 4512bc9..083a42d 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/plugin/JCAUIPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/plugin/JCAUIPlugin.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Nov 15, 2004
  *
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/util/JCAUIMessages.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/util/JCAUIMessages.java
index 0a7d07d..9d747f3 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/util/JCAUIMessages.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/util/JCAUIMessages.java
@@ -1,61 +1,54 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.ui.internal.util;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.wst.common.frameworks.internal.Messages;
+import org.eclipse.osgi.util.NLS;
 
 
-public class JCAUIMessages extends Messages {
+public class JCAUIMessages extends NLS {
 
-	public static final String IMAGE_LOAD_ERROR = "0"; //$NON-NLS-1$
-	public static final String JCA_MODULE_WIZ_TITLE = "1"; //$NON-NLS-1$
-	public static final String JCA_VERSION_LBL = "2"; //$NON-NLS-1$
-	public static final String JCA_MODULE_MAIN_PG_TITLE = "3"; //$NON-NLS-1$
-	public static final String JCA_MODULE_MAIN_PG_DESC = "4"; //$NON-NLS-1$
-	public static final String JCA_IMPORT_MAIN_PG_DESC = "5"; //$NON-NLS-1$
-	public static final String JCA_IMPORT_MAIN_PG_TITLE = "6"; //$NON-NLS-1$
-	public static final String JCA_FILE_LBL = "7"; //$NON-NLS-1$
-	public static final String JCA_MODULE_LBL = "8"; //$NON-NLS-1$
-	public static final String JCA_EXPORT_MAIN_PG_TITLE = "9"; //$NON-NLS-1$
-	public static final String JCA_EXPORT_MAIN_PG_DESC = "10"; //$NON-NLS-1$
-
-	private static final JCAUIMessages INSTANCE = new JCAUIMessages();
-
+	private static final String BUNDLE_NAME = "jca_ui";//$NON-NLS-1$
 
 	private JCAUIMessages() {
-		super();
+		// Do not instantiate
 	}
 
-	/**
-	 * Returns the string from the resource bundle, or 'key' if not found.
-	 */
-	public static String getResourceString(String key) {
-		return INSTANCE.doGetResourceString(key);
+	public static String connector_export_action_label_ui_;
+	public static String _9;
+	public static String _8;
+	public static String _7;
+	public static String _6;
+	public static String _5;
+	public static String _4;
+	public static String _3;
+	public static String _2;
+	public static String _10;
+	public static String _1;
+	public static String _0;
+	public static String _11;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, JCAUIMessages.class);
 	}
 
-	public static String getResourceString(String key, Object[] args) {
-		return INSTANCE.doGetResourceString(key, args);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.common.frameworks.internal.Messages#initializeBundle()
-	 */
-	protected void initializeBundle() {
-		try {
-			resourceBundle = ResourceBundle.getBundle("jca_ui"); //$NON-NLS-1$
-		} catch (MissingResourceException x) {
-			//Ignore
-		}
-	}
-}
\ No newline at end of file
+	public static final String IMAGE_LOAD_ERROR = _0;
+	public static final String JCA_MODULE_WIZ_TITLE = _1;
+	public static final String JCA_VERSION_LBL = _2;
+	public static final String JCA_MODULE_MAIN_PG_TITLE = _3;
+	public static final String JCA_MODULE_MAIN_PG_DESC = _4;
+	public static final String JCA_IMPORT_MAIN_PG_DESC = _5;
+	public static final String JCA_IMPORT_MAIN_PG_TITLE = _6;
+	public static final String JCA_FILE_LBL = _7;
+	public static final String JCA_MODULE_LBL = _8;
+	public static final String JCA_EXPORT_MAIN_PG_TITLE = _9;
+	public static final String JCA_EXPORT_MAIN_PG_DESC = _10;
+	public static final String JCA_FACET_CONFIGURATION= _11;
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizard.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizard.java
index edd4857..a80d9c9 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizard.java
@@ -1,13 +1,13 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
- *******************************************************************************/ 
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.ui.internal.wizard;
 
 import org.eclipse.core.runtime.IExecutableExtension;
@@ -66,7 +66,7 @@
 	 * @see J2EEArtifactCreationWizard#doInit()
 	 */
 	protected void doInit() {
-		setWindowTitle(JCAUIMessages.getResourceString(JCAUIMessages.JCA_MODULE_WIZ_TITLE));
+		setWindowTitle(JCAUIMessages.JCA_MODULE_WIZ_TITLE);
 		setDefaultPageImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.JCA_PROJECT_WIZARD_BANNER));
 		preFillSelectedEARProject();
 	}
@@ -86,4 +86,4 @@
     protected IDataModelProvider getDefaultProvider() {
         return new ConnectorComponentCreationDataModelProvider();
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizardPage.java
index fd39e75..f095b8e 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentCreationWizardPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -26,13 +26,13 @@
 	 */
 	public ConnectorComponentCreationWizardPage(IDataModel model, String pageName) {
 		super(model, pageName);
-		setTitle(JCAUIMessages.getResourceString(JCAUIMessages.JCA_MODULE_MAIN_PG_TITLE));
-		setDescription(JCAUIMessages.getResourceString(JCAUIMessages.JCA_MODULE_MAIN_PG_DESC));
+		setTitle(JCAUIMessages.JCA_MODULE_MAIN_PG_TITLE);
+		setDescription(JCAUIMessages.JCA_MODULE_MAIN_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.JCA_PROJECT_WIZARD_BANNER));
 	}
 
 	protected String getVersionLabel() {
-		return JCAUIMessages.getResourceString(JCAUIMessages.JCA_VERSION_LBL);
+		return JCAUIMessages.JCA_VERSION_LBL;
 	}
 
 	protected String[] getValidationPropertyNames() {
@@ -55,4 +55,4 @@
 ////		createAnnotationsGroup(advanced);
 //		super.createMultipleModulesComposite(advanced);
 //	}	
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentExportWizard.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentExportWizard.java
index 54a7a5b..ef2ea40 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentExportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentExportWizard.java
@@ -1,13 +1,13 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
- *******************************************************************************/ 
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.ui.internal.wizard;
 
 import org.eclipse.jst.j2ee.internal.jca.operations.ConnectorComponentExportDataModelProvider;
@@ -74,4 +74,4 @@
 	protected void doInit() {
 		setDefaultPageImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.JCA_EXPORT_WIZARD_BANNER));
 	} 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportPage.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportPage.java
index f0641a0..b420d10 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -22,13 +22,13 @@
 
 	public ConnectorComponentImportPage(IDataModel model, String pageName) {
 		super(model, pageName);
-		setTitle(JCAUIMessages.getResourceString(JCAUIMessages.JCA_IMPORT_MAIN_PG_TITLE));
-		setDescription(JCAUIMessages.getResourceString(JCAUIMessages.JCA_IMPORT_MAIN_PG_DESC));
+		setTitle(JCAUIMessages.JCA_IMPORT_MAIN_PG_TITLE);
+		setDescription(JCAUIMessages.JCA_IMPORT_MAIN_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.JCA_IMPORT_WIZARD_BANNER));
 	}
 
 	protected String getFileImportLabel() {
-		return JCAUIMessages.getResourceString(JCAUIMessages.JCA_FILE_LBL);
+		return JCAUIMessages.JCA_FILE_LBL;
 	}
 
 	protected String[] getFilterExpression() {
@@ -40,7 +40,7 @@
 	}
 
 	protected String getProjectImportLabel() {
-		return JCAUIMessages.getResourceString(JCAUIMessages.JCA_MODULE_LBL);
+		return JCAUIMessages.JCA_MODULE_LBL;
 	}
 
 	protected Composite createTopLevelComposite(Composite parent) {
@@ -50,4 +50,4 @@
 	protected String getInfopopID() {
 		return IJ2EEUIContextIds.IMPORT_RAR_WIZARD_PAGE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportWizard.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportWizard.java
index fc0556a..56b55ab 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorComponentImportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -79,4 +79,4 @@
 		return new ConnectorComponentImportDataModelProvider();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorFacetInstallPage.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorFacetInstallPage.java
new file mode 100644
index 0000000..b27b55f
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorFacetInstallPage.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.jca.ui.internal.wizard;
+
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEModuleFacetInstallPage;
+import org.eclipse.jst.j2ee.jca.project.facet.IConnectorFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.jca.ui.internal.util.JCAUIMessages;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+
+public class ConnectorFacetInstallPage extends J2EEModuleFacetInstallPage implements IConnectorFacetInstallDataModelProperties {
+
+	private Label configFolderLabel;
+	private Text configFolder;
+	
+	public ConnectorFacetInstallPage() {
+		super(IModuleConstants.JST_CONNECTOR_MODULE);
+		setTitle(JCAUIMessages.JCA_MODULE_MAIN_PG_TITLE);
+		setDescription(JCAUIMessages.JCA_FACET_CONFIGURATION);
+	}
+
+	protected String[] getValidationPropertyNames() {
+		return new String[]{EAR_PROJECT_NAME, CONFIG_FOLDER};
+	}
+
+	protected Composite createTopLevelComposite(Composite parent) {
+		final Composite composite = new Composite(parent, SWT.NONE);
+		composite.setLayout(new GridLayout(1, false));
+
+		//setupEarControl(composite);
+		
+		configFolderLabel = new Label(composite, SWT.NONE);
+		configFolderLabel.setText(J2EEUIMessages.getResourceString(J2EEUIMessages.SOURCEFOLDER));
+		configFolderLabel.setLayoutData(gdhfill());
+
+		configFolder = new Text(composite, SWT.BORDER);
+		configFolder.setLayoutData(gdhfill());
+		configFolder.setData("label", configFolderLabel); //$NON-NLS-1$
+		synchHelper.synchText(configFolder, CONFIG_FOLDER, null);
+		
+		return composite;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorProjectFirstPage.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorProjectFirstPage.java
new file mode 100644
index 0000000..48d663f
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorProjectFirstPage.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.jca.ui.internal.wizard;
+
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPluginIcons;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEComponentFacetCreationWizardPage;
+import org.eclipse.jst.j2ee.jca.ui.internal.util.JCAUIMessages;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class ConnectorProjectFirstPage extends J2EEComponentFacetCreationWizardPage {
+
+	public ConnectorProjectFirstPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+		setTitle(JCAUIMessages.JCA_MODULE_MAIN_PG_TITLE);
+		setDescription(JCAUIMessages.JCA_MODULE_MAIN_PG_DESC);
+		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.JCA_PROJECT_WIZARD_BANNER));
+	}
+
+	protected String getModuleFacetID() {
+		return J2EEProjectUtilities.JCA;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorProjectWizard.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorProjectWizard.java
new file mode 100644
index 0000000..9945476
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/ConnectorProjectWizard.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.jca.ui.internal.wizard;
+
+import java.net.URL;
+
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.jst.j2ee.jca.project.facet.ConnectorFacetProjectCreationDataModelProvider;
+import org.eclipse.jst.j2ee.jca.ui.internal.util.JCAUIMessages;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+import org.eclipse.wst.web.ui.internal.wizards.NewProjectDataModelFacetWizard;
+import org.osgi.framework.Bundle;
+
+public class ConnectorProjectWizard extends NewProjectDataModelFacetWizard {
+
+	public ConnectorProjectWizard(IDataModel model) {
+		super(model);
+		setWindowTitle(JCAUIMessages.JCA_MODULE_WIZ_TITLE);
+	}
+	
+	public ConnectorProjectWizard() {
+		super();
+		setWindowTitle(JCAUIMessages.JCA_MODULE_WIZ_TITLE);
+	}
+
+	protected IDataModel createDataModel() {
+		return DataModelFactory.createDataModel(new ConnectorFacetProjectCreationDataModelProvider());
+	}
+
+	protected ImageDescriptor getDefaultPageImageDescriptor() {
+		final Bundle bundle = Platform.getBundle(J2EEUIPlugin.PLUGIN_ID);
+		final URL url = bundle.getEntry("icons/full/wizban/connector_wiz.gif"); //$NON-NLS-1$
+		return ImageDescriptor.createFromURL(url);
+	}
+
+	protected IFacetedProjectTemplate getTemplate() {
+		return ProjectFacetsManager.getTemplate("template.jst.connector"); //$NON-NLS-1$
+	}
+
+	protected IWizardPage createFirstPage() {
+		return new ConnectorProjectFirstPage(model, "first.page"); //$NON-NLS-1$
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/RARExportPage.java b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/RARExportPage.java
index 3443a93..8cd469d 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/RARExportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/jca_ui/org/eclipse/jst/j2ee/jca/ui/internal/wizard/RARExportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,8 +40,8 @@
 	 */
 	public RARExportPage(IDataModel model, String pageName, IStructuredSelection selection) {
 		super(model, pageName, selection);
-		setTitle(JCAUIMessages.getResourceString(JCAUIMessages.JCA_EXPORT_MAIN_PG_TITLE));
-		setDescription(JCAUIMessages.getResourceString(JCAUIMessages.JCA_EXPORT_MAIN_PG_DESC));
+		setTitle(JCAUIMessages.JCA_EXPORT_MAIN_PG_TITLE);
+		setDescription(JCAUIMessages.JCA_EXPORT_MAIN_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.JCA_EXPORT_WIZARD_BANNER));
 
 	}
@@ -90,4 +90,4 @@
     protected String getCompnentID() {
         return "JST_CONNECTOR"; //$NON-NLS-1$
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.properties b/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.properties
index c2ced77..a2d96c6 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.properties
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -20,4 +20,4 @@
 connector.export.action.label_ui_=Export RAR File...
 connector_module_ui_=Connector Project
 new.connector.module.description_ui_=Create a J2EE connector project
-connectors.actionSet=J2C
\ No newline at end of file
+connectors.actionSet=J2C
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.xml b/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.xml
index e16a908..f4bcbfc 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/plugin.xml
@@ -37,10 +37,10 @@
             name="%connector_module_ui_"
             icon="icons/full/ctool16/newconnectionprj_wiz.gif"
             category="org.eclipse.jst.j2ee.internal"
-            class="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorComponentCreationWizard"
+            class="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorProjectWizard"
             project="true"
             finalPerspective="org.eclipse.jst.j2ee.J2EEPerspective"
-            id="org.eclipse.jst.j2ee.jca.ui.ConnectorComponentCreationWizard">
+            id="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorProjectWizard">
          <description>
             %new.connector.module.description_ui_
          </description>
@@ -139,7 +139,7 @@
       <!-- Connector New -->
         <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.j2ee.jca.ui.ConnectorComponentCreationWizard">
+            wizardId="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorProjectWizard">
          <enablement>
          <or>
                <objectClass
@@ -268,4 +268,20 @@
          </enablement>
        </commonWizard>
     </extension>
+    
+    <extension point="org.eclipse.wst.common.project.facet.ui.wizard">
+    
+     <wizard-pages facet="jst.connector" version="1.0">
+      <install>
+        <page class="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorFacetInstallPage"/>
+      </install>
+     </wizard-pages>
+    
+     <wizard-pages facet="jst.connector" version="1.5">
+      <install>
+        <page class="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorFacetInstallPage"/>
+      </install>
+     </wizard-pages>
+    </extension>
+    
 </plugin>
diff --git a/plugins/org.eclipse.jst.j2ee.jca.ui/property_files/jca_ui.properties b/plugins/org.eclipse.jst.j2ee.jca.ui/property_files/jca_ui.properties
index 69ae412..f8ff5fa 100644
--- a/plugins/org.eclipse.jst.j2ee.jca.ui/property_files/jca_ui.properties
+++ b/plugins/org.eclipse.jst.j2ee.jca.ui/property_files/jca_ui.properties
@@ -1,22 +1,23 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-0=Failed to find the image "{0}".
-1=New Connector Project
-2=J2C version:
-3=Connector Project
-4=Create a standalone Connector module or add it to a new or existing Enterprise Application project.
-5=Import a Connector module from the file system
-6=Connector Import
-7=Connector file:
-8=Connector module:
-9=Connector Export
-10=Export Connector module to the local file system.
-connector.export.action.label_ui_=Export RAR File...
+_0=Failed to find the image "{0}".
+_1=New Connector Project
+_2=J2C version:
+_3=Connector Project
+_4=Create a standalone Connector module or add it to a new or existing Enterprise Application project.
+_5=Import a Connector module from the file system
+_6=Connector Import
+_7=Connector file:
+_8=Connector module:
+_9=Connector Export
+_10=Export Connector module to the local file system.
+_11=Configure Connector module settings.
+connector_export_action_label_ui_=Export RAR File...
diff --git a/plugins/org.eclipse.jst.j2ee.jca/.cvsignore b/plugins/org.eclipse.jst.j2ee.jca/.cvsignore
index c72ac7d..d369c9a 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.jca/.cvsignore
@@ -3,3 +3,4 @@
 runtime
 temp.folder
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.jca/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.j2ee.jca/META-INF/MANIFEST.MF
index ceea42a..02635d2 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.j2ee.jca/META-INF/MANIFEST.MF
@@ -13,7 +13,8 @@
  org.eclipse.jst.j2ee.internal.jca.validation,
  org.eclipse.jst.j2ee.jca.internal.module.util,
  org.eclipse.jst.j2ee.jca.internal.plugin,
- org.eclipse.jst.j2ee.jca.modulecore.util
+ org.eclipse.jst.j2ee.jca.modulecore.util,
+ org.eclipse.jst.j2ee.jca.project.facet
 Require-Bundle: org.eclipse.jst.j2ee,
  org.eclipse.jem.workbench,
  org.eclipse.wst.common.emfworkbench.integration,
diff --git a/plugins/org.eclipse.jst.j2ee.jca/build.properties b/plugins/org.eclipse.jst.j2ee.jca/build.properties
index 943fdf5..cdbdb39 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.jca/build.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/ConnectorHelper.java b/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/ConnectorHelper.java
index dceafe5..f84b25c 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/ConnectorHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/ConnectorHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -79,4 +79,4 @@
 		}
 		return "rar.xml"; //$NON-NLS-1$
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/UIConnectorValidator.java b/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/UIConnectorValidator.java
index 44e1606..3ba7264 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/UIConnectorValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca-validation/org/eclipse/jst/j2ee/internal/jca/validation/UIConnectorValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -81,4 +81,4 @@
 //	}// validateDocTypeVsNature
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JCAResourceHandler.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JCAResourceHandler.java
index 5d6749a..98429cf 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JCAResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JCAResourceHandler.java
@@ -1,65 +1,39 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * Created on May 24, 2004
  *
- * TODO To change the template for this generated file go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.internal.plugin;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-/**
- * @author vijayb
- * 
- * TODO To change the template for this generated type comment go to Window - Preferences - Java -
- * Code Style - Code Templates
- */
-public class JCAResourceHandler {
+public final class JCAResourceHandler extends NLS {
 
-	private static ResourceBundle fgResourceBundle;
+	private static final String BUNDLE_NAME = "rar";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("rar");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private JCAResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String LicenseItemProvider_UI_0;
+	public static String SecurityPermissionItemProvider_UI_0;
+	public static String ConfigPropertyItemProvider_UI_0;
+	public static String _UI_ResourceAdapter_type;
+	public static String _UI_OutboundResourceAdapter_type;
+	public static String _UI_ConnectionDefinition_type;
+	public static String _UI_InboundResourceAdapter_type;
+	public static String _UI_MessageAdapter_type;
+	public static String _UI_MessageListener_type;
+	public static String _UI_ActivationSpec_type;
+	public static String _UI_RequiredConfigPropertyType_type;
+	public static String _UI_AdminObject_type;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, JCAResourceHandler.class);
 	}
-
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaModuleExtensionImpl.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaModuleExtensionImpl.java
index 974ebc2..27df270 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaModuleExtensionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaModuleExtensionImpl.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Sep 29, 2003
  * 
@@ -14,10 +16,11 @@
  */
 package org.eclipse.jst.j2ee.jca.internal.plugin;
 
-import org.eclipse.jst.j2ee.internal.jca.operations.ConnectorComponentCreationDataModelProvider;
+
 import org.eclipse.jst.j2ee.internal.jca.operations.ConnectorComponentImportDataModelProvider;
 import org.eclipse.jst.j2ee.internal.moduleextension.EarModuleExtensionImpl;
 import org.eclipse.jst.j2ee.internal.moduleextension.JcaModuleExtension;
+import org.eclipse.jst.j2ee.jca.project.facet.ConnectorFacetProjectCreationDataModelProvider;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
@@ -58,7 +61,7 @@
 	 * @see org.eclipse.jst.j2ee.internal.internal.moduleextension.EarModuleExtension#createProjectDataModel()
 	 */
 	public IDataModel createProjectDataModel() {
-		return DataModelFactory.createDataModel(new ConnectorComponentCreationDataModelProvider());
+		return DataModelFactory.createDataModel(new ConnectorFacetProjectCreationDataModelProvider());
 	}
 
 	/*
@@ -69,4 +72,4 @@
 	public IDataModel createImportDataModel() {
 		return DataModelFactory.createDataModel(new ConnectorComponentImportDataModelProvider());
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaPlugin.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaPlugin.java
index df43078..c92e99b 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/internal/plugin/JcaPlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -160,4 +160,4 @@
 		return getString(key,substitutions);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDataModelProvider.java
index 228289f..3bdcf68 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDataModelProvider.java
@@ -1,26 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.project.facet;
 
-import java.util.Set;
-
+import org.eclipse.jst.j2ee.internal.common.CreationConstants;
+import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
-import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.J2EEModuleFacetInstallDataModelProvider;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
-public class ConnectorFacetInstallDataModelProvider 
-	extends FacetInstallDataModelProvider
-	implements IConnectorFacetInstallDataModelProperties{
+public class ConnectorFacetInstallDataModelProvider extends J2EEModuleFacetInstallDataModelProvider implements IConnectorFacetInstallDataModelProperties {
 
-	public Set getPropertyNames() {
-		Set names = super.getPropertyNames();
-		names.add(EAR_PROJECT_NAME);
-		names.add(CONFIG_FOLDER);
-		names.add(RUNTIME_TARGET_ID);
-		return names;
+	public Object getDefaultProperty(String propertyName) {
+		if (propertyName.equals(FACET_ID)) {
+			return J2EEProjectUtilities.JCA;
+		} else if (propertyName.equals(CONFIG_FOLDER))
+			return CreationConstants.DEFAULT_CONNECTOR_SOURCE_FOLDER;
+		return super.getDefaultProperty(propertyName);
 	}
 	
-	public Object getDefaultProperty(String propertyName) {
-		if(propertyName.equals(FACET_ID)){
-			return J2EEProjectUtilities.JCA;
-		}
-		return super.getDefaultProperty(propertyName);
+	protected int convertFacetVersionToJ2EEVersion(IProjectFacetVersion version) {
+		return J2EEVersionUtil.convertConnectorVersionStringToJ2EEVersionID(version.getVersionString());
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDelegate.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDelegate.java
index af48048..e66536f 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetInstallDelegate.java
@@ -1,7 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.project.facet;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IWorkspace;
@@ -10,25 +24,38 @@
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
+import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.project.facet.WtpUtils;
+import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
+import org.eclipse.jst.j2ee.application.ApplicationPackage;
+import org.eclipse.jst.j2ee.application.Module;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationDataModelProvider;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationOp;
+import org.eclipse.jst.j2ee.application.internal.operations.IAddComponentToEnterpriseApplicationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.J2EEConstants;
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
 import org.eclipse.jst.j2ee.jca.modulecore.util.ConnectorArtifactEdit;
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.J2EEFacetInstallDelegate;
-import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
 import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.FacetDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 
-public class ConnectorFacetInstallDelegate extends J2EEFacetInstallDelegate implements IDelegate{
+public class ConnectorFacetInstallDelegate extends J2EEFacetInstallDelegate implements IDelegate {
 
 	public void execute(IProject project, IProjectFacetVersion fv, Object config, IProgressMonitor monitor) throws CoreException {
 		if (monitor != null) {
@@ -36,8 +63,8 @@
 		}
 
 		try {
-			IDataModel model = (IDataModel)config;
-			
+			IDataModel model = (IDataModel) config;
+
 			final IJavaProject jproj = JavaCore.create(project);
 
 			// Add WTP natures.
@@ -54,34 +81,39 @@
 			final IVirtualComponent c = ComponentCore.createComponent(project);
 
 			c.create(0, null);
-			c.setMetaProperty("java-output-path","/build/classes/");
+			c.setMetaProperty("java-output-path", "/build/classes/");
 
 
-        
+
 			final IVirtualFolder root = c.getRootFolder();
-			String configFolder = model.getStringProperty(IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER);
-			root.createLink(new Path("/" + configFolder), 0, null);
+			IFolder sourceFolder = null;
+			String configFolder = null;
+			if (root.getProjectRelativePath().segmentCount() == 0) {
+				configFolder = model.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER);
+				root.createLink(new Path("/" + configFolder), 0, null);
 
-			
-			String connectorFolderName = model.getStringProperty(IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER);
-			IPath connectorFolderpath = pjpath.append( connectorFolderName );
-			
-			IFolder connectorFolder = ws.getRoot().getFolder( connectorFolderpath );
-			
-			if (!connectorFolder.getFile(J2EEConstants.RAR_DD_URI).exists()) {
+
+				String configFolderName = model.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER);
+				IPath configFolderpath = pjpath.append(configFolderName);
+
+				sourceFolder = ws.getRoot().getFolder(configFolderpath);
+			} else
+				sourceFolder = project.getFolder(root.getProjectRelativePath());
+
+			if (!sourceFolder.getFile(J2EEConstants.RAR_DD_URI).exists()) {
 				String ver = model.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
-	    		int nVer = J2EEVersionUtil.convertVersionStringToInt(ver);
-				ConnectorArtifactEdit.createDeploymentDescriptor( project, nVer );
+				int nVer = J2EEVersionUtil.convertVersionStringToInt(ver);
+				ConnectorArtifactEdit.createDeploymentDescriptor(project, nVer);
 			}
 
 			try {
-				createManifest(project, configFolder, monitor);
- 			} catch (InvocationTargetException e) {
+				createManifest(project, sourceFolder, monitor);
+			} catch (InvocationTargetException e) {
 				Logger.getLogger().logError(e);
 			} catch (InterruptedException e) {
 				Logger.getLogger().logError(e);
 			}
-			
+
 			// Setup the classpath.
 			ClasspathHelper.removeClasspathEntries(project, fv);
 
@@ -92,28 +124,73 @@
 
 			// Associate with an EAR, if necessary.
 
-			final String earProjectName = (String)model.getProperty(IJ2EEFacetInstallDataModelProperties.EAR_PROJECT_NAME);
-			if (earProjectName != null && !earProjectName.equals("")) {
-	
-				String ver = model.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
-			
-				String j2eeVersionText = J2EEVersionUtil.convertVersionIntToString(
-						J2EEVersionUtil.convertConnectorVersionStringToJ2EEVersionID(ver));
-				
-				installEARFacet(j2eeVersionText, earProjectName, monitor);
+			final String earProjectName = (String) model.getProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME);
+			if (model.getBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR)) {
+				if (earProjectName != null && !earProjectName.equals("")) {
+
+					String ver = fv.getVersionString();
+					String j2eeVersionText = J2EEVersionUtil.convertVersionIntToString
+					(J2EEVersionUtil.convertConnectorVersionStringToJ2EEVersionID(ver));
+					
+					IFacetedProject facetedProject = ProjectFacetsManager.create(project);
+					installEARFacet(j2eeVersionText, earProjectName, facetedProject.getRuntime(), monitor);
+
+					IProject earProject = ProjectUtilities.getProject(earProjectName);
+					IVirtualComponent earComp = ComponentCore.createComponent(earProject);
+
+					final IDataModel dataModel = DataModelFactory.createDataModel(new AddComponentToEnterpriseApplicationDataModelProvider() {
+						public Object getDefaultProperty(String propertyName) {
+							if (IAddComponentToEnterpriseApplicationDataModelProperties.TARGET_COMPONENTS_TO_URI_MAP.equals(propertyName)) {
+								Map map = new HashMap();
+								List components = (List) getProperty(TARGET_COMPONENT_LIST);
+								for (int i = 0; i < components.size(); i++) {
+									IVirtualComponent component = (IVirtualComponent) components.get(i);
+									String name = component.getName();
+									name += ".rar"; //$NON-NLS-1$
+									map.put(component, name);
+								}
+								return map;
+							}
+							return super.getDefaultProperty(propertyName);
+						}
+
+						public IDataModelOperation getDefaultOperation() {
+							return new AddComponentToEnterpriseApplicationOp(model) {
+								protected Module createNewModule(IVirtualComponent wc) {
+									return ((ApplicationPackage) EPackage.Registry.INSTANCE.getEPackage(ApplicationPackage.eNS_URI)).getApplicationFactory().createConnectorModule();
+								}
+							};
+						}
+					});
+					dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp);
+					List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+					modList.add(c);
+					dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
+					try {
+						dataModel.getDefaultOperation().execute(null, null);
+					} catch (ExecutionException e) {
+						Logger.getLogger().logError(e);
+					}
+				}
+			}
+
+			try {
+				((IDataModelOperation) model.getProperty(FacetDataModelProvider.NOTIFICATION_OPERATION)).execute(monitor, null);
+			} catch (ExecutionException e) {
+				Logger.getLogger().logError(e);
 			}
 
 			if (monitor != null) {
 				monitor.worked(1);
 			}
-		} 
+		}
 
 		finally {
 			if (monitor != null) {
 				monitor.done();
 			}
 		}
-		
+
 	}
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..9f05c01
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/ConnectorFacetProjectCreationDataModelProvider.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.jca.project.facet;
+
+import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
+import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class ConnectorFacetProjectCreationDataModelProvider extends FacetProjectCreationDataModelProvider {
+
+	public ConnectorFacetProjectCreationDataModelProvider() {
+		super();
+	}
+	
+	public void init() {
+		super.init();
+		FacetDataModelMap map = (FacetDataModelMap) getProperty(FACET_DM_MAP);
+		IDataModel javaFacet = DataModelFactory.createDataModel(new JavaFacetInstallDataModelProvider());
+		map.add(javaFacet);
+		IDataModel jcaFacet = DataModelFactory.createDataModel(new ConnectorFacetInstallDataModelProvider());
+		map.add(jcaFacet);
+		javaFacet.setProperty(IJavaFacetInstallDataModelProperties.SOURCE_FOLDER_NAME,jcaFacet.getStringProperty(IConnectorFacetInstallDataModelProperties.CONFIG_FOLDER));
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/IConnectorFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/IConnectorFacetInstallDataModelProperties.java
index 61dbdc7..fbdf2ba 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/IConnectorFacetInstallDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jca/org/eclipse/jst/j2ee/jca/project/facet/IConnectorFacetInstallDataModelProperties.java
@@ -1,8 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.project.facet;
 
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
 
 public interface IConnectorFacetInstallDataModelProperties
- extends IJ2EEFacetInstallDataModelProperties{
+ extends IJ2EEModuleFacetInstallDataModelProperties{
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentExportOperation.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentExportOperation.java
index cb32bdc..dd7b376 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentExportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentExportOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -39,7 +39,7 @@
 			setModuleFile(caf.openRARFile(ls, getDestinationPath().toOSString()));
 			getModuleFile().saveAsNoReopen(getDestinationPath().toOSString());
 		} catch (Exception e) {
-			throw new SaveFailureException(J2EEPluginResourceHandler.getString("Error_opening_archive_for_export_2"), e);//$NON-NLS-1$
+			throw new SaveFailureException(J2EEPluginResourceHandler.Error_opening_archive_for_export_2, e);//$NON-NLS-1$
 		}
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentNestedJARLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentNestedJARLoadStrategyImpl.java
index 665dc40..fd4450a 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentNestedJARLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/archive/operations/ConnectorComponentNestedJARLoadStrategyImpl.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.jca.archive.operations;
 
 import java.io.FileNotFoundException;
@@ -110,4 +112,4 @@
 		throw new FileNotFoundException(uri);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ActivationSpecItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ActivationSpecItemProvider.java
index 1d0044a..3d81758 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ActivationSpecItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ActivationSpecItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -109,8 +109,8 @@
 	 */
 	public String getText(Object object) {
 		String label = ((ActivationSpec) object).getActivationSpecClass();
-		return label == null || label.length() == 0 ? JCAResourceHandler.getString("_UI_ActivationSpec_type") : //$NON-NLS-1$
-					JCAResourceHandler.getString("_UI_ActivationSpec_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+		return label == null || label.length() == 0 ? JCAResourceHandler._UI_ActivationSpec_type : 
+					JCAResourceHandler._UI_ActivationSpec_type + " " + label; 
 	}
 
 	/**
@@ -153,4 +153,4 @@
 		//return J2EEPlugin.getDefault();
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AdminObjectItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AdminObjectItemProvider.java
index ddccc69..166aace 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AdminObjectItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AdminObjectItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -122,8 +122,8 @@
 	 */
 	public String getText(Object object) {
 		String label = ((AdminObject) object).getAdminObjectInterface();
-		return label == null || label.length() == 0 ? JCAResourceHandler.getString("_UI_AdminObject_type") : //$NON-NLS-1$
-					JCAResourceHandler.getString("_UI_AdminObject_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+		return label == null || label.length() == 0 ? JCAResourceHandler._UI_AdminObject_type : 
+					JCAResourceHandler._UI_AdminObject_type + " " + label; 
 	}
 
 	/**
@@ -167,4 +167,4 @@
 		//return J2EEPlugin.getDefault();
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AuthenticationMechanismItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AuthenticationMechanismItemProvider.java
index d923f99..1086314 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AuthenticationMechanismItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/AuthenticationMechanismItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConfigPropertyItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConfigPropertyItemProvider.java
index 0b4bd31..97cad08 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConfigPropertyItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConfigPropertyItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -196,7 +196,7 @@
 	public String getText(Object object) {
 		ConfigProperty configProperty = ((ConfigProperty) object);
 		if (configProperty.getName() == null)
-			return JCAResourceHandler.getString("ConfigPropertyItemProvider_UI_0"); //$NON-NLS-1$
+			return JCAResourceHandler.ConfigPropertyItemProvider_UI_0; 
 		return "ConfigProperty: " + configProperty.getName(); //$NON-NLS-1$
 	}// getText
 
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectionDefinitionItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectionDefinitionItemProvider.java
index 22c6efc..6fd0a4b 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectionDefinitionItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectionDefinitionItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -163,8 +163,8 @@
 
 	public String getText(Object object) {
 		String label = ((ConnectionDefinition) object).getManagedConnectionFactoryClass();
-		return label == null || label.length() == 0 ? JCAResourceHandler.getString("_UI_ConnectionDefinition_type") : //$NON-NLS-1$
-					JCAResourceHandler.getString("_UI_ConnectionDefinition_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+		return label == null || label.length() == 0 ? JCAResourceHandler._UI_ConnectionDefinition_type : 
+					JCAResourceHandler._UI_ConnectionDefinition_type + " " + label; 
 	}
 
 	/**
@@ -211,4 +211,4 @@
 		//return J2EEPlugin.getDefault();
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectorItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectorItemProvider.java
index 56ce63b..f280f77 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectorItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ConnectorItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/InboundResourceAdapterItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/InboundResourceAdapterItemProvider.java
index fdb058c..4f1310a 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/InboundResourceAdapterItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/InboundResourceAdapterItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -93,7 +93,7 @@
 	 * @generated
 	 */
 	public String getText(Object object) {
-		return JCAResourceHandler.getString("_UI_InboundResourceAdapter_type"); //$NON-NLS-1$
+		return JCAResourceHandler._UI_InboundResourceAdapter_type; 
 		//return getString("_UI_InboundResourceAdapter_type"); //$NON-NLS-1$
 	}
 
@@ -136,4 +136,4 @@
 		return JcaPlugin.getPlugin();
 		//return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaEditPlugin.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaEditPlugin.java
index 0b77687..aa87cba 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaEditPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaEditPlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -119,4 +119,4 @@
 	public String getString(String key, Object s1, Object s2, Object s3) {
 		return MessageFormat.format(getString(key), new Object[]{s1, s2, s3});
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapter.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapter.java
index 11f7b58..4e4067f 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapterFactory.java
index 6e4745c..be84515 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/JcaItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/LicenseItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/LicenseItemProvider.java
index 4010be5..8247725 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/LicenseItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/LicenseItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -165,8 +165,8 @@
 	public String getText(Object object) {
 		License license = ((License) object);
 		if (license.getDescription() == null)
-			return JCAResourceHandler.getString("LicenseItemProvider_UI_0"); //$NON-NLS-1$
-		return JCAResourceHandler.getString("LicenseItemProvider_UI_0") + ":" + license.getDescription(); //$NON-NLS-1$ //$NON-NLS-2$
+			return JCAResourceHandler.LicenseItemProvider_UI_0; 
+		return JCAResourceHandler.LicenseItemProvider_UI_0 + ":" + license.getDescription(); 
 	}// getText
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageAdapterItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageAdapterItemProvider.java
index 9859144..de1344a 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageAdapterItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageAdapterItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -93,7 +93,7 @@
 	 * @generated
 	 */
 	public String getText(Object object) {
-		return JCAResourceHandler.getString("_UI_MessageAdapter_type"); //$NON-NLS-1$
+		return JCAResourceHandler._UI_MessageAdapter_type; 
 		//return getString("_UI_MessageAdapter_type"); //$NON-NLS-1$
 	}
 
@@ -136,4 +136,4 @@
 		//return J2EEPlugin.getDefault();
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageListenerItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageListenerItemProvider.java
index 216290e..23982cd 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageListenerItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/MessageListenerItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -109,8 +109,8 @@
 	 */
 	public String getText(Object object) {
 		String label = ((MessageListener) object).getMessageListenerType();
-		return label == null || label.length() == 0 ? JCAResourceHandler.getString("_UI_MessageListener_type") : //$NON-NLS-1$
-					JCAResourceHandler.getString("_UI_MessageListener_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+		return label == null || label.length() == 0 ? JCAResourceHandler._UI_MessageListener_type : 
+					JCAResourceHandler._UI_MessageListener_type + " " + label; 
 	}
 
 	/**
@@ -153,4 +153,4 @@
 		//return J2EEPlugin.getDefault();
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/OutboundResourceAdapterItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/OutboundResourceAdapterItemProvider.java
index eb8a9a7..95f9324 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/OutboundResourceAdapterItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/OutboundResourceAdapterItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -136,7 +136,7 @@
 	public String getText(Object object) {
 		//		OutboundResourceAdapter outboundResourceAdapter = (OutboundResourceAdapter) object;
 
-		return JCAResourceHandler.getString("_UI_OutboundResourceAdapter_type"); //$NON-NLS-1$
+		return JCAResourceHandler._UI_OutboundResourceAdapter_type; 
 		//return getString("_UI_OutboundResourceAdapter_type") /*+ " " +
 		// outboundResourceAdapter.isReauthenticationSupport()*/; //$NON-NLS-1$ //$NON-NLS-2$
 	}
@@ -184,4 +184,4 @@
 	public ResourceLocator getResourceLocator() {
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/RequiredConfigPropertyTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/RequiredConfigPropertyTypeItemProvider.java
index 206c31f..e4e3cff 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/RequiredConfigPropertyTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/RequiredConfigPropertyTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -110,8 +110,8 @@
 	 */
 	public String getText(Object object) {
 		String label = ((RequiredConfigPropertyType) object).getName();
-		return label == null || label.length() == 0 ? JCAResourceHandler.getString("_UI_RequiredConfigPropertyType_type") : //$NON-NLS-1$
-					JCAResourceHandler.getString("_UI_RequiredConfigPropertyType_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+		return label == null || label.length() == 0 ? JCAResourceHandler._UI_RequiredConfigPropertyType_type : 
+					JCAResourceHandler._UI_RequiredConfigPropertyType_type + " " + label; 
 	}
 
 	/**
@@ -156,4 +156,4 @@
 		//return J2EEPlugin.getDefault();
 		return JcaPlugin.getPlugin();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ResourceAdapterItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ResourceAdapterItemProvider.java
index 2797088..75915a6 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ResourceAdapterItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/ResourceAdapterItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -304,7 +304,7 @@
 		//		ResourceAdapter resourceAdapter = ((ResourceAdapter) object);
 		//return "ResourceAdapter: " + resourceAdapter.getManagedConnectionFactoryClass();
 		// //$NON-NLS-1$
-		return JCAResourceHandler.getString("_UI_ResourceAdapter_type"); //$NON-NLS-1$
+		return JCAResourceHandler._UI_ResourceAdapter_type; 
 
 	}// getText
 
diff --git a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/SecurityPermissionItemProvider.java b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/SecurityPermissionItemProvider.java
index bca677b..2696f38 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/SecurityPermissionItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/jcaedit/org/eclipse/jst/j2ee/internal/jca/providers/SecurityPermissionItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -166,8 +166,8 @@
 	public String getText(Object object) {
 		SecurityPermission securityPermission = ((SecurityPermission) object);
 		if (securityPermission.getDescription() == null)
-			return JCAResourceHandler.getString("SecurityPermissionItemProvider_UI_0"); //$NON-NLS-1$
-		return JCAResourceHandler.getString("SecurityPermissionItemProvider_UI_0") + ": " + securityPermission.getDescription(); //$NON-NLS-1$ //$NON-NLS-2$
+			return JCAResourceHandler.SecurityPermissionItemProvider_UI_0; 
+		return JCAResourceHandler.SecurityPermissionItemProvider_UI_0 + ": " + securityPermission.getDescription(); 
 	}// getText
 
 	/**
diff --git a/plugins/org.eclipse.jst.j2ee.jca/plugin.xml b/plugins/org.eclipse.jst.j2ee.jca/plugin.xml
index e08313a..a863c83 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.jca/plugin.xml
@@ -80,7 +80,7 @@
     <project-facet id="jst.connector">
       <label>J2C Module</label>
       <description>Enables the project to be deployed as a J2C module.</description>
-      <icon>icons/full/obj16/connector.gif</icon>
+      <icon>icons/full/obj16/Connector.gif</icon>
     </project-facet>
 
     <project-facet-version facet="jst.connector" version="1.0">
@@ -93,7 +93,7 @@
       </action>
       <constraint>
         <and>
-          <requires facet="jst.java" version="1.3" allow-newer="true"/>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -110,7 +110,7 @@
       </action>
       <constraint>
         <and>
-          <requires facet="jst.java" version="1.3" allow-newer="true"/>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
diff --git a/plugins/org.eclipse.jst.j2ee.jca/property_files/rar.properties b/plugins/org.eclipse.jst.j2ee.jca/property_files/rar.properties
index f7e51ae..a201682 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/property_files/rar.properties
+++ b/plugins/org.eclipse.jst.j2ee.jca/property_files/rar.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationDataModelProvider.java
index 6befa59..c2c1e88 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -23,6 +23,11 @@
 import org.eclipse.wst.common.frameworks.datamodel.DataModelPropertyDescriptor;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 
+/**
+ * @deprecated 
+ * @see ConnectorFacetProjectCreationDataModelProvider
+ */
+
 public class ConnectorComponentCreationDataModelProvider extends J2EEComponentCreationDataModelProvider implements IConnectorComponentCreationDataModelProperties {
 
 	public ConnectorComponentCreationDataModelProvider() {
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationFacetOperation.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationFacetOperation.java
index 044d22b..08423fc 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationFacetOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentCreationFacetOperation.java
@@ -1,8 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.jca.operations;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IAdaptable;
@@ -12,12 +19,13 @@
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.datamodel.properties.IJavaComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.jca.project.facet.ConnectorFacetInstallDataModelProvider;
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.J2EEComponentCreationFacetOperation;
 import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
@@ -31,22 +39,20 @@
 		IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
 		String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
 		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, projectName);
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION,
-				model.getProperty(IComponentCreationDataModelProperties.LOCATION));
-		
-		List facetDMs = new ArrayList();
-		facetDMs.add(setupJavaInstallAction());
+
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+		map.add(setupJavaInstallAction());
 		IDataModel newModel = setupConnectorInstallAction();
-		facetDMs.add(newModel);
-		setRuntime(newModel,dm); //Setting runtime property
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
+		map.add(newModel);
+		setRuntime(newModel, dm); // Setting runtime property
+
 		IStatus stat = dm.getDefaultOperation().execute(monitor, info);
-		if( stat.isOK()){
+		if (stat.isOK()) {
 			String earProjectName = (String) model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME);
-			IProject earProject = ProjectUtilities.getProject( earProjectName );
+			IProject earProject = ProjectUtilities.getProject(earProjectName);
 			if (earProject != null && earProject.exists())
 				stat = addtoEar(projectName, earProjectName);
-		}		
+		}
 
 		return stat;
 	}
@@ -56,10 +62,11 @@
 		IDataModel connectorFacetInstallDataModel = DataModelFactory.createDataModel(new ConnectorFacetInstallDataModelProvider());
 		connectorFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME));
 		connectorFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, versionStr);
-		connectorFacetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER, model.getStringProperty(IJavaComponentCreationDataModelProperties.JAVASOURCE_FOLDER) );
+		connectorFacetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER, model.getStringProperty(IJavaComponentCreationDataModelProperties.JAVASOURCE_FOLDER));
+		connectorFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR));
 		if (model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR))
-			connectorFacetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.EAR_PROJECT_NAME, model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME));		
-		connectorFacetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(IJ2EEComponentCreationDataModelProperties.RUNTIME_TARGET_ID));
+			connectorFacetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME, model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME));
+		connectorFacetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(IJ2EEComponentCreationDataModelProperties.RUNTIME_TARGET_ID));
 		return connectorFacetInstallDataModel;
-	}	
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentExportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentExportDataModelProvider.java
index 6ecfefe..9684058 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentExportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentExportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportDataModelProvider.java
index 89bf0d9..91995ee 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportDataModelProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.jca.operations;
 
 import org.eclipse.jst.j2ee.application.internal.operations.J2EEComponentImportDataModelProvider;
@@ -50,4 +52,4 @@
 		return new ConnectorComponentImportOperation(model);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportOperation.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportOperation.java
index d717c41..5b11d11 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/ConnectorComponentImportOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -72,4 +72,4 @@
 		return saveStrat;
 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentCreationDataModelProperties.java
index 574b7dd..0ce7df6 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentCreationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentExportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentExportDataModelProperties.java
index 2eadfef..fc5a54a 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentExportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentExportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentImportDataModelProperties.java
index 1a524c6..f172846 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/internal/jca/operations/IConnectorComponentImportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/internal/module/util/ConnectorEditAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/internal/module/util/ConnectorEditAdapterFactory.java
index dc57a7c..52d9ed6 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/internal/module/util/ConnectorEditAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/internal/module/util/ConnectorEditAdapterFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.internal.module.util;
 
 import org.eclipse.core.runtime.IAdapterFactory;
diff --git a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/modulecore/util/ConnectorArtifactEdit.java b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/modulecore/util/ConnectorArtifactEdit.java
index 09c7482..68d150e 100644
--- a/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/modulecore/util/ConnectorArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee.jca/rarproject/org/eclipse/jst/j2ee/jca/modulecore/util/ConnectorArtifactEdit.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.jca.modulecore.util;
 
 import java.util.List;
@@ -61,7 +71,7 @@
 		super(aProject, toAccessAsReadOnly);
 	}
 	
-	protected ConnectorArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
+	public ConnectorArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
 		super(aProject, toAccessAsReadOnly, forCreate, J2EEProjectUtilities.JCA);
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/.cvsignore b/plugins/org.eclipse.jst.j2ee.navigator.ui/.cvsignore
index 1aca4ab..eb62e2c 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/.cvsignore
@@ -3,3 +3,4 @@
 build.xml
 j2ee-navigator.jar
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/build.properties b/plugins/org.eclipse.jst.j2ee.navigator.ui/build.properties
index c2d0b71..649ce90 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/build.properties
@@ -1,21 +1,20 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
 bin.includes = plugin.xml,\
                *.jar,\
                .,\
-               com.ibm.wtp.j2ee.ui.navigator/,\
                icons/,\
                plugin.properties,\
-               schema/,\
                META-INF/,\
                about.html
-src.includes = com.ibm.wtp.j2ee.ui.navigator/
+src.includes = icons,\
+               schema/
 source.. = j2ee-navigator/
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManager.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManager.java
index 4e81a86..e42c31e 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManager.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManager.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManagerFactory.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManagerFactory.java
index 6903ffb..bbbda14 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManagerFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFModelManagerFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectManager.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectManager.java
index 42258ba..1633456 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectManager.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectManager.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectProvider.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectProvider.java
index 3d39751..3a1d2e7 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/EMFRootObjectProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 17, 2005
  *
@@ -106,6 +116,7 @@
 		EMFModelManager modelManager = (EMFModelManager) emfModelCache.remove(project);
 		if (modelManager != null) {
 			modelManager.dispose();
+			modelManager = null;
 		}
 	}
 	public void dispose() {
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/FlexibleEMFModelManager.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/FlexibleEMFModelManager.java
index 160e162..f5cf432 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/FlexibleEMFModelManager.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/FlexibleEMFModelManager.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 17, 2005
  *
@@ -92,6 +102,8 @@
 	  	     contentModelRoot = artifactEdit.getContentModelRoot();
 			 if (contentModelRoot != null) {
 		  	     flexibleObjects.add(contentModelRoot);
+		  	     if (!rootObjects.contains(contentModelRoot))
+		  	    	 rootObjects.add(contentModelRoot);
 		  	     artifactEditToRootObject.put(artifactEdit,contentModelRoot);
 			 }
 	  	  }
@@ -149,6 +161,7 @@
 		}
 		if (moduleCore != null)
 			moduleCore.dispose();
+		rootObjects.clear();
 		
 	}
 
@@ -162,6 +175,7 @@
 			case EditModelEvent.UNLOADED_RESOURCE :
 			case EditModelEvent.REMOVED_RESOURCE : {
 				Object oldRootObject = removeRootObject(anEvent.getEditModel(),affectedProject);
+				getRootObjects();
 				if (oldRootObject != null)
 					notifyListeners(affectedProject);
 				}
@@ -204,6 +218,7 @@
 	private Object removeRootObject(EditModel editModel, IProject project) {
 		ArtifactEdit artifactEdit = getArtifactEdit(editModel,project);
 		if (artifactEdit != null) {
+			rootObjects.remove(artifactEditToRootObject.get(artifactEdit));
 			artifactEditToRootObject.remove(artifactEdit);
 		}
 		return artifactEdit;
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EENavigatorConstants.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EENavigatorConstants.java
index 6b77ced..75cf8b1 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EENavigatorConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EENavigatorConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -26,4 +26,4 @@
 public interface IJ2EENavigatorConstants {
 
 	String VIEWER_ID = "org.eclipse.wst.navigator.ui.WTPWorkingSetCommonNavigator";//$NON-NLS-1$ 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EEWizardConstants.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EEWizardConstants.java
index 6c4a698..1758945 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EEWizardConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/IJ2EEWizardConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -71,4 +71,4 @@
 	String EXPORT_ENTERPRISE_BEAN_WIZARD_ID = EJBComponentExportWizard.class.getName();
 
 	String EXPORT_WEB_MODULE_WIZARD_ID = WebComponentExportWizard.class.getName();
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEActionProvider.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEActionProvider.java
index 003d99d..3ff311b 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEActionProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEActionProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.navigator.internal;
 
 import java.util.ArrayList;
@@ -128,4 +130,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEComparator.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEComparator.java
index afa07d6..33d2ab6 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEComparator.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEComparator.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 22, 2005
  * 
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEContentProvider.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEContentProvider.java
index d2ab0aa..870b7f0 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEContentProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EELabelProvider.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EELabelProvider.java
index da4e3a7..01b454c 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EELabelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EELabelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -219,4 +219,4 @@
 			return delegateLabelProvider.toString();
 		return super.toString();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EENavigationLabelProvider.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EENavigationLabelProvider.java
index bf53cc0..0820d93 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EENavigationLabelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EENavigationLabelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -30,4 +30,4 @@
 	public J2EENavigationLabelProvider(AdapterFactory adapterFactory) {
 		super(adapterFactory);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEViewerSorter.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEViewerSorter.java
index e72e5ac..0ac695f 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEViewerSorter.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/J2EEViewerSorter.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.navigator.internal;
 
 
@@ -49,4 +51,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/NonFlexibleEMFModelManager.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/NonFlexibleEMFModelManager.java
index cf07c6e..221299c 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/NonFlexibleEMFModelManager.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/NonFlexibleEMFModelManager.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddExternalUtilityJarDropAction.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddExternalUtilityJarDropAction.java
index 79d4adf..1a516b2 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddExternalUtilityJarDropAction.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddExternalUtilityJarDropAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -48,4 +48,4 @@
 //		}
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddModuleDropAction.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddModuleDropAction.java
index fab6593..fefcd70 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddModuleDropAction.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddModuleDropAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -38,4 +38,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddProjectToEarDropAction.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddProjectToEarDropAction.java
index c393523..3ed68ff 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddProjectToEarDropAction.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddProjectToEarDropAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -120,4 +120,4 @@
 		return true;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddUtilityJarDropAction.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddUtilityJarDropAction.java
index f6a5e4f..11b7dbd 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddUtilityJarDropAction.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/AddUtilityJarDropAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -50,4 +50,4 @@
 		return dataModel;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/J2EEImportDropAction.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/J2EEImportDropAction.java
index 09b784a..edc7fbb 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/J2EEImportDropAction.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/J2EEImportDropAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -244,4 +244,4 @@
 		}
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/ModuleIdentifierSerializer.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/ModuleIdentifierSerializer.java
index dbe8932..6e7477f 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/ModuleIdentifierSerializer.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/dnd/ModuleIdentifierSerializer.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -46,4 +46,4 @@
 		String name = new String(data);
 		return ResourcesPlugin.getWorkspace().getRoot().getProject(name);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/plugin/J2EENavigatorPlugin.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/plugin/J2EENavigatorPlugin.java
index 20447f2..d3d5680 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/plugin/J2EENavigatorPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/plugin/J2EENavigatorPlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -44,4 +44,4 @@
 	public static IWorkspace getWorkspace() {
 		return ResourcesPlugin.getWorkspace();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSet.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSet.java
index 8297bc8..88682db 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSet.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSet.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 24, 2005
  *
@@ -42,7 +52,9 @@
 	
 	private String name;
 
-    private ArrayList elements;
+	private String label;
+
+	private ArrayList elements;
 
     private String editPageId;
 
@@ -331,7 +343,43 @@
 		
 	}
 
-	
+	public boolean isVisible() {
+		//TODO_32 This implementation put in WTP 1.0 to maintain compatibility with Eclipse 3.2 M3
+		return true;
+	}
+
+	public String getLabel() {
+		//TODO_32 This implementation put in WTP 1.0 to maintain compatibility with Eclipse 3.2 M3
+		String result = label;
+		if (result == null) {
+			result = getName();
+		}
+		return result;
+	}
+
+	public void setLabel(String label) {
+		//TODO_32 This implementation put in WTP 1.0 to maintain compatibility with Eclipse 3.2 M3
+		this.label = label;
+		
+	}
+
+	public boolean isSelfUpdating() {
+		// TODO_32 this method was added to be compatible 
+		// with 3.2. Please reimplenet it in the 32 stream if needed. 
+		return false;
+	}
+
+	public boolean isAggregateWorkingSet() {
+		// TODO_32 this method was added to be compatible 
+		// with 3.2. Please reimplenet it in the 32 stream if needed. 
+		return false;
+	}
+
+	public boolean isEmpty() {
+		// TODO_32 this method was added to be compatible 
+		// with 3.2. Please reimplenet it in the 32 stream if needed. 
+		return false;
+	}
 	
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetDescriptor.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetDescriptor.java
index 23d48e4..16097bb 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetDescriptor.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetDescriptor.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 23, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetFactory.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetFactory.java
index 8fe91a7..305412e 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 28, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetProvider.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetProvider.java
index 84ea804..1346147 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 25, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetRegistry.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetRegistry.java
index a9c2a21..7a97913 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetRegistry.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 23, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetUpdater.java b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetUpdater.java
index ddb695a..92e8647 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetUpdater.java
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/j2ee-navigator/org/eclipse/jst/j2ee/navigator/internal/workingsets/ComponentWorkingSetUpdater.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 24, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.properties b/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.properties
index d5e0bd4..da488ba 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.properties
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -30,4 +30,4 @@
 J2EE_IMPORT_MESSAGE=Imports J2EE artifacts: EARs, EJB Jars, Application Client Jars, RARs and WARs
 
 
-extension.j2ee.name=J2EE Deployment Descriptors
\ No newline at end of file
+extension.j2ee.name=J2EE Deployment Descriptors
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.xml b/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.xml
index 201330f..b6f98a8 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/plugin.xml
@@ -440,7 +440,7 @@
           <!-- EAR New -->
           <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.j2ee.internal.wizard.EARComponentCreationWizard">
+            wizardId="org.eclipse.jst.j2ee.ui.project.facet.EarProjectWizard">
          <enablement>
          <or> 
              <and>
@@ -459,7 +459,7 @@
         <!-- AppClient New -->
         <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.j2ee.internal.wizard.AppClientComponentCreationWizard">
+            wizardId="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientProjectWizard">
          <enablement>
            <or> 
              <and>
@@ -477,7 +477,7 @@
        </commonWizard>
        <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.servlet.ui.WebComponentCreationWizard">
+            wizardId="org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard">
          <enablement>
            <or>
                <and>
@@ -495,7 +495,7 @@
        <!-- Connector New -->
         <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.j2ee.jca.ui.ConnectorComponentCreationWizard">
+            wizardId="org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorProjectWizard">
          <enablement>
           <or>
                <and>
@@ -513,7 +513,7 @@
        <!-- EJB New -->
         <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.ejb.ui.EJBComponentCreationWizard">
+            wizardId="org.eclipse.jst.ejb.ui.project.facet.EjbProjectWizard">
          <enablement>
           <or>
                <and>
diff --git a/plugins/org.eclipse.jst.j2ee.navigator.ui/schema/componentWorkingSet.exsd b/plugins/org.eclipse.jst.j2ee.navigator.ui/schema/componentWorkingSet.exsd
index 29c7123..7ac37ca 100644
--- a/plugins/org.eclipse.jst.j2ee.navigator.ui/schema/componentWorkingSet.exsd
+++ b/plugins/org.eclipse.jst.j2ee.navigator.ui/schema/componentWorkingSet.exsd
@@ -1,12 +1,12 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jst.common.navigator.java">
+<schema targetNamespace="org.eclipse.jst.j2ee.navigator.ui">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.common.navigator.java" id="commonWorkingSet" name="Commom Working Set"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee.navigator.ui" id="componentWorkingSet" name="Component Working Set"/>
       </appInfo>
       <documentation>
-         [Enter description of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -77,7 +77,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -86,7 +86,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -95,7 +95,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -104,7 +104,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -113,7 +113,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee.ui/.cvsignore b/plugins/org.eclipse.jst.j2ee.ui/.cvsignore
index be6abc0..5bc666b 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.ui/.cvsignore
@@ -4,3 +4,4 @@
 build.xml
 j2ee_ui.jar
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.j2ee.ui/META-INF/MANIFEST.MF
index ff30459..d390178 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.j2ee.ui/META-INF/MANIFEST.MF
@@ -23,7 +23,8 @@
  org.eclipse.jst.j2ee.internal.ui.util,
  org.eclipse.jst.j2ee.internal.war.ui.util,
  org.eclipse.jst.j2ee.internal.wizard,
- org.eclipse.jst.j2ee.ui.project.facet
+ org.eclipse.jst.j2ee.ui.project.facet,
+ org.eclipse.jst.j2ee.ui.project.facet.appclient
 Require-Bundle: org.eclipse.ui.ide,
  org.eclipse.core.resources,
  org.eclipse.ui,
@@ -62,5 +63,7 @@
  org.eclipse.jst.common.annotations.controller,
  org.eclipse.jst.j2ee.ejb.annotation.model,
  org.eclipse.wst.common.project.facet.core,
- org.eclipse.wst.common.project.facet.ui
+ org.eclipse.wst.common.project.facet.ui,
+ org.eclipse.jst.server.core,
+ org.eclipse.wst.web.ui
 Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jst.j2ee.ui/build.properties b/plugins/org.eclipse.jst.j2ee.ui/build.properties
index e1c604f..55ac828 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/build.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/JavaInsertionOperation.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/JavaInsertionOperation.java
index f23b0dd..6ee2dd8 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/JavaInsertionOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/JavaInsertionOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -248,4 +248,4 @@
 		}
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/WTPUIWorkingCopyManager.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/WTPUIWorkingCopyManager.java
index a79d5cd..5a79a1e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/WTPUIWorkingCopyManager.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/common/jdt/internal/integration/ui/WTPUIWorkingCopyManager.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -470,4 +470,4 @@
 		return super.hasWorkingCopies() || (editorInputs != null && !editorInputs.isEmpty());
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AddModulestoEARPropertiesPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AddModulestoEARPropertiesPage.java
index 8d70f1c..c2b2bb1 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AddModulestoEARPropertiesPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AddModulestoEARPropertiesPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
@@ -12,7 +22,6 @@
 
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IPath;
@@ -32,7 +41,6 @@
 import org.eclipse.jst.j2ee.application.internal.operations.RemoveComponentFromEnterpriseApplicationOperation;
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
-import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.jst.j2ee.project.facet.IJavaProjectMigrationDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.JavaProjectMigrationDataModelProvider;
 import org.eclipse.swt.SWT;
@@ -40,7 +48,6 @@
 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.Event;
 import org.eclipse.swt.widgets.Group;
 import org.eclipse.swt.widgets.Label;
@@ -49,9 +56,7 @@
 import org.eclipse.swt.widgets.TableColumn;
 import org.eclipse.swt.widgets.TableItem;
 import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.dialogs.PropertyPage;
 import org.eclipse.wst.common.componentcore.ComponentCore;
-import org.eclipse.wst.common.componentcore.ModuleCoreNature;
 import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.internal.operation.CreateReferenceComponentsDataModelProvider;
 import org.eclipse.wst.common.componentcore.internal.operation.RemoveReferenceComponentsDataModelProvider;
@@ -67,9 +72,10 @@
  * TODO To change the template for this generated type comment go to
  * Window - Preferences - Java - Code Style - Code Templates
  */
-public class AddModulestoEARPropertiesPage extends PropertyPage implements Listener, ICommonManifestUIConstants {
+public class AddModulestoEARPropertiesPage implements IJ2EEDependenciesControl, Listener {
 
-	protected IProject project;
+	protected final IProject project;
+	protected final J2EEDependenciesPage propPage; 
 	protected IVirtualComponent earComponent = null;
 	protected Text componentNameText;
 	protected Label availableModules;
@@ -85,57 +91,26 @@
 	protected static final IStatus OK_STATUS = IDataModelProvider.OK_STATUS;
 
 	/**
-	 * Constructor for AddModulestoEARPropertiesPage.
+	 * Constructor for AddModulestoEARPropertiesControl.
 	 */
-	public AddModulestoEARPropertiesPage() {
-		super();
+	public AddModulestoEARPropertiesPage(final IProject project, final J2EEDependenciesPage page) { 
+		this.project = project;
+		this.propPage = page;
+		earComponent = ComponentCore.createComponent(project);
 	}
 	
-	protected Control createContents(Composite parent) {
-		initialize();
-
-
+	public Composite createContents(final Composite parent) { 
 		Composite composite = new Composite(parent, SWT.NONE);
 		GridLayout layout = new GridLayout();
 		layout.marginWidth = 0;
 		layout.marginWidth = 0;
 		composite.setLayout(layout);
 		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
-		if (earComponent == null)
-			return composite;
-		createProjectLabelsGroup(composite);
+        J2EEDependenciesPage.createDescriptionComposite(composite, ManifestUIResourceHandler.EAR_Modules_Desc);
 		createListGroup(composite);
 		refresh();
 		return composite;
 	}
-	
-	protected void initialize() {
-		project = (IProject) getElement().getAdapter(IResource.class);
-
-		if (ModuleCoreNature.isFlexibleProject(project)) {
-			IVirtualComponent component = ComponentCore.createComponent(project);
-				if (J2EEProjectUtilities.isEARProject(project))
-					earComponent = component;
-		}
-	}
-
-	protected void createProjectLabelsGroup(Composite parent) {
-
-		Composite labelsGroup = new Composite(parent, SWT.NONE);
-		GridLayout layout = new GridLayout();
-		layout.numColumns = 2;
-		labelsGroup.setLayout(layout);
-		labelsGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Label label = new Label(labelsGroup, SWT.NONE);
-		label.setText(ManifestUIResourceHandler.getString("Project_name__UI_")); //$NON-NLS-1$ = "Project name:"
-
-		componentNameText = new Text(labelsGroup, SWT.BORDER);
-		GridData data = new GridData(GridData.FILL_HORIZONTAL);
-		componentNameText.setEditable(false);
-		componentNameText.setLayoutData(data);
-		componentNameText.setText(project.getName());
-	}
 
 	protected void createListGroup(Composite parent) {
 		Composite listGroup = new Composite(parent, SWT.NONE);
@@ -155,17 +130,26 @@
 		createTableComposite(listGroup);
 	}
 
-	public void dispose() {
-		super.dispose();
-	}
-
 	public boolean performOk() {
 		NullProgressMonitor monitor = new NullProgressMonitor();
 		addModulesToEAR(monitor);
 		removeModulesFromEAR(monitor);
 		return true;
 	}
+	
+	public void performDefaults() {
+	}
+	
+	public boolean performCancel() {
+		return true;
+	}
+	
+	public void dispose() {
+	}
 
+	public void setVisible(boolean visible) {
+	}
+	
 	private List newJ2EEModulesToAdd(){
 		List newComps = new ArrayList();
 		if (j2eeComponentList != null && !j2eeComponentList.isEmpty()){
@@ -289,7 +273,7 @@
 	}
 	
 	private void handleSelectExternalJarButton(){
-		IPath[] selected= BuildPathDialogAccess.chooseExternalJAREntries(getShell());
+		IPath[] selected= BuildPathDialogAccess.chooseExternalJAREntries(propPage.getShell());
 
 		if (selected != null) {
 			for (int i= 0; i < selected.length; i++) {
@@ -299,23 +283,13 @@
 							selected[i].toString());
 				
 				ArrayList vlist = new ArrayList();
-				IVirtualReference[] oldrefs = earComponent.getReferences();
-				for (int j = 0; j < oldrefs.length; j++) {
-					IVirtualReference ref = oldrefs[j];
-					vlist.add(ref);
-				}		
 			
 				//To do: check if archive component already exists
 				IVirtualReference ref = ComponentCore.createReference( earComponent, archive );
 				vlist.add(ref);	
 				
-				IVirtualReference[] refs = new IVirtualReference[vlist.size()];
-				for (int j = 0; j < vlist.size(); j++) {
-					IVirtualReference tmpref = (IVirtualReference) vlist.get(j);
-					refs[j] = tmpref;
-				}				
-				earComponent.setReferences(refs);
-				//j2eeComponentList.add(archive.getProject());
+				IVirtualReference[] refs = (IVirtualReference[]) vlist.toArray(new IVirtualReference[vlist.size()]);
+				earComponent.addReferences(refs);
 				j2eeComponentList.add(archive);
 			}
 			refresh();
@@ -325,7 +299,7 @@
 
 	private void handleSelectVariableButton(){
 		IPath existingPath[] = new Path[0];
-		IPath[] paths =  BuildPathDialogAccess.chooseVariableEntries(getShell(), existingPath);
+		IPath[] paths =  BuildPathDialogAccess.chooseVariableEntries(propPage.getShell(), existingPath);
 		
 		if (paths != null) {
 			refresh();
@@ -529,11 +503,11 @@
 
 		// table columns
 		TableColumn fileNameColumn = new TableColumn(table, SWT.NONE, 0);
-		fileNameColumn.setText(ManifestUIResourceHandler.getString("JAR/Module_UI_")); //$NON-NLS-1$
+		fileNameColumn.setText(ManifestUIResourceHandler.JAR_Module_UI_); 
 		fileNameColumn.setResizable(true);
 
 		TableColumn projectColumn = new TableColumn(table, SWT.NONE, 1);
-		projectColumn.setText(ManifestUIResourceHandler.getString("Project_UI_")); //$NON-NLS-1$ = "Project"
+		projectColumn.setText(ManifestUIResourceHandler.Project_UI_); 
 		projectColumn.setResizable(true);
 		tableLayout.layout(table, true);
 		return availableComponentsViewer;
@@ -568,6 +542,7 @@
 		}
 		
 		availableComponentsViewer.setCheckedElements(list.toArray());
+		j2eeComponentList.addAll(list);
 		GridData btndata = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_BEGINNING);
 		buttonColumn.setLayoutData(btndata);
 
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AvailableJ2EEComponentsForEARContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AvailableJ2EEComponentsForEARContentProvider.java
index ad816ec..933e344 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AvailableJ2EEComponentsForEARContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/AvailableJ2EEComponentsForEARContentProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 18, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ClasspathTableManager.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ClasspathTableManager.java
index bf30ac5..5b83709 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ClasspathTableManager.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ClasspathTableManager.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
@@ -255,17 +265,17 @@
 	
 	private void handleSelectExternalJarButton(){
 		 //owner.handleSelectExternalJarButton();
-		if( owner instanceof WebLibDependencyPropertiesPage ){
-			WebLibDependencyPropertiesPage page = (WebLibDependencyPropertiesPage)owner;
-			page.handleSelectExternalJarButton();
+		if( owner instanceof WebLibDependencyPropertiesPage){
+			WebLibDependencyPropertiesPage control = (WebLibDependencyPropertiesPage)owner;
+			control.handleSelectExternalJarButton();
 		} 
 	}
 	
 	private void handleSelectVariableButton(){
 		//owner.handleSelectVariableButton();
-		if( owner instanceof WebLibDependencyPropertiesPage ){
-			WebLibDependencyPropertiesPage page = (WebLibDependencyPropertiesPage)owner;
-			page.handleSelectVariableButton();
+		if( owner instanceof WebLibDependencyPropertiesPage){
+			WebLibDependencyPropertiesPage control = (WebLibDependencyPropertiesPage)owner;
+			control.handleSelectVariableButton();
 		} 		
 	}
 	
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IClasspathTableOwner.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IClasspathTableOwner.java
index 681e747..94f64b3 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IClasspathTableOwner.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IClasspathTableOwner.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ICommonManifestUIConstants.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ICommonManifestUIConstants.java
index 7577ce6..a6c4542 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ICommonManifestUIConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ICommonManifestUIConstants.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
@@ -15,19 +25,19 @@
  * Window - Preferences - Java - Code Style - Code Templates
  */
 public interface ICommonManifestUIConstants {
-	String UP_BUTTON = ManifestUIResourceHandler.getString("Up_1"); //$NON-NLS-1$
-	String DOWN_BUTTON = ManifestUIResourceHandler.getString("Down_2"); //$NON-NLS-1$
-	String SELECT_ALL_BUTTON = ManifestUIResourceHandler.getString("Select_All_3"); //$NON-NLS-1$
-	String DE_SELECT_ALL_BUTTON = ManifestUIResourceHandler.getString("Deselect_All_4"); //$NON-NLS-1$
-	String ERROR_READING_MANIFEST_DIALOG_TITLE = ManifestUIResourceHandler.getString("ERROR_READING_MANIFEST_DIALOG_TITLE"); //$NON-NLS-1$
-	String SAVE_MANIFEST_WITH_ERROR =ManifestUIResourceHandler.getString("SAVE_MANIFEST_WITH_ERROR"); //$NON-NLS-1$
-	String ERROR_READING_MANIFEST_DIALOG_MESSAGE_EDITOR = ManifestUIResourceHandler.getString("ERROR_READING_MANIFEST_DIALOG_MESSAGE_EDITOR"); //$NON-NLS-1$
-	String ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE = ManifestUIResourceHandler.getString("ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE"); //$NON-NLS-1$
-	String MANIFEST_PROBLEM_1 = ManifestUIResourceHandler.getString("MANIFEST_PROBLEM_1"); //$NON-NLS-1$
-	String MANIFEST_PROBLEM_2 = ManifestUIResourceHandler.getString("MANIFEST_PROBLEM_2"); //$NON-NLS-1$
-	String MANIFEST_PROBLEM_3 = ManifestUIResourceHandler.getString("MANIFEST_PROBLEM_3"); //$NON-NLS-1$
-	String MANIFEST_PROBLEM_4 = ManifestUIResourceHandler.getString("MANIFEST_PROBLEM_4"); //$NON-NLS-1$
-	String REDIRECT_TEXT_EDITOR_UI_ = ManifestUIResourceHandler.getString("REDIRECT_TEXT_EDITOR_UI_"); //$NON-NLS-1$
+	String UP_BUTTON = ManifestUIResourceHandler.Up_1; 
+	String DOWN_BUTTON = ManifestUIResourceHandler.Down_2; 
+	String SELECT_ALL_BUTTON = ManifestUIResourceHandler.Select_All_3; 
+	String DE_SELECT_ALL_BUTTON = ManifestUIResourceHandler.Deselect_All_4; 
+	String ERROR_READING_MANIFEST_DIALOG_TITLE = ManifestUIResourceHandler.ERROR_READING_MANIFEST_DIALOG_TITLE; 
+	String SAVE_MANIFEST_WITH_ERROR =ManifestUIResourceHandler.SAVE_MANIFEST_WITH_ERROR; 
+	String ERROR_READING_MANIFEST_DIALOG_MESSAGE_EDITOR = ManifestUIResourceHandler.ERROR_READING_MANIFEST_DIALOG_MESSAGE_EDITOR; 
+	String ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE = ManifestUIResourceHandler.ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE; 
+	String MANIFEST_PROBLEM_1 = ManifestUIResourceHandler.MANIFEST_PROBLEM_1; 
+	String MANIFEST_PROBLEM_2 = ManifestUIResourceHandler.MANIFEST_PROBLEM_2; 
+	String MANIFEST_PROBLEM_3 = ManifestUIResourceHandler.MANIFEST_PROBLEM_3; 
+	String MANIFEST_PROBLEM_4 = ManifestUIResourceHandler.MANIFEST_PROBLEM_4; 
+	String REDIRECT_TEXT_EDITOR_UI_ = ManifestUIResourceHandler.REDIRECT_TEXT_EDITOR_UI_; 
 	
 	String EJB_CLIENT_RADIO_UI_		= CommonEditResourceHandler.getString("EJB_CLIENT_RADIO_UI_"); //$NON-NLS-1$
 	String USE_EJB_SERVER_JARs_UI_ 	= CommonEditResourceHandler.getString("USE_EJB_SERVER_JARs_UI_"); //$NON-NLS-1$
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IJ2EEDependenciesControl.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IJ2EEDependenciesControl.java
new file mode 100644
index 0000000..6005131
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/IJ2EEDependenciesControl.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.internal;
+
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * Interface for classes that implement a portion the "J2EE Module Dependencies"
+ * property page logic.
+ */
+public interface IJ2EEDependenciesControl extends ICommonManifestUIConstants {
+	
+	/**
+	 * Creates the Composite associated with this control.
+	 * @param parent Parent Composite.
+	 * @return Composite for the control.
+	 */
+	Composite createContents(Composite parent);
+	
+	/**
+	 * Called when the property page's <code>performOk()</code> method is called.
+	 * @return
+	 */
+	boolean performOk();
+	
+	/**
+	 * Called when the property page's <code>performDefaults()</code> method is called.
+	 * @return
+	 */
+	void performDefaults();
+	
+	/**
+	 * Called when the property page's <code>performCancel()</code> method is called.
+	 * @return
+	 */
+	boolean performCancel();
+	
+	/**
+	 * Called when the property page's <code>setVisible()</code> method is called.
+	 * @return
+	 */
+	void setVisible(boolean visible);
+	
+	/**
+	 * Called when the property page's <code>dispose()</code> method is called.
+	 * @return
+	 */
+	void dispose();
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEComponentProjectMigrator.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEComponentProjectMigrator.java
new file mode 100644
index 0000000..f5c0fd5
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEComponentProjectMigrator.java
@@ -0,0 +1,552 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.ProjectScope;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.IScopeContext;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jem.workbench.utility.JemProjectUtilities;
+import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
+import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
+import org.eclipse.jst.common.project.facet.WtpUtils;
+import org.eclipse.jst.j2ee.internal.common.CreationConstants;
+import org.eclipse.jst.j2ee.internal.earcreation.EarFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.internal.ejb.project.operations.EjbFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.internal.ejb.project.operations.IEjbFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.jca.project.facet.ConnectorFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.AppClientFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.IAppClientFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.UtilityFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDataModelProvider;
+import org.eclipse.jst.server.core.FacetUtil;
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
+import org.eclipse.wst.common.componentcore.internal.ComponentType;
+import org.eclipse.wst.common.componentcore.internal.ComponentcoreFactory;
+import org.eclipse.wst.common.componentcore.internal.IComponentProjectMigrator;
+import org.eclipse.wst.common.componentcore.internal.Property;
+import org.eclipse.wst.common.componentcore.internal.StructureEdit;
+import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.project.facet.SimpleWebFacetInstallDataModelProvider;
+import org.eclipse.wst.server.core.IRuntime;
+import org.eclipse.wst.server.core.ServerCore;
+import org.eclipse.wst.server.core.ServerUtil;
+
+public class J2EEComponentProjectMigrator implements IComponentProjectMigrator {
+
+	private static final String WEB_LIB_CONTAINER = "org.eclipse.jst.j2ee.internal.web.container";
+	private static final String WEB_LIB_PATH = "/WEB-INF/lib";
+	private IProject project;
+	public J2EEComponentProjectMigrator() {
+		super();
+		// TODO Auto-generated constructor stub
+	}
+
+	public void migrateProject(IProject aProject) {
+		if (aProject.isAccessible()) {
+			project = aProject;
+			removeComponentBuilders(project);
+			if (multipleComponentsDetected())
+				createNewProjects();
+			String facetid = getFacetFromProject(project);
+			if (facetid.length() == 0)
+				addFacets(project);
+		}
+
+	}
+
+		private void createNewProjects() {
+
+			StructureEdit se = null;
+			try {
+				se = StructureEdit.getStructureEditForWrite(project);
+				List comps = se.getComponentModelRoot().getComponents();
+				List removedComps = new ArrayList();
+				for (int i = 1;i<comps.size();i++) {
+					WorkbenchComponent comp = (WorkbenchComponent) comps.get(i);
+					IWorkspace ws = ResourcesPlugin.getWorkspace();
+					IProject newProj = ws.getRoot().getProject(comp.getName());
+					if (!newProj.exists()) {
+						try {
+							createProj(newProj,(!comp.getComponentType().getComponentTypeId().equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION)));
+							WtpUtils.addNatures(newProj);
+						} catch (CoreException e) {
+							// TODO Auto-generated catch block
+							e.printStackTrace();
+						}
+					}
+					addFacetsToProject(newProj,comp.getComponentType().getComponentTypeId(),comp.getComponentType().getVersion(),false);
+					removedComps.add(comp);
+					IFolder compFolder = project.getFolder(comp.getName());
+					if (compFolder.exists())
+						try {
+							compFolder.delete(true,null);
+						} catch (CoreException e) {
+							// TODO Auto-generated catch block
+							e.printStackTrace();
+						}
+				}
+				se.getComponentModelRoot().getComponents().removeAll(removedComps);
+				se.save(null);
+			
+			} finally {
+				if (se != null)
+					se.dispose();
+			}
+	
+		
+	}
+
+		private void createProj(IProject newProj, boolean isJavaProject) throws CoreException {
+			newProj.create(null);
+			IProjectDescription description = ResourcesPlugin.getWorkspace().newProjectDescription(newProj.getName());
+//			if (isJavaProject)
+//				description.setNatureIds(new String[]{JavaCore.NATURE_ID});
+			description.setLocation(null);
+			newProj.open(null);
+			newProj.setDescription(description, null);
+		}
+
+		private boolean multipleComponentsDetected() {
+			StructureEdit se = null;
+			try {
+				se = StructureEdit.getStructureEditForRead(project);
+				if (se == null) return false;
+				return se.getComponentModelRoot().getComponents().size() > 1;
+			} finally {
+				if (se != null)
+					se.dispose();
+			}
+	}
+
+		private void removeComponentBuilders(IProject aProject) {
+		try {
+			aProject.refreshLocal(IResource.DEPTH_INFINITE,null);
+		} catch (CoreException e1) {
+			// TODO Auto-generated catch block
+			e1.printStackTrace();
+		}
+		//IJavaProject javaP = JemProjectUtilities.getJavaProject(aProject);
+		List oldBuilders = new ArrayList();
+		oldBuilders.add("org.eclipse.wst.common.modulecore.ComponentStructuralBuilder");
+		oldBuilders.add("org.eclipse.wst.common.modulecore.ComponentStructuralBuilderDependencyResolver");
+		oldBuilders.add("org.eclipse.wst.common.modulecore.DependencyGraphBuilder");
+		try {
+			J2EEProjectUtilities.removeBuilders(aProject,oldBuilders);
+		} catch (CoreException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		
+	}
+
+		public String getFacetFromProject(IProject aProject) {
+			return J2EEProjectUtilities.getJ2EEProjectType(aProject);
+		}
+
+		
+		protected IDataModel setupJavaInstallAction(IProject aProject, boolean existing,String srcFolder) {
+			IDataModel dm = DataModelFactory.createDataModel(new JavaFacetInstallDataModelProvider());
+			dm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			String jVersion = "1.4";
+			IScopeContext context = new ProjectScope( project );
+		    IEclipsePreferences prefs 
+		            = context.getNode( JavaCore.PLUGIN_ID );
+			if (JavaCore.VERSION_1_5.equals(prefs.get(JavaCore.COMPILER_COMPLIANCE,JavaCore.VERSION_1_4))) {
+				jVersion = "5.0";
+			}
+			dm.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, jVersion); //$NON-NLS-1$
+			if (!existing)
+				dm.setStringProperty(IJavaFacetInstallDataModelProperties.SOURCE_FOLDER_NAME, srcFolder); //$NON-NLS-1$
+			return dm;
+		}
+		
+		protected IDataModel setupUtilInstallAction(IProject aProject,String specVersion) {
+			IDataModel aFacetInstallDataModel = DataModelFactory.createDataModel(new UtilityFacetInstallDataModelProvider());
+			aFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			aFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, specVersion);
+			aFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,false);
+			aFacetInstallDataModel.setStringProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME,null);
+			return aFacetInstallDataModel;
+		}
+		protected IDataModel setupEarInstallAction(IProject aProject,String specVersion) {
+			IDataModel earFacetInstallDataModel = DataModelFactory.createDataModel(new EarFacetInstallDataModelProvider());
+			earFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			earFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, specVersion);
+			
+			return earFacetInstallDataModel;
+		}
+		protected IDataModel setupAppClientInstallAction(IProject aProject,String specVersion) {
+			IDataModel aFacetInstallDataModel = DataModelFactory.createDataModel(new AppClientFacetInstallDataModelProvider());
+			aFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			aFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, specVersion);
+			aFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,false);
+			aFacetInstallDataModel.setStringProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME,null);
+			aFacetInstallDataModel.setBooleanProperty(IAppClientFacetInstallDataModelProperties.CREATE_DEFAULT_MAIN_CLASS,false);
+			return aFacetInstallDataModel;
+		}
+		protected IDataModel setupConnectorInstallAction(IProject aProject,String specVersion) {
+			IDataModel aFacetInstallDataModel = DataModelFactory.createDataModel(new ConnectorFacetInstallDataModelProvider());
+			aFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			aFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, specVersion);
+			aFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,false);
+			aFacetInstallDataModel.setStringProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME,null);
+			return aFacetInstallDataModel;
+		}
+
+		private void addFacets(IProject aProject) {
+			StructureEdit edit = null;
+			try {
+				edit = StructureEdit.getStructureEditForWrite(aProject);
+				if (edit == null) return;  // Not a component project....
+				if (edit.getComponent() == null) return; // Can't migrate
+				ComponentType type = edit.getComponent().getComponentType();
+				if (type == null) return;  // Can't migrate
+				String compId = type.getComponentTypeId();
+				String specVersion = edit.getComponent().getComponentType().getVersion();
+				moveMetaProperties(edit.getComponent(),type);
+				addFacetsToProject(aProject, compId, specVersion,true);
+			}
+			finally {
+				if (edit != null) {
+					edit.save(null);
+					edit.dispose();
+				}
+			}
+			
+		}
+
+		private void moveMetaProperties(WorkbenchComponent component, ComponentType type) {
+			List props = type.getProperties();
+			List compProps = component.getProperties();
+			for (Iterator iter = props.iterator(); iter.hasNext();) {
+				Property element = (Property) iter.next();
+				Property newProp = ComponentcoreFactory.eINSTANCE.createProperty();
+				newProp.setName(element.getName());
+				newProp.setValue(element.getValue());
+				compProps.add(newProp);
+			}
+			props.clear();
+		}
+
+		private void addFacetsToProject(IProject aProject, String compId, String specVersion,boolean existing) {
+			if (compId.equals(J2EEProjectUtilities.DYNAMIC_WEB))
+				installWEBFacets(aProject,specVersion,existing);
+			else if (compId.equals(J2EEProjectUtilities.EJB))
+				installEJBFacets(aProject,specVersion,existing);
+			else if (compId.equals(J2EEProjectUtilities.APPLICATION_CLIENT))
+				installAppClientFacets(aProject,specVersion,existing);
+			else if (compId.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION))
+				installEARFacets(aProject,specVersion,existing);
+			else if (compId.equals(J2EEProjectUtilities.JCA))
+				installConnectorFacets(aProject,specVersion,existing);
+			else if (compId.equals(J2EEProjectUtilities.UTILITY))
+				installUtilityFacets(aProject,specVersion,existing);
+			else if (compId.equals(J2EEProjectUtilities.STATIC_WEB))
+				installStaticWebFacets(aProject,specVersion,existing);
+		}
+
+		private void installStaticWebFacets(IProject project2, String specVersion, boolean existing) {
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, project2.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			//facetDMs.add(setupJavaInstallAction(webProj,existing,CreationConstants.DEFAULT_WEB_SOURCE_FOLDER));
+			IDataModel newModel = setupStaticWebInstallAction(project2);
+			facetDMs.add(newModel);
+			//setRuntime(webProj,dm); //Setting runtime property
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			}
+		}
+
+		private IDataModel setupStaticWebInstallAction(IProject project2) {
+			IDataModel webFacetInstallDataModel = DataModelFactory.createDataModel(new SimpleWebFacetInstallDataModelProvider());
+			webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, project2.getName());
+			webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, "1.0");
+			
+			return webFacetInstallDataModel;
+		}
+
+		private void installUtilityFacets(IProject aProject, String specVersion, boolean existing) {
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			facetDMs.add(setupJavaInstallAction(aProject,existing,"src"));
+			IDataModel newModel = setupUtilInstallAction(aProject,specVersion);
+			facetDMs.add(newModel);
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			}
+			
+		}
+
+		private void installConnectorFacets(IProject aProject, String specVersion, boolean existing) {
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			facetDMs.add(setupJavaInstallAction(aProject,existing,CreationConstants.DEFAULT_CONNECTOR_SOURCE_FOLDER));
+			IDataModel newModel = setupConnectorInstallAction(aProject,specVersion);
+			facetDMs.add(newModel);
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			}
+			
+		}
+
+		private void installEARFacets(IProject aProject, String specVersion, boolean existing) {
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			IDataModel newModel = setupEarInstallAction(aProject,specVersion);
+			facetDMs.add(newModel);
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			}
+			
+		}
+
+		private void installAppClientFacets(IProject aProject, String specVersion, boolean existing) {
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			facetDMs.add(setupJavaInstallAction(aProject,existing,CreationConstants.DEFAULT_APPCLIENT_SOURCE_FOLDER));
+			IDataModel newModel = setupAppClientInstallAction(aProject,specVersion);
+			facetDMs.add(newModel);
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			}
+			
+		}
+
+		private void installEJBFacets(IProject ejbProject2,String ejbVersion, boolean existing) {
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, ejbProject2.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			facetDMs.add(setupJavaInstallAction(ejbProject2,existing,CreationConstants.DEFAULT_EJB_SOURCE_FOLDER));
+			IDataModel newModel = setupEjbInstallAction(ejbProject2,ejbVersion,existing);
+			facetDMs.add(newModel);
+			//setRuntime(ejbProject2,dm); //Setting runtime property
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			}
+			
+		}
+		private void installWEBFacets(IProject webProj,String specVersion, boolean existing) {
+			removeOldWebContainerIfNecessary(project);
+			
+			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, webProj.getName());
+			FacetDataModelMap facetDMs = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			facetDMs.add(setupJavaInstallAction(webProj,existing,CreationConstants.DEFAULT_WEB_SOURCE_FOLDER));
+			IDataModel newModel = setupWebInstallAction(webProj,specVersion);
+			facetDMs.add(newModel);
+			//setRuntime(webProj,dm); //Setting runtime property
+			try {
+				/**
+				 * Warning cleanup 12/07/2005
+				 */
+				//IStatus stat =  dm.getDefaultOperation().execute(null,null);
+				dm.getDefaultOperation().execute(null,null);
+			} catch (ExecutionException e) {
+				Throwable realException = e.getCause();
+				if (realException != null && realException instanceof CoreException) {
+					IStatus st = ((CoreException)realException).getStatus();
+					if (st != null)
+						System.out.println(st);
+					realException.printStackTrace();
+				}
+			} catch (Exception ex) {
+				if (ex != null && ex instanceof CoreException) {
+					IStatus st = ((CoreException)ex).getStatus();
+					if (st != null)
+						System.out.println(st);
+					ex.printStackTrace();
+				}
+			}
+			
+			
+		}
+		private void removeOldWebContainerIfNecessary(IProject webProj) {
+
+			IJavaProject jproj = JemProjectUtilities.getJavaProject(webProj);
+			final IClasspathEntry[] current;
+			try {
+				current = jproj.getRawClasspath();
+				List updatedList = new ArrayList();
+				for (int i = 0; i < current.length; i++) {
+					IClasspathEntry entry = current[i];
+					if ((entry.getPath().toString().indexOf(WEB_LIB_CONTAINER) == -1) && (entry.getPath().toString().indexOf(WEB_LIB_PATH) == -1))
+						updatedList.add(entry);
+				}
+				IClasspathEntry[] updated = (IClasspathEntry[])updatedList.toArray(new IClasspathEntry[updatedList.size()]);
+				jproj.setRawClasspath(updated, null);
+			} catch (JavaModelException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			
+		}
+
+		protected IRuntime getRuntimeByID(String id) {
+			IRuntime[] targets = ServerUtil.getRuntimes("", "");
+			for (int i = 0; i < targets.length; i++) {
+				IRuntime target = targets[i];
+				if (id.equals(target.getId()))
+					return target;
+			}
+			return null;
+		}
+		/**@deprecated 
+		 * If this method is not used it should be removed at a later time, marking as deprecated
+		 * Warning cleanup 12/07/2005
+		 */
+		private void setRuntime(IProject aProject,IDataModel facetModel) {
+
+			IRuntime runtime = ServerCore.getProjectProperties(aProject).getRuntimeTarget();
+			try {
+				if (runtime != null) {
+					IRuntime run = getRuntimeByID(runtime.getId());
+					org.eclipse.wst.common.project.facet.core.runtime.IRuntime facetRuntime = null;
+					try {
+						if (run != null)
+							facetRuntime = FacetUtil.getRuntime(run);
+					}
+					catch (IllegalArgumentException ex)
+					{}
+					if (facetRuntime != null) {
+						facetModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_RUNTIME,facetRuntime);
+					}
+				}
+				} catch (IllegalArgumentException e) {
+				Logger.getLogger().logError(e);
+			}
+		
+			
+		}
+
+		protected IDataModel setupEjbInstallAction(IProject aProject,String ejbVersion, boolean existing) {
+			IDataModel ejbFacetInstallDataModel = DataModelFactory.createDataModel(new EjbFacetInstallDataModelProvider());
+			ejbFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			ejbFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, ejbVersion);
+			ejbFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,false);
+			ejbFacetInstallDataModel.setStringProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME,null);
+			if (!existing)
+				ejbFacetInstallDataModel.setProperty(IEjbFacetInstallDataModelProperties.CONFIG_FOLDER, CreationConstants.DEFAULT_EJB_SOURCE_FOLDER);
+			return ejbFacetInstallDataModel;
+		}
+
+		protected IDataModel setupWebInstallAction(IProject aProject,String specVersion) {
+			IDataModel webFacetInstallDataModel = DataModelFactory.createDataModel(new WebFacetInstallDataModelProvider());
+			webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, aProject.getName());
+			webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, specVersion);
+			webFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,false);
+			webFacetInstallDataModel.setStringProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME,null);
+			return webFacetInstallDataModel;
+		}
+
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEDependenciesPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEDependenciesPage.java
index 66dd0ec..b38f19e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEDependenciesPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/J2EEDependenciesPage.java
@@ -1,56 +1,199 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc, IBM Corporation
+ * 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:
+ * IBM Corporation - initial implementation as prop page heirarchy
+ * rfrost@bea.com - conversion to single property page impl
+ *******************************************************************************/
+
 package org.eclipse.jst.j2ee.internal;
 
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.swt.SWT;
 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.Label;
+import org.eclipse.swt.widgets.TabFolder;
+import org.eclipse.swt.widgets.TabItem;
 import org.eclipse.swt.widgets.Text;
 import org.eclipse.ui.dialogs.PropertyPage;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 
+/**
+ * Primary project property page for J2EE dependencies; content is dynamically 
+ * generated based on the project facets and will be comprised by a
+ * set of IJ2EEDependenciesControl implementations.
+ */
 public class J2EEDependenciesPage extends PropertyPage {
 	
 	public String DESCRIPTION = J2EEUIMessages.getResourceString("DESCRIPTION"); //$NON-NLS-1$
 
+	private IProject project;
+	private IJ2EEDependenciesControl[] controls;
+	
 	public J2EEDependenciesPage() {
 		super();
 	}
-
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
+	 */
 	protected Control createContents(Composite parent) {
-		Composite composite = new Composite(parent, SWT.NONE);
-		GridLayout layout = new GridLayout();
+		
+		// Need to find out what type of project we are handling
+		project = (IProject) getElement().getAdapter(IResource.class);
+		boolean isEAR = false;
+		boolean isWEB = false;
+		try {
+			final IFacetedProject facetedProject = ProjectFacetsManager.create(project);
+			isEAR = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE)); 
+			isWEB = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_WEB_MODULE));
+		} catch (CoreException ce) {
+			final String errorCheckingFacet = ManifestUIResourceHandler.Error_Checking_Project_Facets;
+			setErrorMessage(errorCheckingFacet);
+			setValid(false);
+			return getErrorComposite(parent, errorCheckingFacet);
+		}
+		
+		if (isEAR) {
+			return createEARContent(parent);
+		} else if (isWEB) {
+			return createWebContent(parent);
+		} else {
+			return createNonEARContent(parent);
+		}
+	}
+	
+	private Composite getErrorComposite(final Composite parent, final String error) {
+		final Composite composite = new Composite(parent, SWT.NONE);
+		final GridLayout layout = new GridLayout();
         layout.marginWidth = 0;
         layout.marginWidth = 0;
         composite.setLayout(layout);
         composite.setLayoutData(new GridData(GridData.FILL_BOTH));
-        createLabelsComposite(composite);
+		final Label label= new Label(composite, SWT.NONE);
+		label.setText(error);
 		return composite;
+	}
 	
+	private Composite createEARContent(final Composite parent) {
+		controls = new IJ2EEDependenciesControl[1];
+		controls[0] = new AddModulestoEARPropertiesPage(project, this);
+		return controls[0].createContents(parent);
+	}
+	
+	private Composite createWebContent(final Composite parent) {
+		final boolean standalone = J2EEProjectUtilities.isStandaloneProject(project);
+		
+		if (standalone) {
+			// only need to create the Web Libraries page
+			controls = new IJ2EEDependenciesControl[1];
+			controls[0] = new WebLibDependencyPropertiesPage(project, this);
+			return controls[0].createContents(parent);
+		} else {
+			// Create a tabbed folder with both "J2EE Modules" and "Web Libraries"
+			final TabFolder folder = new TabFolder(parent, SWT.LEFT);
+			folder.setLayoutData(new GridData(GridData.FILL_BOTH));
+			folder.setFont(parent.getFont());
+
+			// Create the two tabs 
+			controls = new IJ2EEDependenciesControl[2];
+		
+			controls[0] = new JARDependencyPropertiesPage(project, this);
+			TabItem tab = new TabItem(folder, SWT.NONE);
+			tab.setControl(controls[0].createContents(folder));
+			tab.setText(ManifestUIResourceHandler.J2EE_Modules);
+			controls[1] = new WebLibDependencyPropertiesPage(project, this);		
+			tab = new TabItem(folder, SWT.NONE);
+			tab.setControl(controls[1].createContents(folder));
+			tab.setText(ManifestUIResourceHandler.Web_Libraries);
+		
+			folder.setSelection(0);
+			return folder;
+		}
+	}
+	
+	private Composite createNonEARContent(final Composite parent) {
+		controls = new IJ2EEDependenciesControl[1];
+		controls[0] = new JARDependencyPropertiesPage(project, this);
+		return controls[0].createContents(parent);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jface.preference.IPreferencePage#performOk()
+	 */
+	public boolean performOk() {
+		for (int i = 0; i < controls.length; i++) {
+			if (!controls[i].performOk()) {
+				return false;
+			}
+		}
+		return true;
 	}
 
-	private void createLabelsComposite(Composite parent) {
-		Composite labelsGroup = new Composite(parent, SWT.NONE);
+	/* (non-Javadoc)
+	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
+	 */
+	public void performDefaults() {
+		for (int i = 0; i < controls.length; i++) {
+			controls[i].performDefaults();
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jface.preference.IPreferencePage#performCancel()
+	 */
+	public boolean performCancel() {
+		for (int i = 0; i < controls.length; i++) {
+			if (!controls[i].performCancel()) {
+				return false;
+			}
+		}
+		return super.performCancel();
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
+	 */
+	public void setVisible(boolean visible) {
+		super.setVisible(visible);
+		for (int i = 0; i < controls.length; i++) {
+			controls[i].setVisible(visible);
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jface.dialogs.IDialogPage#dispose()
+	 */
+	public void dispose() {
+		super.dispose();
+		for (int i = 0; i < controls.length; i++) {
+			controls[i].dispose();
+		}
+	}
+
+	protected static void createDescriptionComposite(final Composite parent, final String description) {
+		Composite descriptionComp = new Composite(parent, SWT.NONE);
 		GridLayout layout = new GridLayout();
 		layout.numColumns = 1;
-		labelsGroup.setLayout(layout);
-		labelsGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Label label = new Label(labelsGroup, SWT.NONE);
-		label.setText(ManifestUIResourceHandler.getString("EAR_Modules")); //$NON-NLS-1$
-		fillDescription(labelsGroup, ManifestUIResourceHandler.getString("EAR_Modules_Desc")); //$NON-NLS-1$
-		
-		label = new Label(labelsGroup, SWT.NONE);
-		label.setText(ManifestUIResourceHandler.getString("J2EE_Modules")); //$NON-NLS-1$
-		fillDescription(labelsGroup, ManifestUIResourceHandler.getString("J2EE_Modules_Desc")); //$NON-NLS-1$
-		
-		label = new Label(labelsGroup, SWT.NONE);
-		label.setText(ManifestUIResourceHandler.getString("Web_Libraries")); //$NON-NLS-1$
-		fillDescription(labelsGroup, ManifestUIResourceHandler.getString("Web_Libraries_Desc")); //$NON-NLS-1$
+		descriptionComp.setLayout(layout);
+		descriptionComp.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		fillDescription(descriptionComp, description);
 	}
 	
-	private void fillDescription(Composite c, String s) {
+	private static void fillDescription(Composite c, String s) {
 		GridData data = new GridData();
 		data.horizontalSpan = 2;
 		data.horizontalIndent = 15;
@@ -58,13 +201,12 @@
 		data.horizontalSpan = 2;
 		data.horizontalIndent = 15;
 		data.widthHint = 250;
-		data.heightHint = 70;
+		data.heightHint = 50;
 		Text text = new Text(c, SWT.V_SCROLL | SWT.BORDER | SWT.MULTI | SWT.WRAP);
 		text.setLayoutData(data);
 		text.setTextLimit(80);
-		text.setSize(300, 120);
+		text.setSize(250, 50);
 		text.setEditable(false);
 		text.setText(s);
 	}
-
 }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/JARDependencyPropertiesPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/JARDependencyPropertiesPage.java
index 6d184ef..3c5eff4 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/JARDependencyPropertiesPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/JARDependencyPropertiesPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
@@ -17,7 +27,6 @@
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
@@ -29,7 +38,6 @@
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
 import org.eclipse.jface.operation.IRunnableWithProgress;
 import org.eclipse.jface.preference.IPreferencePage;
-import org.eclipse.jface.preference.PreferencePage;
 import org.eclipse.jface.viewers.CheckboxTableViewer;
 import org.eclipse.jface.viewers.ColumnWeightData;
 import org.eclipse.jface.viewers.TableLayout;
@@ -50,7 +58,6 @@
 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.Event;
 import org.eclipse.swt.widgets.Group;
 import org.eclipse.swt.widgets.Label;
@@ -58,7 +65,6 @@
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.TableColumn;
 import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.dialogs.PropertyPage;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.ModuleCoreNature;
 import org.eclipse.wst.common.componentcore.UnresolveableURIException;
@@ -76,9 +82,10 @@
  * TODO To change the template for this generated type comment go to
  * Window - Preferences - Java - Code Style - Code Templates
  */
-public class JARDependencyPropertiesPage extends PropertyPage implements IClasspathTableOwner, Listener, ClasspathModelListener, ICommonManifestUIConstants {
+public class JARDependencyPropertiesPage implements IJ2EEDependenciesControl, IClasspathTableOwner, Listener, ClasspathModelListener {
 
-    protected IProject project;
+    protected final IProject project;
+    protected final J2EEDependenciesPage propPage;
     protected IOException caughtManifestException;
     protected boolean isDirty;
     protected Text classPathText;
@@ -90,17 +97,22 @@
     protected Label manifestLabel;
     protected Label enterpriseApplicationLabel;
     protected Label availableDependentJars;
-  
 
     /**
-	 * Constructor for JARDependencyPropertiesPage.
+	 * Constructor for JARDependencyPropertiesControl
 	 */
-    public JARDependencyPropertiesPage() {
+    public JARDependencyPropertiesPage(final IProject project, 
+    		final J2EEDependenciesPage page) {
         super();
+        this.project = project;
+        this.propPage = page;
     }
 
+    /**
+     * Returns false if page should not be displayed 
+     * for the project.
+     */
     protected void initialize() {
-        project = (IProject) getElement().getAdapter(IResource.class);
         model = new ClasspathModel(null);
         model.setProject(project);
         if( model.getComponent() != null ){
@@ -111,7 +123,6 @@
     }
     
     public void dispose() {
-    	super.dispose();
     	if(model.earArtifactEdit != null) {
     		model.earArtifactEdit.dispose();
     		model.earArtifactEdit = null;
@@ -159,25 +170,17 @@
 
     protected void initializeValidateEditListener() {
         validateEditListener = new ValidateEditListener(null, model);
-        validateEditListener.setShell(getShell());
+        validateEditListener.setShell(propPage.getShell());
     }
 
-    /**
-	 * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
-	 */
     public void setVisible(boolean visible) {
-        super.setVisible(visible);
         if (visible && caughtManifestException != null && !model.isDirty())
-            ManifestErrorPrompter.showManifestException(getShell(), ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE, false, caughtManifestException);
+            ManifestErrorPrompter.showManifestException(propPage.getShell(), ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE, false, caughtManifestException);
 
     }
 
-    /**
-	 * @see PreferencePage#createContents(Composite)
-	 */
-    protected Control createContents(Composite parent) {
-        initialize();
-
+    public Composite createContents(Composite parent) {
+    	initialize(); 
         Composite composite = createBasicComposite(parent);
         GridLayout layout = new GridLayout();
         layout.marginWidth = 0;
@@ -187,6 +190,7 @@
         if( model.getComponent() != null ){        
 	        if(!isValidComponent())
 	        	return composite;
+	        J2EEDependenciesPage.createDescriptionComposite(composite, ManifestUIResourceHandler.J2EE_Modules_Desc);
 	        createProjectLabelsGroup(composite);
 	        createListGroup(composite);
 	        createTextGroup(composite);
@@ -211,10 +215,10 @@
 
 	protected boolean isValidComponent() {
 		if (J2EEProjectUtilities.isEARProject(project)) {
-			this.setErrorMessage(ManifestUIResourceHandler.getString("EAR_Module_Dep_Error")); //$NON-NLS-1$
+			propPage.setErrorMessage(ManifestUIResourceHandler.EAR_Module_Dep_Error); 
 			return false;
 		} else if (J2EEProjectUtilities.isStandaloneProject(model.getComponent().getProject()) ) {
-			this.setErrorMessage(ClasspathModel.NO_EAR_MESSAGE);
+			propPage.setErrorMessage(ClasspathModel.NO_EAR_MESSAGE);
 			return false;
 		}
 		return true;
@@ -227,15 +231,16 @@
 		layout.numColumns = 2;
 		labelsGroup.setLayout(layout);
 		labelsGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
+		/*
 		Label label = new Label(labelsGroup, SWT.NONE);
-		label.setText(ManifestUIResourceHandler.getString("Project_name__UI_")); //$NON-NLS-1$ = "Project name:"
+		label.setText(ManifestUIResourceHandler.Project_name__UI_); 
 
 		componentNameText = new Text(labelsGroup, SWT.BORDER);
 		GridData data = new GridData(GridData.FILL_HORIZONTAL);
 		componentNameText.setEditable(false);
 		componentNameText.setLayoutData(data);
 		componentNameText.setText(project.getName());
+		*/
 		
 		createEnterpriseAppsControls(labelsGroup);
 
@@ -244,7 +249,7 @@
     private void createEnterpriseAppsControls(Composite labelsGroup) {
 
 		enterpriseApplicationLabel = new Label(labelsGroup, SWT.NONE);
-		enterpriseApplicationLabel.setText(ManifestUIResourceHandler.getString("EAR_Project_Name__UI__UI_")); //$NON-NLS-1$ = "EAR project name:"
+		enterpriseApplicationLabel.setText(ManifestUIResourceHandler.EAR_Project_Name__UI__UI_); 
 
 		availableAppsCombo = new CCombo(labelsGroup, SWT.READ_ONLY | SWT.BORDER);
 		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
@@ -267,7 +272,7 @@
 
         availableDependentJars = new Label(listGroup, SWT.NONE);
         gData = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL);
-        availableDependentJars.setText(ManifestUIResourceHandler.getString("Available_dependent_JARs__UI_")); //$NON-NLS-1$ = "Available dependent JARs:"
+        availableDependentJars.setText(ManifestUIResourceHandler.Available_dependent_JARs__UI_); 
         availableDependentJars.setLayoutData(gData);
         createTableComposite(listGroup);
     }
@@ -296,7 +301,7 @@
     protected void createClassPathText(Composite textGroup) {
     	
     	manifestLabel = new Label(textGroup, SWT.NONE);
-		manifestLabel.setText(ManifestUIResourceHandler.getString("Manifest_Class-Path__UI_")); //$NON-NLS-1$ = "Manifest Class-Path:"
+		manifestLabel.setText(ManifestUIResourceHandler.Manifest_Class_Path__UI_); 
 		
         classPathText = new Text(textGroup, SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
         GridData gData = new GridData(GridData.FILL_BOTH);
@@ -335,11 +340,11 @@
 
         // table columns
         TableColumn fileNameColumn = new TableColumn(table, SWT.NONE, 0);
-        fileNameColumn.setText(ManifestUIResourceHandler.getString("JAR/Module_UI_")); //$NON-NLS-1$
+        fileNameColumn.setText(ManifestUIResourceHandler.JAR_Module_UI_); 
         fileNameColumn.setResizable(true);
 
         TableColumn projectColumn = new TableColumn(table, SWT.NONE, 1);
-        projectColumn.setText(ManifestUIResourceHandler.getString("Project_UI_")); //$NON-NLS-1$ = "Project"
+        projectColumn.setText(ManifestUIResourceHandler.Project_UI_); 
         projectColumn.setResizable(true);
         tableLayout.layout(table, true);
         return availableJARsViewer;
@@ -432,10 +437,7 @@
             tableManager.refresh();
     }
 
-    /**
-	 * @see PreferencePage#performDefaults()
-	 */
-    protected void performDefaults() {
+    public void performDefaults() {
         model.resetClassPathSelection();
         refresh();
         isDirty = false;
@@ -444,7 +446,7 @@
     
     public boolean performCancel() {
     	model.dispose();
-    	return super.performCancel();
+    	return true;
     }
 
     /**
@@ -455,14 +457,18 @@
             return true;
         WorkspaceModifyComposedOperation composed = new WorkspaceModifyComposedOperation(createManifestOperation());
         composed.addRunnable(createBuildPathOperation());
+        
+        WorkspaceModifyComposedOperation op = createJ2EEComponentDependencyOperations();
+        if( op != null )
+        	composed.addRunnable(op);
         try {
-            new ProgressMonitorDialog(getShell()).run(true, true, composed);
+            new ProgressMonitorDialog(propPage.getShell()).run(true, true, composed);
         } catch (InvocationTargetException ex) {
-            String title = ManifestUIResourceHandler.getString("An_internal_error_occurred_ERROR_"); //$NON-NLS-1$
+            String title = ManifestUIResourceHandler.An_internal_error_occurred_ERROR_; 
             String msg = title;
             if (ex.getTargetException() != null && ex.getTargetException().getMessage() != null)
                 msg = ex.getTargetException().getMessage();
-            MessageDialog.openError(this.getShell(), title, msg);
+            MessageDialog.openError(propPage.getShell(), title, msg);
             org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ex);
             return false;
         } catch (InterruptedException e) {
@@ -494,6 +500,62 @@
 //		return true;
 //    }
 
+    
+	protected WorkspaceModifyComposedOperation createJ2EEComponentDependencyOperations() {
+		WorkspaceModifyComposedOperation composedOp = null;
+		List selected = getSelectedClassPathSelection().getClasspathElements();
+		List unselected = getUnSelectedClassPathSelection().getClasspathElements();
+		
+		List targetComponentsHandles = new ArrayList();
+		for (int i = 0; i < selected.size(); i++) {
+			ClasspathElement element = (ClasspathElement) selected.get(i);
+			IProject elementProject = element.getProject();
+			if( elementProject != null ){
+				IVirtualComponent targetComp = ComponentCore.createComponent(elementProject);
+				targetComponentsHandles.add(targetComp);
+			}
+		}
+ 		if (!targetComponentsHandles.isEmpty()) {
+  			composedOp = new WorkspaceModifyComposedOperation();
+ 			composedOp.addRunnable(WTPUIPlugin.getRunnableWithProgress(ComponentUtilities.createReferenceComponentOperation(model.getComponent(), targetComponentsHandles)));
+  		}
+  		targetComponentsHandles = new ArrayList();
+		for (int i = 0; i < unselected.size(); i++) {
+			ClasspathElement element = (ClasspathElement) unselected.get(i);
+			IProject elementProject = element.getProject();
+			if( elementProject != null ){
+				if (ModuleCoreNature.isFlexibleProject(elementProject)) {
+					IVirtualComponent targetComp = ComponentCore.createComponent(elementProject);
+					targetComponentsHandles.add(targetComp);
+				}
+			}else{
+				URI archiveURI = element.getArchiveURI();
+				if( archiveURI != null && !archiveURI.equals("") ){ //$NON-NLS-1$
+					String name = ""; //$NON-NLS-1$
+					try {
+						String type = ModuleURIUtil.getArchiveType(archiveURI);
+						String tmpname = ModuleURIUtil.getArchiveName(archiveURI);
+						name = type + IPath.SEPARATOR + tmpname;
+					} catch (UnresolveableURIException e) {
+						Logger.getLogger().logError(e.getMessage());
+					}
+					if( !name.equals("")){ //$NON-NLS-1$
+						IVirtualReference ref = model.getComponent().getReference(name);
+						IVirtualComponent referenced = ref.getReferencedComponent();
+						targetComponentsHandles.add(referenced);
+					}	
+				}
+			}
+		}
+		if (!targetComponentsHandles.isEmpty()) {
+			if(composedOp == null)
+				composedOp = new WorkspaceModifyComposedOperation();
+			composedOp.addRunnable(WTPUIPlugin.getRunnableWithProgress(ComponentUtilities.removeReferenceComponentOperation(model.getComponent(), targetComponentsHandles)));
+		}
+		return composedOp;
+	}
+	
+	
 	protected WorkspaceModifyComposedOperation createComponentDependencyOperations() {
 		WorkspaceModifyComposedOperation composedOp = null;
 		List selected = getSelectedClassPathSelectionForWLPs().getClasspathElements();
@@ -543,7 +605,7 @@
 		if (!targetComponentsHandles.isEmpty()) {
 			if(composedOp == null)
 				composedOp = new WorkspaceModifyComposedOperation();
-			composedOp.addRunnable(WTPUIPlugin.getRunnableWithProgress(ComponentUtilities.removeReferenceComponentOperation(model.getComponent(), targetComponentsHandles)));
+			composedOp.addRunnable(WTPUIPlugin.getRunnableWithProgress(ComponentUtilities.removeWLPReferenceComponentOperation(model.getComponent(), targetComponentsHandles)));
 		}
 		return composedOp;
 	}
@@ -589,6 +651,28 @@
 		return selection;
 	}
 	
+    private ClassPathSelection getSelectedClassPathSelection() {
+		ClassPathSelection selection = new ClassPathSelection();
+		Object[] checkedElements = tableManager.availableJARsViewer.getCheckedElements();
+		for(int i = 0; i < checkedElements.length; i++) {
+			selection.getClasspathElements().add(checkedElements[i]);
+		}
+		return selection;
+    }
+    
+	protected ClassPathSelection getUnSelectedClassPathSelection() {
+		ClassPathSelection selection = new ClassPathSelection();
+		Object[] checkedElements = tableManager.availableJARsViewer.getCheckedElements();
+		List modelElements = model.getClassPathSelection().getClasspathElements();
+		for (int i = 0; i < modelElements.size(); i++) {
+			List checkedElementsList = Arrays.asList(checkedElements);
+			if (!checkedElementsList.contains(modelElements.get(i))) {
+				selection.getClasspathElements().add(modelElements.get(i));
+			}
+		}
+		return selection;
+	}
+	
     
     private ClassPathSelection getSelectedClassPathSelectionForWLPs() {
     		ClassPathSelection selection = new ClassPathSelection();
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestErrorPrompter.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestErrorPrompter.java
index f18b120..e70c7e7 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestErrorPrompter.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestErrorPrompter.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestUIResourceHandler.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestUIResourceHandler.java
index 9d32806..f4814b9 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestUIResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ManifestUIResourceHandler.java
@@ -1,60 +1,57 @@
-/*
- * Created on Jan 17, 2005
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
  *
- * TODO To change the template for this generated file go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-/**
- * @author jialin
- *
- * TODO To change the template for this generated type comment go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
-public class ManifestUIResourceHandler {
+public final class ManifestUIResourceHandler extends NLS {
 
-	private static ResourceBundle fgResourceBundle;
+	private static final String BUNDLE_NAME = "manifest_ui";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("manifest_ui");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String) will return the key
-			// it was called with
-		}
-		return null;
+	private ManifestUIResourceHandler() {
+		// Do not instantiate
 	}
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle= getResourceBundle();
-		}
-		
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		} 
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+
+	public static String Up_1;
+	public static String Down_2;
+	public static String Select_All_3;
+	public static String Deselect_All_4;
+	public static String ERROR_READING_MANIFEST_DIALOG_TITLE;
+	public static String SAVE_MANIFEST_WITH_ERROR;
+	public static String ERROR_READING_MANIFEST_DIALOG_MESSAGE_EDITOR;
+	public static String ERROR_READING_MANIFEST_DIALOG_MESSAGE_PROP_PAGE;
+	public static String MANIFEST_PROBLEM_1;
+	public static String MANIFEST_PROBLEM_2;
+	public static String MANIFEST_PROBLEM_3;
+	public static String MANIFEST_PROBLEM_4;
+	public static String An_internal_error_occurred_ERROR_;
+	public static String Project_name__UI_;
+	public static String EAR_Project_Name__UI__UI_;
+	public static String Available_dependent_JARs__UI_;
+	public static String Manifest_Class_Path__UI_;
+	public static String JAR_Module_UI_;
+	public static String Project_UI_;
+	public static String EAR_Modules;
+	public static String EAR_Modules_Desc;
+	public static String J2EE_Modules;
+	public static String J2EE_Modules_Desc;
+	public static String Web_Libraries;
+	public static String Web_Libraries_Desc;
+	public static String EAR_Module_Dep_Error;
+	public static String Jar_Dep_One_Module_Error;
+	public static String Web_Lib_Error;
+	public static String REDIRECT_TEXT_EDITOR_UI_;
+	public static String Error_Checking_Project_Facets;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, ManifestUIResourceHandler.class);
 	}
-public static String getString(String key, Object[] args) {
-
-	try {return MessageFormat.format(getString(key), args);}
-	catch (IllegalArgumentException e) {return getString(key);}
-
-}
-	public static String getString(String key, Object[] args, int x) {
-
-		return getString(key);
-	}
-}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/UpdateManifestOperation.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/UpdateManifestOperation.java
index 1551033..cdf1c19 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/UpdateManifestOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/UpdateManifestOperation.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WebLibDependencyPropertiesPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WebLibDependencyPropertiesPage.java
index edb10da..1da2f8e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WebLibDependencyPropertiesPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WebLibDependencyPropertiesPage.java
@@ -1,8 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 
+import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.emf.common.util.URI;
@@ -13,7 +24,6 @@
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
 import org.eclipse.jface.operation.IRunnableWithProgress;
-import org.eclipse.jface.preference.PreferencePage;
 import org.eclipse.jst.j2ee.application.internal.operations.ClassPathSelection;
 import org.eclipse.jst.j2ee.application.internal.operations.ClasspathElement;
 import org.eclipse.jst.j2ee.internal.common.ClasspathModelListener;
@@ -23,7 +33,6 @@
 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.Label;
 import org.eclipse.swt.widgets.Listener;
 import org.eclipse.swt.widgets.Text;
@@ -37,20 +46,19 @@
 
 public class WebLibDependencyPropertiesPage extends JARDependencyPropertiesPage implements IClasspathTableOwner, Listener, ClasspathModelListener {
 
-	public WebLibDependencyPropertiesPage() {
-		super();
+	public WebLibDependencyPropertiesPage(final IProject project, 
+    		final J2EEDependenciesPage page) {
+		super(project, page);
 	}
 	
-	/**
-	 * @see PreferencePage#createContents(Composite)
-	 */
-    protected Control createContents(Composite parent) {
-		initialize();
+    public Composite createContents(Composite parent) {
+    	initialize(); 
 		Composite composite = createBasicComposite(parent);
 		if( model.getComponent() != null ){
 			if (!isValidWebModule())
 				return composite;
-			createProjectLabelsGroup(composite);
+	        J2EEDependenciesPage.createDescriptionComposite(composite, ManifestUIResourceHandler.Web_Libraries_Desc);
+			//createProjectLabelsGroup(composite);
 			createListGroup(composite);
 			handleWLPSupport();
 			model.setWLPModel(true);
@@ -68,7 +76,7 @@
 		labelsGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 
 		Label label = new Label(labelsGroup, SWT.NONE);
-		label.setText(ManifestUIResourceHandler.getString("Project_name__UI_")); //$NON-NLS-1$ = "Project name:"
+		label.setText(ManifestUIResourceHandler.Project_name__UI_); 
 
 		componentNameText = new Text(labelsGroup, SWT.BORDER);
 		GridData data = new GridData(GridData.FILL_HORIZONTAL);
@@ -90,7 +98,7 @@
 
         availableDependentJars = new Label(listGroup, SWT.NONE);
         gData = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL);
-        availableDependentJars.setText(ManifestUIResourceHandler.getString("Available_dependent_JARs__UI_")); //$NON-NLS-1$ = "Available dependent JARs:"
+        availableDependentJars.setText(ManifestUIResourceHandler.Available_dependent_JARs__UI_); 
         availableDependentJars.setLayoutData(gData);
         createTableComposite(listGroup);
     }
@@ -106,7 +114,7 @@
     
     protected boolean isValidWebModule() {
 		if (!J2EEProjectUtilities.isDynamicWebProject(project)) {
-			this.setErrorMessage(ManifestUIResourceHandler.getString("Web_Lib_Error")); //$NON-NLS-1$
+			propPage.setErrorMessage(ManifestUIResourceHandler.Web_Lib_Error); 
 			return false;
 		}
 		return true;
@@ -121,18 +129,20 @@
 			tableManager.deselectAllButton.setEnabled(true);
 		}
 	}
-	
     
     private void handleWLPSupport() {
-			tableManager.setWLPEntry(true);
-			availableDependentJars.setText("Select utility projects to add as Web Library projects to the web module"); //$NON-NLS-1$
-			tableManager.refresh();
+		tableManager.setWLPEntry(true);
+		availableDependentJars.setText("Select utility projects to add as Web Library projects to the web module"); //$NON-NLS-1$
+		tableManager.refresh();
 	}
     
     public boolean performOk() {
 		if( model.getComponent() == null || !isValidWebModule()){
 			return true;
-		}	
+		}
+		if (!isDirty) {
+            return true;
+		}
 		try {
 			boolean createdFlexProjects = runWLPOp(createFlexProjectOperations());
 			boolean createdComponentDependency = false;
@@ -144,6 +154,7 @@
 				composedOp.addRunnable(createWLPBuildPathOperation());
 				createdBuildPathSettings = runWLPOp(composedOp);
 			}
+			isDirty = false;
 			return createdBuildPathSettings;
 		} finally {
 			model.dispose();
@@ -153,13 +164,13 @@
     private boolean runWLPOp(WorkspaceModifyComposedOperation composed) {
     	try {
 			if (composed != null)
-				new ProgressMonitorDialog(getShell()).run(true, true, composed);
+				new ProgressMonitorDialog(propPage.getShell()).run(true, true, composed);
 		} catch (InvocationTargetException ex) {
-			String title = ManifestUIResourceHandler.getString("An_internal_error_occurred_ERROR_"); //$NON-NLS-1$
+			String title = ManifestUIResourceHandler.An_internal_error_occurred_ERROR_; 
 			String msg = title;
 			if (ex.getTargetException() != null && ex.getTargetException().getMessage() != null)
 				msg = ex.getTargetException().getMessage();
-			MessageDialog.openError(this.getShell(), title, msg);
+			MessageDialog.openError(propPage.getShell(), title, msg);
 			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ex);
 			return false;
 		} catch (InterruptedException e) {
@@ -172,7 +183,7 @@
 		
 		if (J2EEProjectUtilities.isDynamicWebProject(project)){
 			
-			IPath[] selected= BuildPathDialogAccess.chooseExternalJAREntries(getShell());
+			IPath[] selected= BuildPathDialogAccess.chooseExternalJAREntries(propPage.getShell());
 	
 			if (selected != null) {
 				for (int i= 0; i < selected.length; i++) {
@@ -210,13 +221,13 @@
 					
 			        WorkspaceModifyComposedOperation composed = new WorkspaceModifyComposedOperation(createBuildPathOperationForExternalJar(selection));
 			        try {
-			            new ProgressMonitorDialog(getShell()).run(true, true, composed);
+			            new ProgressMonitorDialog(propPage.getShell()).run(true, true, composed);
 			        } catch (InvocationTargetException ex) {
-			            String title = ManifestUIResourceHandler.getString("An_internal_error_occurred_ERROR_"); //$NON-NLS-1$
+			            String title = ManifestUIResourceHandler.An_internal_error_occurred_ERROR_; 
 			            String msg = title;
 			            if (ex.getTargetException() != null && ex.getTargetException().getMessage() != null)
 			                msg = ex.getTargetException().getMessage();
-			            MessageDialog.openError(this.getShell(), title, msg);
+			            MessageDialog.openError(propPage.getShell(), title, msg);
 			            org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ex);
 			            
 			        } catch (InterruptedException e) {
@@ -236,7 +247,7 @@
 		
 		if (J2EEProjectUtilities.isDynamicWebProject(project)){
 			IPath existingPath[] = new Path[0];
-			IPath[] paths =  BuildPathDialogAccess.chooseVariableEntries(getShell(), existingPath);
+			IPath[] paths =  BuildPathDialogAccess.chooseVariableEntries(propPage.getShell(), existingPath);
 			
 			if (paths != null) {
 				for (int i = 0; i < paths.length; i++) {
@@ -275,13 +286,13 @@
 						
 				        WorkspaceModifyComposedOperation composed = new WorkspaceModifyComposedOperation(createBuildPathOperationForExternalJar(selection));
 				        try {
-				            new ProgressMonitorDialog(getShell()).run(true, true, composed);
+				            new ProgressMonitorDialog(propPage.getShell()).run(true, true, composed);
 				        } catch (InvocationTargetException ex) {
-				            String title = ManifestUIResourceHandler.getString("An_internal_error_occurred_ERROR_"); //$NON-NLS-1$
+				            String title = ManifestUIResourceHandler.An_internal_error_occurred_ERROR_; 
 				            String msg = title;
 				            if (ex.getTargetException() != null && ex.getTargetException().getMessage() != null)
 				                msg = ex.getTargetException().getMessage();
-				            MessageDialog.openError(this.getShell(), title, msg);
+				            MessageDialog.openError(propPage.getShell(), title, msg);
 				            org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ex);
 				            
 				        } catch (InterruptedException e) {
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WorkspaceModifyComposedOperation.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WorkspaceModifyComposedOperation.java
index d53efb2..f0c7021 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WorkspaceModifyComposedOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/WorkspaceModifyComposedOperation.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractActionDelegate.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractActionDelegate.java
index ee8d0b6..9d9a71e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractActionDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractActionDelegate.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
@@ -220,4 +222,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenAction.java
index 71a917e..249a671 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -119,4 +119,4 @@
 		updateSelection((IStructuredSelection) selection);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardAction.java
index 941b6c9..d652982 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardAction.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
@@ -142,4 +144,4 @@
 	protected boolean shouldAcceptElement(Object obj) {
 		return true;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardWorkbenchAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardWorkbenchAction.java
index a87d22a..5c70936 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardWorkbenchAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/AbstractOpenWizardWorkbenchAction.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
@@ -56,4 +58,4 @@
 	public void selectionChanged(IAction action, ISelection selection) {
 		// do nothing. Action doesn't depend on selection.
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/BaseAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/BaseAction.java
index 6880e60..853a940 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/BaseAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/BaseAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -118,4 +118,4 @@
 		run();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/IJ2EEUIContextIds.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/IJ2EEUIContextIds.java
index 961434d..112e2ba 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/IJ2EEUIContextIds.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/IJ2EEUIContextIds.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -55,4 +55,4 @@
 	public static final String RENAME_EAR_DIALOG_1 = J2EEUIPlugin.PLUGIN_ID + ".navm3000"; //$NON-NLS-1$
 	public static final String RENAME_MODULE_DIALOG_1 = J2EEUIPlugin.PLUGIN_ID + ".navm3010"; //$NON-NLS-1$
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/ImportClassesAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/ImportClassesAction.java
index 6ac5653..abff486 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/ImportClassesAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/ImportClassesAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -60,4 +60,4 @@
 		dialog.open();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteAction.java
index 7231476..6697cf6 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteAction.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
@@ -416,4 +418,4 @@
 
 		ErrorDialog.openError(shell, null, null, status, IStatus.ERROR);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteModuleActionPopulator.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteModuleActionPopulator.java
index 728aa38..97d00f3 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteModuleActionPopulator.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeleteModuleActionPopulator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -44,4 +44,4 @@
 //		return dataModel;
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeployAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeployAction.java
index f66edde..59ab16f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeployAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEDeployAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,6 +19,7 @@
 import java.util.List;
 
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
@@ -26,9 +27,9 @@
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jst.j2ee.internal.deploy.DeployerRegistry;
 import org.eclipse.jst.j2ee.internal.deploy.J2EEDeployOperation;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.wst.server.core.IRuntime;
-import org.eclipse.wst.server.core.ServerCore;
 
 /**
  * @author cbridgha
@@ -100,7 +101,7 @@
 			for (int i = 0; i < modules.size(); i++) {
 				EObject module = (EObject) modules.get(i);
 				IProject proj = ProjectUtilities.getProject(module);
-				IRuntime runtime = ServerCore.getProjectProperties(proj).getRuntimeTarget();
+				IRuntime runtime = J2EEProjectUtilities.getServerRuntime(proj);
 				if (proj == null || runtime == null)
 					return false;
 				List visitors = reg.getDeployModuleExtensions(module, runtime);
@@ -108,11 +109,11 @@
 					return true;
 			}
 			return false;
-		} catch (RuntimeException e) {
+		} catch (CoreException e) {
 			System.out.println("Deploy Action recovering from problem verifying enablement."); //$NON-NLS-1$
 			e.printStackTrace();
 		}
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEModuleRenameChange.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEModuleRenameChange.java
index e8a70da..da682a4 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEModuleRenameChange.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEModuleRenameChange.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -122,6 +122,10 @@
 	/**
 	 * @return
 	 */
+	/**@deprecated 
+	 * If this method is not used it should be removed at a later time, marking as deprecated
+	 * Warning cleanup 12/07/2005
+	 */
 	private RenameOptions getRenameOptions() {
 		RenameOptions options = new RenameOptions();
 		options.setNewName(this.newName);
@@ -143,4 +147,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameAction.java
index 1e9859c..b5f6df4 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameAction.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
@@ -388,4 +390,4 @@
 
 		ErrorDialog.openError(shell, null, null, status, IStatus.ERROR);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameParticipant.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameParticipant.java
index c7c9dff..e52b7c6 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameParticipant.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EERenameParticipant.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -92,4 +92,4 @@
 	public RefactoringStatus checkConditions(IProgressMonitor pm, CheckConditionsContext context) throws OperationCanceledException {
 		return RefactoringStatus.create(Status.OK_STATUS);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEResourceOpenListener.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEResourceOpenListener.java
index 5afcc05..2d0657e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEResourceOpenListener.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/J2EEResourceOpenListener.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 2, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewAppClientComponentAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewAppClientComponentAction.java
index f005597..b8a2f7e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewAppClientComponentAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewAppClientComponentAction.java
@@ -1,18 +1,20 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
 import org.eclipse.jface.wizard.Wizard;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
-import org.eclipse.jst.j2ee.internal.wizard.AppClientComponentCreationWizard;
+import org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientProjectWizard;
 import org.eclipse.ui.IWorkbench;
 
 
@@ -33,7 +35,7 @@
 	}
 
 	protected Wizard createWizard() {
-		return new AppClientComponentCreationWizard();
+		return new AppClientProjectWizard();
 	}
 
 	protected boolean shouldAcceptElement(Object obj) {
@@ -43,4 +45,4 @@
 	protected String getDialogText() {
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewEARComponentAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewEARComponentAction.java
index 4de7409..3c96cb2 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewEARComponentAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/NewEARComponentAction.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.actions;
 
 
@@ -13,7 +15,7 @@
 import org.eclipse.jface.wizard.Wizard;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
-import org.eclipse.jst.j2ee.internal.wizard.EARComponentCreationWizard;
+import org.eclipse.jst.j2ee.ui.project.facet.EarProjectWizard;
 import org.eclipse.ui.IWorkbench;
 
 
@@ -33,7 +35,7 @@
 	}
 
 	protected Wizard createWizard() {
-		return new EARComponentCreationWizard();
+		return new EarProjectWizard();
 	}
 
 	protected boolean shouldAcceptElement(Object obj) {
@@ -43,4 +45,4 @@
 	protected String getDialogText() {
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/OpenJ2EEResourceAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/OpenJ2EEResourceAction.java
index 86cd9e4..e6f9ad9 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/OpenJ2EEResourceAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/OpenJ2EEResourceAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -228,4 +228,4 @@
 		}
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/WTPBaseAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/WTPBaseAction.java
index ef0dcce..5433410 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/WTPBaseAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/actions/WTPBaseAction.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jul 7, 2004
  * 
@@ -117,4 +119,4 @@
 	protected IStructuredSelection getSelection() {
 		return selection;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ExportApplicationClientAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ExportApplicationClientAction.java
index 599304b..296fd55 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ExportApplicationClientAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ExportApplicationClientAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -48,4 +48,4 @@
 		dialog.open();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ImportApplicationClientAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ImportApplicationClientAction.java
index c51e8be..eec6155 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ImportApplicationClientAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/client/actions/ImportApplicationClientAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -53,4 +53,4 @@
 		dialog.open();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEClipboard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEClipboard.java
index ea1c402..ea1fcca 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEClipboard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEClipboard.java
@@ -17,6 +17,10 @@
 import org.eclipse.emf.ecore.EObject;
 
 public class J2EEClipboard extends ArrayList {
+	/**
+	 * Warning cleanup 12/07/2005
+	 */
+	private static final long serialVersionUID = 8713021573099134096L;
 	private Map bindings;
 	private Map extensions;
 
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyCommand.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyCommand.java
index 99ee2c6..51dc0bd 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyCommand.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyCommand.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.command;
 
 
@@ -76,4 +78,4 @@
 	public void redo() {
 		//redo
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyFromClipboardCommand.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyFromClipboardCommand.java
index 4e9d19f..5581dec 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyFromClipboardCommand.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyFromClipboardCommand.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -93,4 +93,4 @@
 	public void undo() {
 		result = null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyToClipboardOverrideCommand.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyToClipboardOverrideCommand.java
index cf1fa3a..eb42b83 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyToClipboardOverrideCommand.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EECopyToClipboardOverrideCommand.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.command;
 
 
@@ -79,4 +81,4 @@
 			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEPasteFromClipboardOverrideCommand.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEPasteFromClipboardOverrideCommand.java
index be4cc5f..d51a6d5 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEPasteFromClipboardOverrideCommand.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/command/J2EEPasteFromClipboardOverrideCommand.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.command;
 
 
@@ -145,4 +147,4 @@
 		//		}
 		//	};
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseDeployableArtifactAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseDeployableArtifactAdapterFactory.java
index 87e364e..ea7adc7 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseDeployableArtifactAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseDeployableArtifactAdapterFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jan 18, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseModuleArtifact.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseModuleArtifact.java
index 41d4b7f..b3cb39e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseModuleArtifact.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/EnterpriseModuleArtifact.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableAdapterFactory.java
index 4ddf187..2127745 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableAdapterFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARComposite.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARComposite.java
index 36dfdd7..fa02515 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARComposite.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARComposite.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;
 
 
@@ -265,4 +267,4 @@
 			}
 		};
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARDialog.java
index f46d94e..76ca214 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteEARDialog.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;
 
 
@@ -62,4 +64,4 @@
 		return super.getContents();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteModuleDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteModuleDialog.java
index a3b0f0e..cfb80fe 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteModuleDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/DeleteModuleDialog.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/FilteredFileSelectionDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/FilteredFileSelectionDialog.java
index 38c9322..5442f2c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/FilteredFileSelectionDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/FilteredFileSelectionDialog.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -72,4 +72,4 @@
 		PlatformUI.getWorkbench().getHelpSystem().setHelp(this.getParentShell(), helpCode); //$NON-NLS-1$
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/J2EEDeployStatusDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/J2EEDeployStatusDialog.java
index e44a0b3..9e29ba9 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/J2EEDeployStatusDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/J2EEDeployStatusDialog.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -331,4 +331,4 @@
 		messageLabel.setText(message);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARComposite.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARComposite.java
index 0a0a18a..c74e3b8 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARComposite.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARComposite.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;
 
 
@@ -260,4 +262,4 @@
 			}
 		};
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARDialog.java
index b3bd549..e9cc80e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameEARDialog.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;
 
 
@@ -56,4 +58,4 @@
 		renameOptions = renameComposite.createRenameOptions();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameModuleDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameModuleDialog.java
index 1549dd3..a5ea814 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameModuleDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/RenameModuleDialog.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;
 
 
@@ -60,4 +62,4 @@
 		OKButton = getButton(0);
 		renameComposite.setOKButton(OKButton);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TwoArrayQuickSorter.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TwoArrayQuickSorter.java
index a5eb764..62d6907 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TwoArrayQuickSorter.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TwoArrayQuickSorter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -123,4 +123,4 @@
 		x[b] = t;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeJavaSearchScope.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeJavaSearchScope.java
index 980120a..6c430f6 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeJavaSearchScope.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeJavaSearchScope.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -349,4 +349,4 @@
 		//Default nothing
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeSearchEngine.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeSearchEngine.java
index dc739f2..353d443 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeSearchEngine.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeSearchEngine.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypedFileViewerFilter.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypedFileViewerFilter.java
index f92a0f6..7b42534 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypedFileViewerFilter.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypedFileViewerFilter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -69,4 +69,4 @@
 	public boolean select(Viewer viewer, Object parentElement, Object element) {
 		return isValid(element);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/EARImportListContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/EARImportListContentProvider.java
index f43d7f7..31c2471 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/EARImportListContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/EARImportListContentProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -69,4 +69,4 @@
 	public void inputChanged(org.eclipse.jface.viewers.Viewer viewer, Object oldInput, Object newInput) {
 		//do nothing
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ExportEARAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ExportEARAction.java
index d0c8d7b..a7078ae 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ExportEARAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ExportEARAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -49,4 +49,4 @@
 		dialog.create();
 		dialog.open();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ImportEARAction.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ImportEARAction.java
index 9531deb..305c3ec 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ImportEARAction.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ImportEARAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -52,4 +52,4 @@
 		dialog.open();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ModulesProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ModulesProvider.java
index 202444c..4914e7f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ModulesProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ear/actions/ModulesProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -135,4 +135,4 @@
 	public void removeListener(org.eclipse.jface.viewers.ILabelProviderListener listener) {
 		//do nothing
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/AbstractMethodsContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/AbstractMethodsContentProvider.java
index 50c4c7b..1eccf45 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/AbstractMethodsContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/AbstractMethodsContentProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ejb.provider;
 
 
@@ -311,4 +313,4 @@
 	protected abstract EStructuralFeature getMethodElementsReference();
 
 	protected abstract EStructuralFeature getMethodElementsContainerReference();
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/EJBUIMessages.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/EJBUIMessages.java
index 4858782..d03ed28 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/EJBUIMessages.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/EJBUIMessages.java
@@ -1,82 +1,31 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ejb.provider;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.wst.common.frameworks.internal.Messages;
+import org.eclipse.osgi.util.NLS;
 
 
-public class EJBUIMessages extends Messages {
+public class EJBUIMessages extends NLS {
 
-	public static final String IMAGE_LOAD_ERROR = "0"; //$NON-NLS-1$
-	public static final String EJB_PROJECT_WIZ_TITLE = "1"; //$NON-NLS-1$
-	public static final String EJB_VERSION_LBL = "2"; //$NON-NLS-1$
-	public static final String EJB_PROJECT_MAIN_PG_TITLE = "3"; //$NON-NLS-1$
-	public static final String EJB_PROJECT_MAIN_PG_DESC = "4"; //$NON-NLS-1$
-	public static final String EJB_IMPORT_MAIN_PG_DESC = "5"; //$NON-NLS-1$
-	public static final String EJB_IMPORT_MAIN_PG_TITLE = "6"; //$NON-NLS-1$
-	public static final String EJB_JAR_FILE_LBL = "7"; //$NON-NLS-1$
-	public static final String EJB_PROJECT_LBL = "8"; //$NON-NLS-1$
-	public static final String EJB_EXPORT_MAIN_PG_TITLE = "9"; //$NON-NLS-1$
-	public static final String EJB_EXPORT_MAIN_PG_DESC = "10"; //$NON-NLS-1$
-	public static final String EJB_Client_Title = "11"; //$NON-NLS-1$
-	public static final String EJB_Client_Desc = "12"; //$NON-NLS-1$
-	public static final String Client_JAR_URI = "13"; //$NON-NLS-1$
-	public static final String Project_name = "14"; //$NON-NLS-1$
-	public static final String Project_location = "15"; //$NON-NLS-1$
-	public static final String EJB_Project = "16"; //$NON-NLS-1$
-	public static final String DELETE_BEAN_ONLY = "17"; //$NON-NLS-1$
-	public static final String Delete_Bean_Classes_UI = "18"; //$NON-NLS-1$
-	public static final String Delete_Access_Bean = "19"; //$NON-NLS-1$
-	public static final String Delete_Deployed_Code = "20"; //$NON-NLS-1$
-	public static final String Select_All_UI = "21"; //$NON-NLS-1$
-	public static final String Deselect_All_UI = "22"; //$NON-NLS-1$
-	public static final String The_selected_Enterprise_Be = "23"; //$NON-NLS-1$
-	public static final String Delete = "24"; //$NON-NLS-1$
-	public static final String Cannot_delete_Enterprise_B = "25"; //$NON-NLS-1$
-	public static final String Cannot_delete_bean = "26"; //$NON-NLS-1$
-	public static final String Delete_Enterprise_Beans = "27"; //$NON-NLS-1$
-	public static final String Delete_Options_Query = "27"; //$NON-NLS-1$
+	private static final String BUNDLE_NAME = "j2ee_ejb_ui";//$NON-NLS-1$
 
-	private static EJBUIMessages INSTANCE = new EJBUIMessages();
-
-	/**
-	 * The constructor.
-	 */
 	private EJBUIMessages() {
-		super();
+		// Do not instantiate
 	}
 
-	/**
-	 * Returns the string from the resource bundle, or 'key' if not found.
-	 */
-	public static String getResourceString(String key) {
-		return INSTANCE.doGetResourceString(key);
-	}
+	public static String GroupedEJBJarItemProvider_UI_0;
+	public static String GroupedEJBJarItemProvider_UI_1;
+	public static String GroupedEJBJarItemProvider_UI_2;
 
-	public static String getResourceString(String key, Object[] args) {
-		return INSTANCE.doGetResourceString(key, args);
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, EJBUIMessages.class);
 	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.common.frameworks.internal.Messages#initializeBundle()
-	 */
-	protected void initializeBundle() {
-		try {
-			resourceBundle = ResourceBundle.getBundle("j2ee_ejb_ui"); //$NON-NLS-1$
-		} catch (MissingResourceException x) {
-			//Ignore
-		}
-	}
-
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/ExcludeListContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/ExcludeListContentProvider.java
index 58a7b5d..12c91ca 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/ExcludeListContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/ExcludeListContentProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ejb.provider;
 
 
@@ -135,4 +137,4 @@
 		return AD_EL_SF;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/GroupedEJBJarItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/GroupedEJBJarItemProvider.java
index 6186ccc..897ef71 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/GroupedEJBJarItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/GroupedEJBJarItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -49,9 +49,9 @@
 	private static Hashtable entityTable = new Hashtable();
 	private static Hashtable messageTable = new Hashtable();
 
-	private static final String SESSION = EJBUIMessages.getResourceString("GroupedEJBJarItemProvider_UI_0"); //$NON-NLS-1$
-	private static final String ENTITY = EJBUIMessages.getResourceString("GroupedEJBJarItemProvider_UI_1"); //$NON-NLS-1$
-	private static final String MESSAGE = EJBUIMessages.getResourceString("GroupedEJBJarItemProvider_UI_2"); //$NON-NLS-1$
+	private static final String SESSION = EJBUIMessages.GroupedEJBJarItemProvider_UI_0;
+	private static final String ENTITY = EJBUIMessages.GroupedEJBJarItemProvider_UI_1;
+	private static final String MESSAGE = EJBUIMessages.GroupedEJBJarItemProvider_UI_2;
 
 	//	Normally there is one instance of an item provider for all instances of the objecct
 	//	in the tree. The item provider would be stateless. However, because we are doing tricks
@@ -362,4 +362,4 @@
 			isDisposing = false;
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEEjbItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEEjbItemProviderAdapterFactory.java
index 0cf1822..f888d86 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEEjbItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEEjbItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -77,4 +77,4 @@
 		}
 		return messageDrivenItemProvider;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEJavaClassProviderHelper.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEJavaClassProviderHelper.java
index 2efc4c8..5660abf 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEJavaClassProviderHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/J2EEJavaClassProviderHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ejb.provider;
 
 
@@ -138,4 +140,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodPermissionsContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodPermissionsContentProvider.java
index 606fdb9..e2109e9 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodPermissionsContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodPermissionsContentProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ejb.provider;
 
 import java.util.Collections;
@@ -124,4 +126,4 @@
 		if (notification.getFeature() == PERMISSION_MES_UNCHECKED_SF || notification.getFeature() == PERMISSION_MES_ROLES_SF || notification.getFeature() == getMethodElementsReference() || notification.getFeature() == getMethodElementsContainerReference())
 			super.notifyChanged(notification);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodTransactionContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodTransactionContentProvider.java
index b606168..fe0e1b7 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodTransactionContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ejb/provider/MethodTransactionContentProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ejb.provider;
 
 
@@ -112,4 +114,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/listeners/ValidateEditListener.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/listeners/ValidateEditListener.java
index 6bbb9fc..3f29da8 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/listeners/ValidateEditListener.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/listeners/ValidateEditListener.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.listeners;
 
 import java.util.List;
@@ -264,4 +266,4 @@
 	public void setShell(Shell aShell) {
 		fShell = aShell;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/perspective/J2EEPerspective.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/perspective/J2EEPerspective.java
index 63616b3..f9fc213 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/perspective/J2EEPerspective.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/perspective/J2EEPerspective.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Dec 7, 2004
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/ErrorDialog.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/ErrorDialog.java
index 25b7101..60f11ee 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/ErrorDialog.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/ErrorDialog.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -189,4 +189,4 @@
 		}
 		return composite;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEEditorUtility.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEEditorUtility.java
index 35db620..b6a89c4 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEEditorUtility.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEEditorUtility.java
@@ -1,11 +1,15 @@
-package org.eclipse.jst.j2ee.internal.plugin;
+/*******************************************************************************
+ * Copyright (c) 2002, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
-/*
- * Licensed Material - Property of IBM 
- * (C) Copyright IBM Corp. 2002 - All Rights Reserved. 
- * US Government Users Restricted Rights - Use, duplication or disclosure 
- * restricted by GSA ADP Schedule Contract with IBM Corp. 
- */
+package org.eclipse.jst.j2ee.internal.plugin;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
@@ -31,12 +35,6 @@
 import org.eclipse.ui.part.FileEditorInput;
 import org.eclipse.wst.common.internal.emfworkbench.WorkbenchResourceHelper;
 
-/*
- * Licensed Materials - Property of IBM,
- * WebSphere Studio Workbench
- * (c) Copyright IBM Corp 1999, 2000
- */
-
 /**
  * A number of routines for working with JavaElements in editors
  * 
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIAdapterFactory.java
index 76e4aa3..372f44c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIAdapterFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Jun 30, 2004
  */
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIContextIds.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIContextIds.java
index 45d86d2..7d8053c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIContextIds.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIContextIds.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -23,16 +23,8 @@
  * Generation - Code and Comments
  */
 public interface J2EEUIContextIds {
-	//Migration Wizard
-	public static final String MIGRATION_WIZARD_GENERAL = J2EEUIPlugin.PLUGIN_ID + ".migr1000"; //$NON-NLS-1$
-	public static final String MIGRATION_WIZARD_EAR = J2EEUIPlugin.PLUGIN_ID + ".migr1000"; //$NON-NLS-1$
-	public static final String MIGRATION_WIZARD_EJB = J2EEUIPlugin.PLUGIN_ID + ".migr1100"; //$NON-NLS-1$
-	public static final String MIGRATION_WIZARD_CMP = J2EEUIPlugin.PLUGIN_ID + ".migr1500"; //$NON-NLS-1$
-	public static final String MIGRATION_WIZARD_WEB = J2EEUIPlugin.PLUGIN_ID + ".migr1200"; //$NON-NLS-1$
-	public static final String MIGRATION_WIZARD_APP_CLIENT = J2EEUIPlugin.PLUGIN_ID + ".migr1300"; //$NON-NLS-1$
-	public static final String MIGRATION_WIZARD_CONNECTOR = J2EEUIPlugin.PLUGIN_ID + ".migr1400"; //$NON-NLS-1$
 
 	//	Delete Enterprise Bean Dialog
 	public static final String DELETE_ENTERPRISE_BEAN_DIALOG = J2EEUIPlugin.PLUGIN_ID + ".delb1000"; //$NON-NLS-1$
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIMessages.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIMessages.java
index 50865cc..57a6d13 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIMessages.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIMessages.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.plugin;
 
 import java.util.MissingResourceException;
@@ -46,6 +48,7 @@
 	public static final String APP_CLIENT_PROJECT_WIZ_TITLE = "24"; //$NON-NLS-1$
 	public static final String APP_CLIENT_VERSION_LBL = "3"; //$NON-NLS-1$
 	public static final String APP_CLIENT_PROJECT_MAIN_PG_TITLE = "25"; //$NON-NLS-1$
+	public static final String APP_CLIENT_SETTINGS = "101"; //$NON-NLS-1$
 
 	public static final String APP_CLIENT_PROJECT_MAIN_PG_DESC = "26"; //$NON-NLS-1$
 	public static final String MODULES_DEPENDENCY_PAGE_TITLE = "27"; //$NON-NLS-1$
@@ -179,6 +182,7 @@
 	public static final String ADDVARIABLE="ADDVARIABLE";//$NON-NLS-1$
 	public static final String SUPPORTMULTIPLEMODULES="SUPPORTMULTIPLEMODULES";//$NON-NLS-1$
 	public static final String SOURCEFOLDER="SOURCEFOLDER";//$NON-NLS-1$
+	public static final String CONTENT_FOLDER = "102"; //$NON-NLS-1$
 
 	/**
 	 * Returns the string from the resource bundle, or 'key' if not found.
@@ -208,4 +212,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIPlugin.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIPlugin.java
index f03a6b4..b127ed0 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEUIPlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEViewerSorter.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEViewerSorter.java
index a1c84fa..27dcf80 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEViewerSorter.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/J2EEViewerSorter.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.plugin;
 
 
@@ -48,4 +50,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/UIProjectUtilities.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/UIProjectUtilities.java
index 0eb1312..cad6e8f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/UIProjectUtilities.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/plugin/UIProjectUtilities.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -210,4 +210,4 @@
 		return new IProject[0];
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryContentProvider.java
index 9ca88ff..f71fc30 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryContentProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -126,4 +128,4 @@
 		methodsProviderDelegate.inputChanged(aViewer, oldInput, newInput);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryLabelProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryLabelProvider.java
index 463686c..76d0c0f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryLabelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEAdapterFactoryLabelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -87,4 +87,4 @@
 		if (feature == ROLE_NAME_SF || feature == ROLES_SF)
 			fireLabelProviderChanged();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProvider.java
index 87355ca..dfe361c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -189,4 +191,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProviderAdapterFactory.java
index 483d130..0434b30 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEApplicationItemProviderAdapterFactory.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -29,4 +31,4 @@
 		return new J2EEApplicationItemProvider(this);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEModulemapItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEModulemapItemProviderAdapterFactory.java
index 4352701..4d620b0 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEModulemapItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEModulemapItemProviderAdapterFactory.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -27,4 +29,4 @@
 		return new J2EEUtilityJavaProjectsItemProvider(this, false);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJarItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJarItemProvider.java
index efc524f..ce41769 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJarItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJarItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -264,4 +264,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJavaProjectsItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJavaProjectsItemProvider.java
index 5c3af74..7a2fe62 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJavaProjectsItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/J2EEUtilityJavaProjectsItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 import org.eclipse.emf.common.notify.AdapterFactory;
@@ -49,4 +51,4 @@
 		return UTILITY_JAVA_PROJECTS;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/MethodsProviderDelegate.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/MethodsProviderDelegate.java
index aa0eac8..1200806 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/MethodsProviderDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/MethodsProviderDelegate.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -114,4 +116,4 @@
 		AbstractMethodsContentProvider prov = getContentProvider(inputElement);
 		return prov == null ? null : prov.getElements(inputElement);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/ModulesItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/ModulesItemProvider.java
index ecfe4ad..9e94066 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/ModulesItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/provider/ModulesItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -219,4 +221,4 @@
 		return MODULES;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/AnnotationIconDecorator.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/AnnotationIconDecorator.java
index a8e4e5c..5722db0 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/AnnotationIconDecorator.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/AnnotationIconDecorator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -116,4 +116,4 @@
 			return J2EEUIPlugin.getDefault().getImageDescriptor(imageFileName);
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/BinaryProjectUIHelper.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/BinaryProjectUIHelper.java
index b24d920..4205656 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/BinaryProjectUIHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/ui/util/BinaryProjectUIHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.ui.util;
 
 
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/J2EEWebAppItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/J2EEWebAppItemProvider.java
index 1df1520..1e9f725 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/J2EEWebAppItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/J2EEWebAppItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -106,14 +106,20 @@
 
 		public void dispose() {
 			// TODO fix up notification
-			// if (editModel != null) {
-			// editModel.removeListener(this);
-			// if (editModel.get13WebServicesClientResource() != null) {
-			// client = editModel.get13WebServicesClientResource().getWebServicesClient();
-			// if (client != null)
-			// client.eAdapters().remove(this);
-			// }
-			// }
+			
+			webServletGroup.dispose();
+			webServletMappingGroup.dispose();
+			webFiltersGroup.dispose();
+			webFilterMappingGroup.dispose();
+			webRefsGroup.dispose();
+			webSecurityGroup.dispose();
+			webListenerGroup.dispose();
+			
+			weakWebApp = null;
+			 if (client != null)
+				 client.eAdapters().remove(this);
+			 children.clear();
+			
 		}
 	}
 
@@ -142,6 +148,7 @@
 	protected WeakReference weakWebApp = null;
 
 	public Collection getChildren(Object object) {
+		children.clear();
 		if (object instanceof WebApp && children.isEmpty()) {
 			weakWebApp = new WeakReference(object);
 			initChildren();
@@ -217,4 +224,4 @@
 			clientMgr.dispose();
 		super.dispose();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFilterMappingGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFilterMappingGroupItemProvider.java
index 6a1fdf4..7a5695f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFilterMappingGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFilterMappingGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -77,4 +77,4 @@
 	public Object getParent(Object object) {
 		return weakWebApp.get();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFiltersGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFiltersGroupItemProvider.java
index a45f036..d3809b1 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFiltersGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebFiltersGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebGroupItemProvider.java
index 29b0050..4d3e247 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -74,4 +74,10 @@
 		Collections.sort(theChildren, new WebGroupComparator());
 		return theChildren;
     }
+
+	public void dispose() {
+		// TODO Auto-generated method stub
+		super.dispose();
+		weakWebApp = null;
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebListenerGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebListenerGroupItemProvider.java
index c814120..d58e81f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebListenerGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebListenerGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebReferencesGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebReferencesGroupItemProvider.java
index 4f0f817..a5fcbbc 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebReferencesGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebReferencesGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -116,4 +116,4 @@
 		return WebAppEditResourceHandler.getString("References_1"); //$NON-NLS-1$ 
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebSecurityGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebSecurityGroupItemProvider.java
index d37862a..9da0aad 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebSecurityGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebSecurityGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletGroupItemProvider.java
index e9fca20..e0c207d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletMappingGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletMappingGroupItemProvider.java
index bd5d812..536b0ac 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletMappingGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/war/ui/util/WebServletMappingGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AnnotationsStandaloneGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AnnotationsStandaloneGroup.java
index d57889d..a59acbe 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AnnotationsStandaloneGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AnnotationsStandaloneGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -193,4 +193,4 @@
 			((IDataModel)model).setProperty(IAnnotationsDataModel.USE_ANNOTATIONS, new Boolean(aBoolean));
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizard.java
index e6fe276..b18fff0 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizard.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 22, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizardPage.java
index 831c0a3..6f752d5 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentCreationWizardPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 22, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentExportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentExportWizard.java
index b09b9f1..9fe83e2 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentExportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentExportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -73,4 +73,4 @@
 	protected void doInit() {
 		setDefaultPageImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.APP_CLIENT_EXPORT_WIZARD_BANNER));
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportPage.java
index d3cf726..8199026 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -74,4 +74,4 @@
 		return super.createTopLevelComposite(parent);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportWizard.java
index 3899c63..c766e79 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientComponentImportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -96,4 +96,4 @@
 	protected IDataModelProvider getDefaultProvider() {
 		return new AppClientComponentImportDataModelProvider();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientExportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientExportPage.java
index a36d767..ac8e380 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientExportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AppClientExportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -85,4 +85,4 @@
         return "JST_APPCLIENT"; //$NON-NLS-1$
     }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJ2EEComponentsContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJ2EEComponentsContentProvider.java
index 2db45df..a51b970 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJ2EEComponentsContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJ2EEComponentsContentProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 18, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJarsProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJarsProvider.java
index 0327326..23bf01e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJarsProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableJarsProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.wizard;
 
 
@@ -232,4 +234,4 @@
 	public void removeListener(org.eclipse.jface.viewers.ILabelProviderListener listener) {
 		//do nothing
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableModuleProjectsProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableModuleProjectsProvider.java
index f81de4f..e8749e2 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableModuleProjectsProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableModuleProjectsProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -148,4 +148,4 @@
 	public void removeListener(ILabelProviderListener listener) {
 		//do nothing
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilJarsAndWebLibProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilJarsAndWebLibProvider.java
index 885ea00..2871401 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilJarsAndWebLibProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilJarsAndWebLibProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -178,4 +178,4 @@
 		//Auto-generated method stub
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilityJarsProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilityJarsProvider.java
index 0f182d8..4629cc7 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilityJarsProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/AvailableUtilityJarsProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -159,4 +159,4 @@
 		//do nothing
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ClassesImportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ClassesImportWizard.java
index 5f37175..ac07f23 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ClassesImportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ClassesImportWizard.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.wizard;
 
 import java.util.ArrayList;
@@ -172,4 +174,4 @@
 
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DataModelAnnotationsStandaloneGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DataModelAnnotationsStandaloneGroup.java
index 6de8b22..7ec0ba6 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DataModelAnnotationsStandaloneGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DataModelAnnotationsStandaloneGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DefaultJ2EEComponentCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DefaultJ2EEComponentCreationWizard.java
index 748b941..b79213f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DefaultJ2EEComponentCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/DefaultJ2EEComponentCreationWizard.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 23, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationSecondPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationSecondPage.java
index 27f75f8..8c2f68f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationSecondPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationSecondPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 18, 2005
  *
@@ -235,7 +245,10 @@
             String projectName = compDM.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
             if(projectName == null) return;
             IProject project = ProjectUtilities.getProject(projectName);
-            String compName = compDM.getStringProperty(IComponentCreationDataModelProperties.COMPONENT_NAME);
+            /**
+			 * Warning cleanup 12/07/2005
+			 */
+			//String compName = compDM.getStringProperty(IComponentCreationDataModelProperties.COMPONENT_NAME);
             if (project != null && project.exists())
                 newProjects.add(project);
         }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizard.java
index 5aa28f1..0dbeb11 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizard.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizardPage.java
index b88dd1e..c8f9bf6 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentCreationWizardPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 17, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportPage.java
index 759b741..84c2085 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -90,4 +90,4 @@
     protected String getCompnentID() {
         return "JST_EAR";  //$NON-NLS-1$
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportWizard.java
index e241f8c..a9b2611 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentExportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -75,4 +75,4 @@
 		setDefaultPageImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.EAR_EXPORT_WIZARD_BANNER));
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportOptionsPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportOptionsPage.java
index 375aeeb..93c0e7c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportOptionsPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportOptionsPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -318,4 +318,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportPage.java
index b913d6f..b2a5e77 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -128,4 +128,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportWizard.java
index c8cfdc7..e67fede 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentImportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -101,4 +101,4 @@
 		return new EARComponentImportDataModelProvider();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentProjectsPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentProjectsPage.java
index 316e9bf..874fec6 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentProjectsPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARComponentProjectsPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -290,4 +290,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARImportListContentProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARImportListContentProvider.java
index a3d9ac8..fac4333 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARImportListContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARImportListContentProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -97,4 +97,4 @@
 	public void dispose() {
 		// dispose
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARValidationHelper.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARValidationHelper.java
index aa43dbb..7b3772c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARValidationHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/EARValidationHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.wizard;
 
 
@@ -87,4 +89,4 @@
 		return new RunnableWithProgressWrapper(op);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizard.java
index 6d96b7e..924193d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizard.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 14, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizardPage.java
index 7330740..2ae501e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/FlexibleProjectCreationWizardPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 14, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ImportUtil.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ImportUtil.java
index f7b7aa6..afa712e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ImportUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ImportUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -12,7 +12,6 @@
 
 import java.io.File;
 
-import org.eclipse.core.internal.localstore.CoreFileSystemLibrary;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.jst.j2ee.application.Application;
@@ -27,6 +26,7 @@
 import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.j2ee.webapplication.WebApp;
+import org.eclipse.wst.common.frameworks.internal.WTPPlugin;
 
 
 
@@ -198,7 +198,7 @@
 			}
 			for (int i = 0; i < projects.length; i++) {
 				if (projects[i].exists()) {
-					if (CoreFileSystemLibrary.isCaseSensitive()) {
+					if (WTPPlugin.isPlatformCaseSensitive()) {
 						if (projects[i].getName().equals(projectName))
 							return projects[i].getName();
 					} else {
@@ -213,4 +213,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactCreationWizard.java
index d31e313..c07cfd3 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactCreationWizard.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.wizard;
 
 import java.lang.reflect.InvocationTargetException;
@@ -16,7 +18,6 @@
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jface.dialogs.IDialogSettings;
 import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jst.j2ee.internal.DelegateConfigurationElement;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
 import org.eclipse.ui.INewWizard;
 import org.eclipse.ui.IPluginContribution;
@@ -26,6 +27,7 @@
 import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizard;
+import org.eclipse.wst.web.internal.DelegateConfigurationElement;
 
 /**
  * <p>
@@ -280,4 +282,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactExportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactExportWizard.java
index d6297da..1a9bb8c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactExportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactExportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -168,4 +168,4 @@
 		return (J2EEExportPage) getPage(MAIN_PG);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactImportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactImportWizard.java
index 6c54a07..08bc374 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactImportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEArtifactImportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,13 +16,13 @@
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IExecutableExtension;
 import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jst.j2ee.internal.DelegateConfigurationElement;
 import org.eclipse.jst.j2ee.internal.plugin.CommonEditorUtility;
 import org.eclipse.ui.IImportWizard;
 import org.eclipse.ui.IWorkbench;
 import org.eclipse.ui.wizards.newresource.BasicNewProjectResourceWizard;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizard;
+import org.eclipse.wst.web.internal.DelegateConfigurationElement;
 
 /**
  * <p>
@@ -221,4 +221,4 @@
 		return selection;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizard.java
index 87f4af4..27a56e8 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -12,7 +12,6 @@
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.wizard.IWizardPage;
 import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit;
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
@@ -20,6 +19,7 @@
 import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.internal.datamodel.ui.IDMPageHandler;
 
 /**
  * <p>
@@ -89,10 +89,10 @@
 	 * 
 	 */
 	protected void addModulesPageIfNecessary() {
-        //TODO: add modules page back for 0.7
-//		if (getDataModel().getBooleanProperty(UI_SHOW_EAR_SECTION)) {
-//			addPage(new J2EEModulesDependencyPage(getDataModel(), MODULE_PG));
-//		}
+		// TODO: add modules page back for 0.7
+		// if (getDataModel().getBooleanProperty(UI_SHOW_EAR_SECTION)) {
+		// addPage(new J2EEModulesDependencyPage(getDataModel(), MODULE_PG));
+		// }
 	}
 
 	/**
@@ -109,20 +109,14 @@
 	 * Skips the page identified by the MODULE_PG name if
 	 * {@link J2EEComponentCreationWizard#shouldShowModulesPage()}is false.
 	 * </p>
-	 * 
-	 * @see org.eclipse.jface.wizard.IWizard#getPreviousPage(org.eclipse.jface.wizard.IWizardPage)
 	 */
-	public IWizardPage getPreviousPage(IWizardPage page) {
-		IWizardPage previous = super.getPreviousPage(page);
-		if (previous != null && previous.getName().equals(MODULE_PG)) {
-			if (!shouldShowModulesPage()) {
-				previous = super.getPreviousPage(previous);
-			}
+	public String getPreviousPage(String currentPageName, String expectedPreviousPageName) {
+		if (!shouldShowModulesPage() && expectedPreviousPageName.equals(MODULE_PG)) {
+			return IDMPageHandler.PAGE_BEFORE;
 		}
-		return previous;
+		return super.getPreviousPage(currentPageName, expectedPreviousPageName);
 	}
 
-
 	/**
 	 * {@inheritDoc}
 	 * 
@@ -130,17 +124,12 @@
 	 * Skips the page identified by the MODULE_PG name if
 	 * {@link J2EEModuleProjectCreationWizard#shouldShowModulesPage()}is false.
 	 * </p>
-	 * 
-	 * @see org.eclipse.jface.wizard.IWizard#getNextPage(org.eclipse.jface.wizard.IWizardPage)
 	 */
-	public IWizardPage getNextPage(IWizardPage page) {
-		IWizardPage next = super.getNextPage(page);
-		if (next != null && next.getName().equals(MODULE_PG)) {
-			if (!shouldShowModulesPage()) {
-				next = super.getNextPage(next);
-			}
+	public String getNextPage(String currentPageName, String expectedNextPageName) {
+		if (!shouldShowModulesPage() && (null != expectedNextPageName && expectedNextPageName.equals(MODULE_PG))) {
+			return IDMPageHandler.PAGE_AFTER;
 		}
-		return next;
+		return super.getNextPage(currentPageName, expectedNextPageName);
 	}
 
 	/**
@@ -204,4 +193,4 @@
 			dm.setProperty(EAR_COMPONENT_NAME, earComponent.getName());
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizardPage.java
index 8660683..dc936c2 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentCreationWizardPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -302,7 +302,7 @@
         newServerTargetButton.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 if(!J2EEComponentCreationWizardPage.launchNewRuntimeWizard(getShell(), model)){
-                	setErrorMessage(J2EECreationResourceHandler.getString("ServerTargetDataModel_UI_9")); //$NON-NLS-1$
+                	setErrorMessage(J2EECreationResourceHandler.ServerTargetDataModel_UI_9);
                 }
             }
         });
@@ -315,7 +315,10 @@
     protected void createServerEarAndStandaloneGroup(Composite parent) {
         earGroup = new ServerEarAndStandaloneGroup(parent, getDataModel(), synchHelper);
     }
-    
+    /**@deprecated 
+	 * If this method is not used it should be removed at a later time, marking as deprecated
+	 * Warning cleanup 12/07/2005
+	 */
 	private void createProjectsComboGroup(Composite parent) {
 		// set up project name label
 		
@@ -553,4 +556,4 @@
         return isOK;
     }   
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentFacetCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentFacetCreationWizardPage.java
new file mode 100644
index 0000000..661956d
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentFacetCreationWizardPage.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+/*
+ * Created on Nov 10, 2003
+ *
+ * To change the template for this generated file go to
+ * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
+ */
+package org.eclipse.jst.j2ee.internal.wizard;
+
+import org.eclipse.jst.j2ee.ui.project.facet.EarSelectionPanel;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.web.ui.internal.wizards.DataModelFacetCreationWizardPage;
+
+public abstract class J2EEComponentFacetCreationWizardPage extends DataModelFacetCreationWizardPage implements IFacetProjectCreationDataModelProperties {
+
+	protected EarSelectionPanel earPanel;
+
+	public J2EEComponentFacetCreationWizardPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+	}
+
+	protected Composite createTopLevelComposite(Composite parent) {
+		Composite top = new Composite(parent, SWT.NONE);
+		PlatformUI.getWorkbench().getHelpSystem().setHelp(top, getInfopopID());
+		top.setLayout(new GridLayout());
+		top.setLayoutData(new GridData(GridData.FILL_BOTH));
+		createProjectGroup(top);
+		Composite composite = new Composite(top, SWT.NONE);
+		composite.setLayoutData(gdhfill());
+		GridLayout layout = new GridLayout(3, false);
+		composite.setLayout(layout);
+		createServerTargetComposite(composite);
+		createEarComposite(composite);
+		return top;
+	}
+
+	private void createEarComposite(Composite composite) {
+		FacetDataModelMap map = (FacetDataModelMap) model.getProperty(FACET_DM_MAP);
+		IDataModel facetModel = (IDataModel) map.get(getModuleFacetID());
+		earPanel = new EarSelectionPanel(facetModel, composite);
+	}
+
+	protected abstract String getModuleFacetID();
+
+	public void dispose() {
+		super.dispose();
+		if (earPanel != null)
+			earPanel.dispose();
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentImportWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentImportWizard.java
index 822084a..dab3960 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentImportWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentImportWizard.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -152,4 +152,4 @@
 	// return VALIDATOR_STRINGS;
 	// }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentLabelProvider.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentLabelProvider.java
index 252a5f9..cff0050 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentLabelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEComponentLabelProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEExportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEExportPage.java
index bfbce81..11928ab 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEExportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEExportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -381,4 +381,4 @@
 		return J2EEUIPlugin.getDefault().getDialogSettings();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEImportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEImportPage.java
index ae6abe3..5941ce2 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEImportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEImportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -275,4 +275,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleExportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleExportPage.java
index 34f7bbd..ea4b4bd 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleExportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleExportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -46,4 +46,4 @@
 		return new String[]{IJ2EEComponentExportDataModelProperties.COMPONENT_NAME, IJ2EEComponentExportDataModelProperties.ARCHIVE_DESTINATION, IJ2EEComponentExportDataModelProperties.OVERWRITE_EXISTING};
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleFacetInstallPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleFacetInstallPage.java
new file mode 100644
index 0000000..d105659
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleFacetInstallPage.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal.wizard;
+
+
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.ui.project.facet.EarSelectionPanel;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.wst.web.ui.internal.wizards.DataModelFacetInstallPage;
+
+public abstract class J2EEModuleFacetInstallPage extends DataModelFacetInstallPage implements IJ2EEModuleFacetInstallDataModelProperties {
+
+	public J2EEModuleFacetInstallPage(String pageName) {
+		super(pageName);
+	}
+
+	protected EarSelectionPanel earPanel;
+
+	public void dispose() {
+		if (null != earPanel) {
+			earPanel.dispose();
+		}
+		super.dispose();
+	}
+
+	protected void setupEarControl(final Composite parent) {
+		Composite c = new Composite(parent, SWT.NONE);
+		c.setLayoutData(gdhfill());
+		final GridLayout layout = new GridLayout(3, false);
+		layout.marginWidth = 0;
+		layout.marginHeight = 0;
+		c.setLayout(layout);
+		this.earPanel = new EarSelectionPanel(model, c);
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleImportPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleImportPage.java
index ce7a1a5..497b35e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleImportPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModuleImportPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -63,4 +63,4 @@
 		return new String[]{IJ2EEComponentImportDataModelProperties.FILE_NAME, IJ2EEComponentImportDataModelProperties.PROJECT_NAME, IJ2EEProjectServerTargetDataModelProperties.RUNTIME_TARGET_ID, IJ2EEModuleImportDataModelProperties.EAR_COMPONENT_NAME, IJ2EEModuleImportDataModelProperties.ADD_TO_EAR};
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModulesDependencyPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModulesDependencyPage.java
index 582e971..a66992d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModulesDependencyPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEModulesDependencyPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -231,4 +231,4 @@
 		});
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportPageNew.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportPageNew.java
index 5414bbb..ba3c0bb 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportPageNew.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportPageNew.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -395,4 +395,4 @@
 		return J2EEUIMessages.getResourceString("J2EEUtilityJarImportPage_UI_7"); //$NON-NLS-1$
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportTypePageNew.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportTypePageNew.java
index 4d127bf..831a04d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportTypePageNew.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportTypePageNew.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -414,4 +414,4 @@
 		return model.validateProperty(IJ2EEUtilityJarListImportDataModelProperties.EAR_PROJECT).isOK();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportWizardNew.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportWizardNew.java
index 310487d..67a123d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportWizardNew.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/J2EEUtilityJarImportWizardNew.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -85,4 +85,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/JavaUtilityComponentCreationWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/JavaUtilityComponentCreationWizard.java
deleted file mode 100644
index a1d2144..0000000
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/JavaUtilityComponentCreationWizard.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
-
-package org.eclipse.jst.j2ee.internal.wizard;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExecutableExtension;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jst.j2ee.internal.archive.operations.JavaComponentCreationDataModelProvider;
-import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
-import org.eclipse.ui.INewWizard;
-import org.eclipse.ui.IWorkbench;
-import org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider;
-import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizard;
-
-/**
- *
- * TODO To change the template for this generated type comment go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
-public class JavaUtilityComponentCreationWizard extends DataModelWizard implements INewWizard, IExecutableExtension{
-
-//	private IConfigurationElement configurationElement;
-	
-	public JavaUtilityComponentCreationWizard() {
-		super();
-		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.JAVAUTIL_COMPONENT_WIZ_TITLE));
-		//setDefaultPageImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.APP_CLIENT_PROJECT_WIZARD_BANNER));
-	}
-
-	public void doAddPages() {
-		addPage(new JavaUtilityComponentCreationWizardPage(getDataModel(), JavaUtilityComponentCreationWizardPage.PAGE_NAME));
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.frameworks.datamodel.ui.DataModelWizard#getDefaultProvider()
-	 */
-	protected IDataModelProvider getDefaultProvider() {
-		return new JavaComponentCreationDataModelProvider();
-	}
-	
-	public final void setInitializationData(IConfigurationElement aConfigurationElement, String aPropertyName, Object theData) throws CoreException {
-//		configurationElement = aConfigurationElement;
-//		doSetInitializeData(aConfigurationElement, aPropertyName, theData);
-
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchWizard#init(org.eclipse.ui.IWorkbench, org.eclipse.jface.viewers.IStructuredSelection)
-	 */
-	public void init(IWorkbench workbench, IStructuredSelection selection) {
-		// TODO Auto-generated method stub
-		
-	}
-	public boolean canFinish() {
-		return super.canFinish();
-	}
-}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/JavaUtilityComponentCreationWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/JavaUtilityComponentCreationWizardPage.java
deleted file mode 100644
index e0720d3..0000000
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/JavaUtilityComponentCreationWizardPage.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.j2ee.internal.wizard;
-
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jst.j2ee.internal.actions.IJ2EEUIContextIds;
-import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
-import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
-import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizardPage;
-import org.eclipse.wst.web.internal.WSTWebPlugin;
-
-
-
-/**
- *
- * TODO To change the template for this generated type comment go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
-public class JavaUtilityComponentCreationWizardPage extends DataModelWizardPage {
-	public static final String PAGE_NAME = "JavaUtilityComponentCreationWizardPage"; //$NON-NLS-1$
-	protected NewModuleGroupEx projectNameGroup;	
-	
-	/**
-	 * @param model
-	 * @param pageName
-	 */
-	protected JavaUtilityComponentCreationWizardPage(IDataModel model, String pageName) {
-		super(model, pageName);
-		
-		setTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.JAVAUTILITY_MAIN_PG_TITLE));
-		setDescription(J2EEUIMessages.getResourceString(J2EEUIMessages.JAVAUTILITY_MAIN_PG_DESC));
-		ImageDescriptor desc = AbstractUIPlugin.imageDescriptorFromPlugin(WSTWebPlugin.PLUGIN_ID, "icons/full/wizban/newwprj_wiz.gif"); //$NON-NLS-1$
-		setImageDescriptor(desc);
-		setInfopopID(IJ2EEUIContextIds.NEW_JAVA_COMPONENT_WIZARD_P1);
-		setPageComplete(true);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.frameworks.datamodel.ui.DataModelWizardPage#getValidationPropertyNames()
-	 */
-	protected String[] getValidationPropertyNames() {
-		return new String[]{IComponentCreationDataModelProperties.COMPONENT_NAME};
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.frameworks.datamodel.ui.DataModelWizardPage#createTopLevelComposite(org.eclipse.swt.widgets.Composite)
-	 */
-	protected Composite createTopLevelComposite(Composite parent) {
-		Composite top = new Composite(parent, SWT.NONE);
-		top.setLayout(new GridLayout());
-		top.setData(new GridData(GridData.FILL_BOTH));
-		Composite composite = new Composite(top, SWT.NONE);
-		GridLayout layout = new GridLayout(3, false);
-		composite.setLayout(layout);
-		
-		createProjectNameGroup(composite);
-		Composite detail = new Composite(top, SWT.NONE);
-		detail.setLayout(new GridLayout());
-		detail.setData(new GridData(GridData.FILL_BOTH));
-
-
-		return top;
-	}
-	
-	protected void createProjectNameGroup(Composite parent) {
-		projectNameGroup = new NewModuleGroupEx(parent, SWT.NULL, model);
-	}
-
-}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewFlexibleProjectGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewFlexibleProjectGroup.java
index b24956f..23bbd1f 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewFlexibleProjectGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewFlexibleProjectGroup.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 14, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJ2EEComponentSelectionPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJ2EEComponentSelectionPage.java
index f92fe03..1d8da97 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJ2EEComponentSelectionPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJ2EEComponentSelectionPage.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 23, 2005
  *
@@ -10,14 +20,16 @@
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jface.wizard.IWizard;
 import org.eclipse.jface.wizard.IWizardPage;
-import org.eclipse.jst.j2ee.applicationclient.internal.creation.AppClientComponentCreationDataModelProvider;
-import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
+import org.eclipse.jst.j2ee.applicationclient.internal.creation.AppClientFacetProjectCreationDataModelProvider;
 import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
 import org.eclipse.jst.j2ee.internal.actions.IJ2EEUIContextIds;
 import org.eclipse.jst.j2ee.internal.earcreation.IDefaultJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.moduleextension.EarModuleManager;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.project.facet.J2EEModuleFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientProjectWizard;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StackLayout;
 import org.eclipse.swt.layout.GridData;
@@ -32,10 +44,13 @@
 import org.eclipse.ui.internal.WorkbenchPlugin;
 import org.eclipse.ui.wizards.IWizardDescriptor;
 import org.eclipse.ui.wizards.IWizardRegistry;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizardPage;
 import org.eclipse.wst.common.frameworks.internal.ui.GenericWizardNode;
+import org.eclipse.wst.web.ui.internal.wizards.NewProjectDataModelFacetWizard;
 
 public class NewJ2EEComponentSelectionPage extends DataModelWizardPage implements IDefaultJ2EEComponentCreationDataModelProperties {
     private Button defaultModulesButton;
@@ -340,9 +355,10 @@
                  * @see org.eclipse.wst.common.frameworks.internal.ui.wizard.GenericWizardNode#createWizard()
                  */
                 protected IWizard createWizard() {
-                    IDataModel dm = DataModelFactory.createDataModel(new AppClientComponentCreationDataModelProvider());
-                    dm.setBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, false);
-                    return new AppClientComponentCreationWizard(dm);
+                    IDataModel dm = DataModelFactory.createDataModel(new AppClientFacetProjectCreationDataModelProvider());
+                    FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+                    map.getFacetDataModel(J2EEProjectUtilities.APPLICATION_CLIENT).setBooleanProperty(J2EEModuleFacetInstallDataModelProvider.PROHIBIT_ADD_TO_EAR, true);
+                    return new AppClientProjectWizard(dm);
                 }
             };
         }
@@ -361,15 +377,15 @@
                  * @see org.eclipse.wst.common.frameworks.internal.ui.wizard.GenericWizardNode#createWizard()
                  */
                 protected IWizard createWizard() {
-                    J2EEComponentCreationWizard result = null;
+                    NewProjectDataModelFacetWizard result = null;
 
                     IWizardRegistry newWizardRegistry = WorkbenchPlugin.getDefault().getNewWizardRegistry();
-                    IWizardDescriptor descriptor = newWizardRegistry.findWizard("org.eclipse.jst.j2ee.jca.ui.ConnectorComponentCreationWizard"); //$NON-NLS-1$
+                    IWizardDescriptor descriptor = newWizardRegistry.findWizard("org.eclipse.jst.j2ee.jca.ui.internal.wizard.ConnectorProjectWizard"); //$NON-NLS-1$
                     try {
-                        result = (J2EEComponentCreationWizard)descriptor.createWizard();
+                        result = (NewProjectDataModelFacetWizard)descriptor.createWizard();
                         IDataModel dm = result.getDataModel();
-                        dm.setBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, false);
-                        result.setDataModel(dm);
+                        FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+                        map.getFacetDataModel(J2EEProjectUtilities.JCA).setBooleanProperty(J2EEModuleFacetInstallDataModelProvider.PROHIBIT_ADD_TO_EAR, true);
                     } catch (CoreException ce) {
                         Logger.getLogger().log(ce);
                     }
@@ -392,15 +408,15 @@
                  * @see org.eclipse.wst.common.frameworks.internal.ui.wizard.GenericWizardNode#createWizard()
                  */
                 protected IWizard createWizard() {
-                    J2EEComponentCreationWizard result = null;
+                	NewProjectDataModelFacetWizard result = null;
 
                     IWizardRegistry newWizardRegistry = WorkbenchPlugin.getDefault().getNewWizardRegistry();
-                    IWizardDescriptor descriptor = newWizardRegistry.findWizard("org.eclipse.jst.ejb.ui.EJBComponentCreationWizard"); //$NON-NLS-1$
+                    IWizardDescriptor descriptor = newWizardRegistry.findWizard("org.eclipse.jst.ejb.ui.project.facet.EjbProjectWizard"); //$NON-NLS-1$
                     try {
-                        result = (J2EEComponentCreationWizard)descriptor.createWizard();
+                        result = (NewProjectDataModelFacetWizard)descriptor.createWizard();
                         IDataModel dm = result.getDataModel();
-                        dm.setBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, false);
-                        result.setDataModel(dm);
+                        FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+                        map.getFacetDataModel(J2EEProjectUtilities.EJB).setBooleanProperty(J2EEModuleFacetInstallDataModelProvider.PROHIBIT_ADD_TO_EAR, true);
                     } catch (CoreException ce) {
                         Logger.getLogger().log(ce);
                     }
@@ -423,11 +439,15 @@
                  * @see org.eclipse.wst.common.frameworks.internal.ui.wizard.GenericWizardNode#createWizard()
                  */
                 protected IWizard createWizard() {
-                    IWizard result = null;
+                	NewProjectDataModelFacetWizard result = null;
                     IWizardRegistry newWizardRegistry = WorkbenchPlugin.getDefault().getNewWizardRegistry();
-                    IWizardDescriptor servletWizardDescriptor = newWizardRegistry.findWizard("org.eclipse.jst.servlet.ui.WebComponentCreationWizard"); //$NON-NLS-1$
+                    IWizardDescriptor servletWizardDescriptor = newWizardRegistry.findWizard("org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard"); //$NON-NLS-1$
                     try {
-                        result = servletWizardDescriptor.createWizard();
+                        result = (NewProjectDataModelFacetWizard)servletWizardDescriptor.createWizard();
+                        IDataModel dm = result.getDataModel();
+                        FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+                        map.getFacetDataModel(J2EEProjectUtilities.DYNAMIC_WEB).setBooleanProperty(J2EEModuleFacetInstallDataModelProvider.PROHIBIT_ADD_TO_EAR, true);
+                        
                     } catch (CoreException ce) {
                         Logger.getLogger().log(ce);
                     }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassOptionsWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassOptionsWizardPage.java
index dad24a3..8de017d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassOptionsWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassOptionsWizardPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -365,4 +365,4 @@
 			model.setProperty(INewJavaClassDataModelProperties.INTERFACES, valueList);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassWizardPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassWizardPage.java
index 837aa21..867b1cc 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassWizardPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewJavaClassWizardPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -229,8 +229,17 @@
 			names[i] = (String) items.get(i);
 		}
 		projectNameCombo.setItems(names);
+		IProject selectedProject = null;
 		try {
-			IProject selectedProject = getSelectedProject();
+			if (model !=null) {
+				String projectNameFromModel = model.getStringProperty(IArtifactEditOperationDataModelProperties.COMPONENT_NAME);
+				if (projectNameFromModel!=null && projectNameFromModel.length()>0)
+					selectedProject = ProjectUtilities.getProject(projectNameFromModel);
+			}
+		} catch (Exception e) {};
+		try {
+			if (selectedProject == null)
+				selectedProject = getSelectedProject();
 			if (selectedProject != null && selectedProject.isAccessible()
 					&& selectedProject.hasNature(IModuleConstants.MODULE_NATURE_ID)) {
 				projectNameCombo.setText(selectedProject.getName());
@@ -611,4 +620,4 @@
 		this.projectName = projectName;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleDataModelGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleDataModelGroup.java
index 4719ad8..df93ccf 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleDataModelGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleDataModelGroup.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.wizard;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroup.java
index a81b9e9..19d2b27 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -253,4 +253,4 @@
 			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroupEx.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroupEx.java
index 808df7a..afa2209 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroupEx.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewModuleGroupEx.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -271,4 +271,4 @@
 			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewProjectGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewProjectGroup.java
index 82e52cb..40f980d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewProjectGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/NewProjectGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -139,4 +139,4 @@
 	public void dispose() {
         projectModel = null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerEarAndStandaloneGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerEarAndStandaloneGroup.java
index 37bc7a5..496345a 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerEarAndStandaloneGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerEarAndStandaloneGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -129,4 +129,4 @@
 		synchHelper = null;
 		model = null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetComboHelper.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetComboHelper.java
index 7cc3187..d0e6af5 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetComboHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetComboHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Aug 27, 2003
  * 
@@ -71,4 +73,4 @@
 	public List getValidTargets() {
 		return targets;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetGroup.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetGroup.java
index bf7bbe1..d655c3d 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -138,4 +138,4 @@
 	public void setNewTargetServerButton(Button newTargetServerButton) {
 		this.newTargetServerButton = newTargetServerButton;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetUIHelper.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetUIHelper.java
index 02c387f..31f6d67 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetUIHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/ServerTargetUIHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -20,7 +20,6 @@
 import java.util.Arrays;
 
 import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jface.dialogs.IDialogConstants;
@@ -120,11 +119,11 @@
 	//	}
 
 	public static void setServerTarget(Shell shell, IProject project, IRuntime runtime, IProgressMonitor monitor) {
-		try {
-			ServerCore.getProjectProperties(project).setRuntimeTarget(runtime, monitor);
-		} catch (CoreException e) {
-			Logger.getLogger().logError(e);
-		}
+//		try {
+//			ServerCore.getProjectProperties(project).setRuntimeTarget(runtime, monitor);
+//		} catch (CoreException e) {
+//			Logger.getLogger().logError(e);
+//		}
 	}
 
 
@@ -155,4 +154,4 @@
 			Logger.getLogger().logError(ite);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/StringArrayTableWizardSection.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/StringArrayTableWizardSection.java
index a429725..fdea5bb 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/StringArrayTableWizardSection.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/StringArrayTableWizardSection.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -258,4 +258,4 @@
 	public Button getRemoveButton() {
 		return removeButton;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportMainPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportMainPage.java
index 4b81b6c..235f013 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportMainPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportMainPage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportPage1.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportPage1.java
index 099bb17..c423470 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportPage1.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/wizard/WizardClassesImportPage1.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -1439,4 +1439,4 @@
 		return dialog.open();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.java
index cf9d12f..9f298cc 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.java
@@ -11,122 +11,340 @@
 
 package org.eclipse.jst.j2ee.ui.project.facet;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.viewers.CheckStateChangedEvent;
+import org.eclipse.jface.viewers.CheckboxTableViewer;
+import org.eclipse.jface.viewers.ICheckStateListener;
+import org.eclipse.jface.viewers.TableLayout;
+import org.eclipse.jface.wizard.WizardDialog;
+import org.eclipse.jst.j2ee.internal.actions.IJ2EEUIContextIds;
+import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
+import org.eclipse.jst.j2ee.internal.earcreation.DefaultJ2EEComponentCreationDataModelProvider;
+import org.eclipse.jst.j2ee.internal.earcreation.IDefaultJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.earcreation.IEarFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPluginIcons;
+import org.eclipse.jst.j2ee.internal.wizard.AvailableJ2EEComponentsContentProvider;
+import org.eclipse.jst.j2ee.internal.wizard.DefaultJ2EEComponentCreationWizard;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEComponentLabelProvider;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.ModifyEvent;
-import org.eclipse.swt.events.ModifyListener;
-import org.eclipse.swt.graphics.Color;
 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.Display;
+import org.eclipse.swt.widgets.Event;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Text;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
-import org.eclipse.wst.common.project.facet.ui.AbstractFacetWizardPage;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
+import org.eclipse.wst.web.ui.internal.wizards.DataModelFacetInstallPage;
 
 /**
  * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
  */
 
-public final class EarFacetInstallPage 
+public final class EarFacetInstallPage extends DataModelFacetInstallPage implements IEarFacetInstallDataModelProperties {
+	
+	private Button selectAllButton;
+	private Button deselectAllButton;
+	private Button newModuleButton;
+	private CheckboxTableViewer moduleProjectsViewer;
+	private boolean ignoreCheckedState = false;
+	
+	
+	private Label contentDirLabel;
+	private Text contentDir;
 
-    extends AbstractFacetWizardPage
-    
-{
-    private IDataModel config;
-    private Label contentDirLabel;
-    private Text contentDir;
-    
-    public EarFacetInstallPage() 
-    {
-        super( "ear.facet.install.page" );
-        
-        setTitle( Resources.pageTitle );
-        setDescription( Resources.pageDescription );
-    }
-    
-    public void createControl( final Composite parent ) 
-    {
-        final Composite composite = new Composite( parent, SWT.NONE );
-        composite.setLayout( new GridLayout( 1, false ) );
-        
-        this.contentDirLabel = new Label( composite, SWT.NONE );
-        this.contentDirLabel.setText( Resources.contentDirLabel );
-        this.contentDirLabel.setLayoutData( gdhfill() );
-        
-        this.contentDir = new Text( composite, SWT.BORDER );
-        this.contentDir.setText( this.config.getStringProperty( IEarFacetInstallDataModelProperties.CONTENT_DIR ) );
-        this.contentDir.setLayoutData( gdhfill() );
-        
-        final ModifyListener modifyListener = new ModifyListener()
-        {
-            public void modifyText( final ModifyEvent event ) 
-            {
-                config.setStringProperty( IEarFacetInstallDataModelProperties.CONTENT_DIR, contentDir.getText() );
-                validate();
-            }
-        };
-        
-        this.contentDir.addModifyListener( modifyListener );
-        
-        setControl( composite );
-    }
-    
-    public void setConfig( final Object config ) 
-    {
-        this.config = (IDataModel) config;
-    }
+	public EarFacetInstallPage() {
+		super("ear.facet.install.page"); //$NON-NLS-1$
+		setTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.EAR_COMPONENT_SECOND_PG_TITLE));
+		setDescription(J2EEUIMessages.getResourceString(J2EEUIMessages.EAR_COMPONENT_SECOND_PG_DESC));
+		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.EAR_WIZ_BANNER));
+	}
 
-    private void validate()
-    {
-        boolean valid = true;
+	protected String[] getValidationPropertyNames() {
+		return new String[]{CONTENT_DIR, J2EE_PROJECTS_LIST};
+	}
 
-        final Display display = this.contentDirLabel.getDisplay();
-        
-        final String contentDirLabelText;
-        final Color contentDirLabelColor;
-        
-        if( this.contentDir.getText().trim().length() == 0 )
-        {
-            contentDirLabelText = Resources.contentDirLabelInvalid;
-            contentDirLabelColor = display.getSystemColor( SWT.COLOR_RED );
-            
-            valid = false;
-        }
-        else
-        {
-            contentDirLabelText = Resources.contentDirLabel;
-            contentDirLabelColor = null;
-        }
-        
-        this.contentDirLabel.setText( contentDirLabelText );
-        this.contentDirLabel.setForeground( contentDirLabelColor );
-        
-        this.setPageComplete( valid );
+	protected Composite createTopLevelComposite(Composite parent) {
+		Composite modulesGroup = new Composite(parent, SWT.NONE);
+		GridLayout layout = new GridLayout();
+		modulesGroup.setLayout(layout);
+		setInfopopID(IJ2EEUIContextIds.NEW_EAR_ADD_MODULES_PAGE);
+		GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
+		modulesGroup.setLayoutData(gridData);
+		createModuleProjectOptions(modulesGroup);
+		createButtonsGroup(modulesGroup);
+		
+		final Composite composite = new Composite(modulesGroup, SWT.NONE);
+		composite.setLayout(new GridLayout(1, false));
+
+		this.contentDirLabel = new Label(composite, SWT.NONE);
+		this.contentDirLabel.setText(Resources.contentDirLabel);
+		this.contentDirLabel.setLayoutData(gdhfill());
+
+		this.contentDir = new Text(composite, SWT.BORDER);
+		this.contentDir.setLayoutData(gdhfill());
+		synchHelper.synchText(contentDir, CONTENT_DIR, null);
+
+		return modulesGroup;
+	}
+
+	protected int getJ2EEVersion() {
+		IProjectFacetVersion version = (IProjectFacetVersion)getDataModel().getProperty(FACET_VERSION);
+		return J2EEVersionUtil.convertVersionStringToInt(version.getVersionString());
+	}
+	
+	/**
+	 * @param modulesGroup
+	 */
+	private void createModuleProjectOptions(Composite modulesGroup) {
+		moduleProjectsViewer = CheckboxTableViewer.newCheckList(modulesGroup, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
+		GridData gData = new GridData(GridData.FILL_BOTH);
+		gData.widthHint = 200;
+		gData.heightHint = 80;
+		moduleProjectsViewer.getControl().setLayoutData(gData);
+		int j2eeVersion = getJ2EEVersion();
+		AvailableJ2EEComponentsContentProvider provider = new AvailableJ2EEComponentsContentProvider(j2eeVersion);
+		moduleProjectsViewer.setContentProvider(provider);
+		moduleProjectsViewer.setLabelProvider(new J2EEComponentLabelProvider());
+		setCheckedItemsFromModel();
+		
+		moduleProjectsViewer.addCheckStateListener(new ICheckStateListener() {
+			public void checkStateChanged(CheckStateChangedEvent event) {
+				if (!ignoreCheckedState) {
+					getDataModel().setProperty(J2EE_PROJECTS_LIST, getCheckedJ2EEElementsAsList());
+					getDataModel().setProperty(JAVA_PROJECT_LIST, getCheckedJavaProjectsAsList());
+                }
+			}
+		});
+		TableLayout tableLayout = new TableLayout();
+		moduleProjectsViewer.getTable().setLayout(tableLayout);
+		moduleProjectsViewer.getTable().setHeaderVisible(false);
+		moduleProjectsViewer.getTable().setLinesVisible(false);
+		moduleProjectsViewer.setSorter(null);
+	}
+
+	/**
+	 *  
+	 */
+	private void setCheckedItemsFromModel() {
+		List components = (List) getDataModel().getProperty(J2EE_PROJECTS_LIST);
+		moduleProjectsViewer.setCheckedElements(components.toArray());
+	}
+
+	private void refreshModules() {
+		moduleProjectsViewer.refresh();
+		setCheckedItemsFromModel();
+	}
+
+	protected List getCheckedJ2EEElementsAsList() {
+		Object[] elements = moduleProjectsViewer.getCheckedElements();
+		List list;
+		if (elements == null || elements.length == 0)
+			list = Collections.EMPTY_LIST;
+		else{
+			list = new ArrayList(); 
+			for( int i=0; i< elements.length; i++){
+				if( elements[i] instanceof IProject ) {
+					list.add(elements[i]);
+				}
+			}
+		}	
+		return list;
+	}
+	
+	protected List getCheckedJavaProjectsAsList() {
+		Object[] elements = moduleProjectsViewer.getCheckedElements();
+		List list;
+		if (elements == null || elements.length == 0)
+			list = Collections.EMPTY_LIST;
+		else{
+			list = new ArrayList(); 
+			for( int i=0; i< elements.length; i++){
+				if( elements[i] instanceof IProject ) {
+					list.add(elements[i]);
+				}
+			}
+		}	
+		return list;
+	}
+	
+	
+	protected void createButtonsGroup(org.eclipse.swt.widgets.Composite parent) {
+		Composite buttonGroup = new Composite(parent, SWT.NONE);
+		GridLayout layout = new GridLayout();
+		layout.numColumns = 4;
+		buttonGroup.setLayout(layout);
+		buttonGroup.setLayoutData(new GridData(GridData.FILL_BOTH));
+		selectAllButton = new Button(buttonGroup, SWT.PUSH);
+		selectAllButton.setText(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_PROJECT_MODULES_PG_SELECT));
+		selectAllButton.addListener(SWT.Selection, this);
+		GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
+		gd.widthHint = 120;
+		selectAllButton.setLayoutData(gd);
+		deselectAllButton = new Button(buttonGroup, SWT.PUSH);
+		deselectAllButton.setText(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_PROJECT_MODULES_PG_DESELECT));
+		deselectAllButton.addListener(SWT.Selection, this);
+		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
+		gd.widthHint = 120;
+		deselectAllButton.setLayoutData(gd);
+		newModuleButton = new Button(buttonGroup, SWT.PUSH);
+		newModuleButton.setText(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_PROJECT_MODULES_PG_NEW));
+		newModuleButton.addListener(SWT.Selection, this);
+		gd = new GridData(GridData.GRAB_HORIZONTAL);
+		gd.minimumWidth = 120;
+		newModuleButton.setLayoutData(gd);
+	}
+
+	/**
+	 * @see org.eclipse.swt.widgets.Listener#handleEvent(Event)
+	 */
+	public void handleEvent(Event evt) {
+		if (evt.widget == selectAllButton)
+			handleSelectAllButtonPressed();
+		else if (evt.widget == deselectAllButton)
+			handleDeselectAllButtonPressed();
+		else if (evt.widget == newModuleButton)
+			handleNewModuleButtonPressed();
+		else
+			super.handleEvent(evt);
+	}
+
+	/**
+	 *  
+	 */
+	private void handleNewModuleButtonPressed() {
+		IDataModel aModel = createNewModuleModel();
+		DefaultJ2EEComponentCreationWizard wizard = new DefaultJ2EEComponentCreationWizard(aModel);
+		WizardDialog dialog = new WizardDialog(getShell(), wizard);
+		dialog.create();
+		if (dialog.open() != IDialogConstants.CANCEL_ID) {
+			IWorkspaceRoot input = ResourcesPlugin.getWorkspace().getRoot();
+			moduleProjectsViewer.setInput(input);
+            setNewModules(aModel);
+            refreshModules();
+		}
+	}
+    /**
+     * @param model
+     */
+    private void setNewModules(IDataModel defaultModel) {
+        List newComponents = new ArrayList();
+        collectNewComponents(defaultModel, newComponents);
+        List oldComponents = (List) getDataModel().getProperty(J2EE_PROJECTS_LIST);
+        newComponents.addAll(oldComponents);
+        getDataModel().setProperty(J2EE_PROJECTS_LIST, newComponents);
     }
     
-    private static GridData gdhfill()
-    {
-        return new GridData( GridData.FILL_HORIZONTAL );
+    private void collectNewComponents(IDataModel defaultModel, List newProjects) {
+        collectComponents(defaultModel.getNestedModel(IDefaultJ2EEComponentCreationDataModelProperties.NESTED_MODEL_EJB), newProjects);
+        collectComponents(defaultModel.getNestedModel(IDefaultJ2EEComponentCreationDataModelProperties.NESTED_MODEL_WEB), newProjects);
+        collectComponents(defaultModel.getNestedModel(IDefaultJ2EEComponentCreationDataModelProperties.NESTED_MODEL_CLIENT), newProjects);
+        collectComponents(defaultModel.getNestedModel(IDefaultJ2EEComponentCreationDataModelProperties.NESTED_MODEL_JCA), newProjects);
     }
-
-    private static final class Resources
-    
-        extends NLS
-        
-    {
-        public static String pageTitle;
-        public static String pageDescription;
-        public static String contentDirLabel;
-        public static String contentDirLabelInvalid;
-        
-        static
-        {
-            initializeMessages( EarFacetInstallPage.class.getName(), 
-                                Resources.class );
+    private void collectComponents(IDataModel compDM, List newProjects) {
+        if (compDM != null) {
+        	String projectName = compDM.getStringProperty(IFacetDataModelProperties.FACET_PROJECT_NAME);
+            if(projectName == null) return;
+            IProject project = ProjectUtilities.getProject(projectName);
+            if (project != null && project.exists())
+                newProjects.add(project);
         }
     }
     
+	private IDataModel createNewModuleModel() {
+		IDataModel defaultModel = DataModelFactory.createDataModel(new DefaultJ2EEComponentCreationDataModelProvider());
+		// transfer properties, project name
+		String projectName = model.getStringProperty(FACET_PROJECT_NAME);
+		defaultModel.setProperty(IDefaultJ2EEComponentCreationDataModelProperties.PROJECT_NAME, projectName);
+		// ear component name
+		String earName = model.getStringProperty(FACET_PROJECT_NAME);
+		defaultModel.setProperty(IDefaultJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME, earName);
+		// ear j2ee version
+		int j2eeVersion = getJ2EEVersion();
+		defaultModel.setProperty(IDefaultJ2EEComponentCreationDataModelProperties.J2EE_VERSION, new Integer(j2eeVersion));
+		
+		IRuntime rt = (IRuntime) model.getProperty(FACET_RUNTIME);
+		defaultModel.setProperty(IDefaultJ2EEComponentCreationDataModelProperties.FACET_RUNTIME, rt);
+		
+		return defaultModel;
+	}
+
+	/**
+	 *  
+	 */
+	private void handleDeselectAllButtonPressed() {
+		ignoreCheckedState = true;
+		try {
+			moduleProjectsViewer.setAllChecked(false);
+			//getDataModel().setProperty(J2EE_COMPONENT_LIST, null);
+			//IDataModel nestedModel = (IDataModel)getDataModel().getProperty(NESTED_ADD_COMPONENT_TO_EAR_DM);	
+			//(nestedModel).setProperty(AddComponentToEnterpriseApplicationDataModelProvider., getCheckedJ2EEElementsAsList());
+			getDataModel().setProperty(J2EE_PROJECTS_LIST, null);
+			getDataModel().setProperty(JAVA_PROJECT_LIST, null);			
+		} finally {
+			ignoreCheckedState = false;
+		}
+	}
+
+	/**
+	 *  
+	 */
+	private void handleSelectAllButtonPressed() {
+		ignoreCheckedState = true;
+		try {
+			moduleProjectsViewer.setAllChecked(true);
+			//getDataModel().setProperty(J2EE_COMPONENT_LIST, getCheckedElementsAsList());
+			//IDataModel nestedModel = (IDataModel)getDataModel().getProperty(NESTED_ADD_COMPONENT_TO_EAR_DM);
+			//(nestedModel).setProperty(AddComponentToEnterpriseApplicationDataModelProvider., getCheckedJ2EEElementsAsList());
+			
+			getDataModel().setProperty(J2EE_PROJECTS_LIST, getCheckedJ2EEElementsAsList());
+			getDataModel().setProperty(JAVA_PROJECT_LIST, getCheckedJavaProjectsAsList());
+			
+		} finally {
+			ignoreCheckedState = false;
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.wst.common.frameworks.internal.ui.wizard.J2EEWizardPage#enter()
+	 */
+	protected void enter() {
+		IWorkspaceRoot input = ResourcesPlugin.getWorkspace().getRoot();
+		moduleProjectsViewer.setInput(input);
+		super.enter();
+	}
+	
+	
+	private static final class Resources
+
+	extends NLS
+
+	{
+		public static String pageTitle;
+		public static String pageDescription;
+		public static String contentDirLabel;
+		public static String contentDirLabelInvalid;
+
+		static {
+			initializeMessages(EarFacetInstallPage.class.getName(), Resources.class);
+		}
+	}
+
 }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.properties b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.properties
index 73c7486..4cd1fce 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarFacetInstallPage.properties
@@ -1,4 +1,14 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
 pageTitle = EAR Module
 pageDescription = Configure EAR module settings.
-contentDirLabel = Content Directory\:
-contentDirLabelInvalid = Content Directory (invalid)\:
+contentDirLabel = Content Directory:
+contentDirLabelInvalid = Content Directory (invalid):
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectFirstPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectFirstPage.java
new file mode 100644
index 0000000..3ebafd0
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectFirstPage.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.ui.project.facet;
+
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPluginIcons;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.web.ui.internal.wizards.DataModelFacetCreationWizardPage;
+
+public class EarProjectFirstPage extends DataModelFacetCreationWizardPage {
+
+	public EarProjectFirstPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+		setTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.EAR_COMPONENT_MAIN_PG_TITLE));
+		setDescription(J2EEUIMessages.getResourceString(J2EEUIMessages.EAR_COMPONENT_MAIN_PG_DESC));
+		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.EAR_WIZ_BANNER));
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectWizard.java
index da688b6..a108d70 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarProjectWizard.java
@@ -1,50 +1,58 @@
-/******************************************************************************
- * Copyright (c) 2005 BEA Systems, Inc.
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- *
+ * 
  * Contributors:
- *    Konstantin Komissarchik - initial API and implementation
- ******************************************************************************/
-
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.ui.project.facet;
 
 import java.net.URL;
 
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.project.facet.EARFacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
 import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
-import org.eclipse.wst.common.project.facet.ui.FacetedProjectWizard;
+import org.eclipse.wst.web.ui.internal.wizards.NewProjectDataModelFacetWizard;
 import org.osgi.framework.Bundle;
 
-/**
- * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
- */
+public class EarProjectWizard extends NewProjectDataModelFacetWizard {
 
-public final class EarProjectWizard
+	public EarProjectWizard(IDataModel model){
+		super(model);
+		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.EAR_COMPONENT_WIZ_TITLE));
+	}
+	
+	public EarProjectWizard(){
+		super();
+		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.EAR_COMPONENT_WIZ_TITLE));
+	}
+	
+	protected IDataModel createDataModel() {
+		return DataModelFactory.createDataModel(new EARFacetProjectCreationDataModelProvider());
+	}
 
-    extends FacetedProjectWizard
+	protected ImageDescriptor getDefaultPageImageDescriptor() {
+		final Bundle bundle = Platform.getBundle("org.eclipse.jst.j2ee.ui");
+		final URL url = bundle.getEntry("icons/ear-wiz-banner.gif");
 
-{
-    protected IFacetedProjectTemplate getTemplate()
-    {
-        return ProjectFacetsManager.getTemplate( "template.jst.ear" );
-    }
-    
-    protected String getPageDescription()
-    {
-        return "Create an EAR project in the workspace or at an external location";
-    }
+		return ImageDescriptor.createFromURL(url);
+	}
 
-    protected ImageDescriptor getDefaultPageImageDescriptor()
-    {
-        final Bundle bundle = Platform.getBundle( "org.eclipse.jst.j2ee.ui" );
-        final URL url = bundle.getEntry( "icons/ear-wiz-banner.gif" );
+	protected IFacetedProjectTemplate getTemplate() {
+		return ProjectFacetsManager.getTemplate("template.jst.ear");
+	}
 
-        return ImageDescriptor.createFromURL( url );
-    }
+	protected IWizardPage createFirstPage() {
+		return new EarProjectFirstPage(model, "first.page"); //$NON-NLS-1$ 
+	}
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.java
index e47f76e..27ee1a3 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.java
@@ -11,77 +11,55 @@
 
 package org.eclipse.jst.j2ee.ui.project.facet;
 
-import java.util.ArrayList;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IWorkspace;
-import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.web.project.facet.IWebFacetInstallDataModelProperties;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Combo;
 import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Listener;
-import org.eclipse.wst.common.componentcore.ModuleCoreNature;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelSynchHelper;
 
 /**
  * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
  */
 
-public final class EarSelectionPanel
-
-    extends Composite
+public final class EarSelectionPanel implements IWebFacetInstallDataModelProperties
     
 {
-    private final ArrayList listeners;
     private final Button addToEar;
     private final Combo combo;
     private final Button newButton;
+    private final Label label;
    
-    public EarSelectionPanel( final Composite parent, 
-                              final int style ) 
+    private final IDataModel model;
+    private DataModelSynchHelper synchhelper;
+    
+    public EarSelectionPanel( final IDataModel model, final Composite parent) 
     {
-        super( parent, style );
+        this.model = model;
+        this.synchhelper = new DataModelSynchHelper(model);
         
-        this.listeners = new ArrayList();
-        
-        final GridLayout layout = new GridLayout( 2, false );
-        layout.marginWidth = 0;
-        layout.marginHeight = 0;
-        
-        setLayout( layout );
-        
-        this.addToEar = new Button( this, SWT.CHECK );
+        this.addToEar = new Button( parent, SWT.CHECK );
         this.addToEar.setText( Resources.addToEarLabel );
-        this.addToEar.setLayoutData( gdhspan( gdhfill(), 2 ) );
-        
-        this.addToEar.addSelectionListener( new SelectionAdapter()
-        {
-            public void widgetSelected( final SelectionEvent event ) 
-            {
-                resetEnabledState();
-                notifyListeners();
-            }
-        } );
-        
-        this.combo = new Combo( this, SWT.BORDER | SWT.READ_ONLY );
+        this.addToEar.setLayoutData( gdhspan( gdhfill(), 3 ) );
+        synchhelper.synchCheckbox(addToEar, ADD_TO_EAR, null);
+
+        label = new Label(parent, SWT.NULL);
+        label.setText(Resources.earProjectLabel);
+        GridData gridData = new GridData();
+        gridData.horizontalIndent = 20;
+        label.setLayoutData(gridData);
+        this.combo = new Combo(parent, SWT.NONE);
         this.combo.setLayoutData( gdhfill() );
         
-        this.combo.addSelectionListener( new SelectionAdapter()
-        {
-            public void widgetSelected( final SelectionEvent event )
-            {
-                notifyListeners();
-            }
-        } );
-        
-        this.newButton = new Button( this, SWT.PUSH );
+        this.newButton = new Button( parent, SWT.PUSH );
         this.newButton.setText( Resources.newButtonLabel );
         
         this.newButton.addSelectionListener( new SelectionAdapter()
@@ -89,86 +67,11 @@
             public void widgetSelected( final SelectionEvent event )
             {
                 handleAddButton();
-                notifyListeners();
             }
         } );
         
-        resetEnabledState();
+        synchhelper.synchCombo(combo, EAR_PROJECT_NAME, new Control[]{label, newButton});
         
-        populateEarList();
-        
-        if( this.combo.getItemCount() > 0 )
-        {
-            this.combo.select( 0 );
-        }
-    }
-    
-    public boolean getAddToEar()
-    {
-        return this.addToEar.getSelection();
-    }
-    
-    public String getEarProjectName()
-    {
-        if( this.addToEar.getSelection() )
-        {
-            final int index = this.combo.getSelectionIndex();
-            return index == -1 ? null : this.combo.getItem( index );
-        }
-        else
-        {
-            return null;
-        }
-    }
-    
-    public void addListener( final Listener listener )
-    {
-        this.listeners.add( listener );
-    }
-    
-    public void removeListener( final Listener listener )
-    {
-        this.listeners.remove( listener );
-    }
-    
-    private void notifyListeners()
-    {
-        for( int i = 0, n = this.listeners.size(); i < n; i++ )
-        {
-            ( (Listener) this.listeners.get( i ) ).handleEvent( null );
-        }
-    }
-    
-    private void resetEnabledState()
-    {
-        final boolean enabled = this.addToEar.getSelection();
-        
-        this.combo.setEnabled( enabled );
-        this.newButton.setEnabled( enabled );
-    }
-    
-    private void populateEarList()
-    {
-        this.combo.removeAll();
-        
-        final IWorkspace ws = ResourcesPlugin.getWorkspace();
-        final IProject[] projects = ws.getRoot().getProjects();
-        
-        for( int i = 0; i < projects.length; i++ )
-        {
-            final IProject project = projects[ i ];
-            
-            
-            if( !ModuleCoreNature.isFlexibleProject(project) )
-            {
-                continue;
-            }
-            
-            if(J2EEProjectUtilities.isEARProject(project))
-            {
-                this.combo.add( project.getName() );
-            }
-            }
     }
 
     private void handleAddButton()
@@ -176,25 +79,13 @@
         final EarProjectWizard wizard = new EarProjectWizard();
         
         final WizardDialog dialog 
-            = new WizardDialog( getShell(), wizard );
+            = new WizardDialog( newButton.getShell(), wizard );
         
         if( dialog.open() != SWT.CANCEL )
         {
+            model.notifyPropertyChange(EAR_PROJECT_NAME, IDataModel.VALID_VALUES_CHG);
             final String earproj = wizard.getProjectName();
-            
-            if( earproj != null )
-            {
-                populateEarList();
-                
-                for( int i = 0, n = this.combo.getItemCount(); i < n; i++ )
-                {
-                    if( this.combo.getItem( i ).equals( earproj ) )
-                    {
-                        this.combo.select( i );
-                        break;
-                    }
-                }
-            }
+            model.setProperty(EAR_PROJECT_NAME, earproj);
         }
     }
     
@@ -217,6 +108,7 @@
     {
         public static String addToEarLabel;
         public static String newButtonLabel;
+        public static String earProjectLabel;
         
         static
         {
@@ -225,4 +117,11 @@
         }
     }
     
+    public void dispose() {
+    	if(synchhelper != null){
+    		synchhelper.dispose();
+    		synchhelper = null;
+    	}
+    }
+    
 }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.properties b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.properties
index b6732b9..0d6810e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/EarSelectionPanel.properties
@@ -1,2 +1,13 @@
-addToEarLabel = Add project to an EAR.
-newButtonLabel = New...
\ No newline at end of file
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+addToEarLabel = Add project to an EAR
+newButtonLabel = New...
+earProjectLabel=EAR Project Name:
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.java
index 00c8fb1..6fb4c12 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.java
@@ -11,94 +11,39 @@
 
 package org.eclipse.jst.j2ee.ui.project.facet;
 
-import org.eclipse.jst.j2ee.project.facet.IUtilityFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEModuleFacetInstallPage;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Listener;
-import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
-import org.eclipse.wst.common.project.facet.ui.AbstractFacetWizardPage;
 
 /**
  * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
  */
+public final class UtilityFacetInstallPage extends J2EEModuleFacetInstallPage {
+	public UtilityFacetInstallPage() {
+		super("utility.facet.install.page");
+		setTitle(Resources.pageTitle);
+		setDescription(Resources.pageDescription);
+	}
 
-public final class UtilityFacetInstallPage 
+	private static final class Resources extends NLS {
+		public static String pageTitle;
+		public static String pageDescription;
 
-    extends AbstractFacetWizardPage
-    
-{
-    private IDataModel config;
-    private EarSelectionPanel earPanel;
-    
-    public UtilityFacetInstallPage() 
-    {
-        super( "utility.facet.install.page" );
-        
-        setTitle( Resources.pageTitle );
-        setDescription( Resources.pageDescription );
-    }
-    
-    public void createControl( final Composite parent ) 
-    {
-        final Composite composite = new Composite( parent, SWT.NONE );
-        composite.setLayout( new GridLayout( 1, false ) );
-        
-        this.earPanel = new EarSelectionPanel( composite, SWT.NONE );
-        this.earPanel.setLayoutData( gdhfill() );
-        
-        this.earPanel.addListener( new Listener()
-        {
-            public void handleEvent( final Event event ) 
-            {
-                config.setStringProperty(IUtilityFacetInstallDataModelProperties.EAR_PROJECT_NAME,earPanel.getEarProjectName() );
-                validate();
-            }
-        } );
-        
-        setControl( composite );
-    }
-    
-    public void setConfig( final Object config ) 
-    {
-        this.config = (IDataModel) config;
-    }
+		static {
+			initializeMessages(UtilityFacetInstallPage.class.getName(), Resources.class);
+		}
+	}
 
-    private void validate()
-    {
-        boolean valid = true;
-        
-        if( this.earPanel.getAddToEar() && 
-            this.earPanel.getEarProjectName() == null )
-        {
-            valid = false;
-        }
-        
-        this.setPageComplete( valid );
-    }
-    
-    private static GridData gdhfill()
-    {
-        return new GridData( GridData.FILL_HORIZONTAL );
-    }
+	protected String[] getValidationPropertyNames() {
+		return new String[]{EAR_PROJECT_NAME};
+	}
 
-    private static final class Resources
-    
-        extends NLS
-        
-    {
-        public static String pageTitle;
-        public static String pageDescription;
-        
-        static
-        {
-            initializeMessages( UtilityFacetInstallPage.class.getName(), 
-                                Resources.class );
-        }
-    }
-    
+	protected Composite createTopLevelComposite(Composite parent) {
+		final Composite composite = new Composite(parent, SWT.NONE);
+		composite.setLayout(new GridLayout(1, false));
+		//setupEarControl(composite);
+		return composite;
+	}
 }
-
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.properties b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.properties
index 1a31e84..0a6de07 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityFacetInstallPage.properties
@@ -1,2 +1,12 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
 pageTitle = Utility Module
 pageDescription = Configure utility module settings.
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectFirstPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectFirstPage.java
new file mode 100644
index 0000000..28cd41e
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectFirstPage.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.ui.project.facet;
+
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEComponentFacetCreationWizardPage;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class UtilityProjectFirstPage extends J2EEComponentFacetCreationWizardPage {
+
+	public UtilityProjectFirstPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+		setTitle(Resources.pageTitle);
+		setDescription(Resources.pageDescription);
+	}
+
+	private static final class Resources extends NLS {
+		public static String pageTitle;
+		public static String pageDescription;
+
+		static {
+			initializeMessages(UtilityFacetInstallPage.class.getName(), Resources.class);
+		}
+	}
+
+	protected String getModuleFacetID() {
+		return J2EEProjectUtilities.UTILITY;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectWizard.java
index dae8c95..494ad6c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectWizard.java
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/UtilityProjectWizard.java
@@ -15,36 +15,48 @@
 
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.project.facet.UtilityProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
 import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
-import org.eclipse.wst.common.project.facet.ui.FacetedProjectWizard;
+import org.eclipse.wst.web.ui.internal.wizards.NewProjectDataModelFacetWizard;
 import org.osgi.framework.Bundle;
 
 /**
  * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
  */
 
-public final class UtilityProjectWizard 
+public final class UtilityProjectWizard extends NewProjectDataModelFacetWizard {
 
-    extends FacetedProjectWizard 
-    
-{
-    protected IFacetedProjectTemplate getTemplate()
-    {
-        return ProjectFacetsManager.getTemplate( "template.jst.utility" );
-    }
-    
-    protected String getPageDescription()
-    {
-        return "Create a Utility project in the workspace or at an external location.";
-    }
-    
-    protected ImageDescriptor getDefaultPageImageDescriptor()
-    {
-        final Bundle bundle = Platform.getBundle( "org.eclipse.jst.j2ee.ui" );
-        final URL url = bundle.getEntry( "icons/util-wiz-banner.gif" );
+	public UtilityProjectWizard(IDataModel model) {
+		super(model);
+		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.JAVAUTIL_COMPONENT_WIZ_TITLE));
+	}
+	
+	public UtilityProjectWizard(){
+		super();
+		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.JAVAUTIL_COMPONENT_WIZ_TITLE));
+	}
 
-        return ImageDescriptor.createFromURL( url );
-    }
-    
+	protected IDataModel createDataModel() {
+		return DataModelFactory.createDataModel(new UtilityProjectCreationDataModelProvider());
+	}
+
+	protected ImageDescriptor getDefaultPageImageDescriptor() {
+		final Bundle bundle = Platform.getBundle("org.eclipse.jst.j2ee.ui");
+		final URL url = bundle.getEntry("icons/util-wiz-banner.gif");
+		return ImageDescriptor.createFromURL(url);
+	}
+
+	protected IFacetedProjectTemplate getTemplate() {
+		return ProjectFacetsManager.getTemplate("template.jst.utility");
+	}
+
+	protected IWizardPage createFirstPage() {
+		return new UtilityProjectFirstPage(model, "first.page"); //$NON-NLS-1$ 
+	}
+
 }
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientFacetInstallPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientFacetInstallPage.java
new file mode 100644
index 0000000..6a315d3
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientFacetInstallPage.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.ui.project.facet.appclient;
+
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEModuleFacetInstallPage;
+import org.eclipse.jst.j2ee.project.facet.IAppClientFacetInstallDataModelProperties;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+
+public class AppClientFacetInstallPage extends J2EEModuleFacetInstallPage implements IAppClientFacetInstallDataModelProperties {
+
+	private Label configFolderLabel;
+	private Text configFolder;
+	private Button createMainClass;
+	
+	public AppClientFacetInstallPage() {
+		super("appclient.facet.install.page"); //$NON-NLS-1$
+		setTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_PROJECT_MAIN_PG_TITLE));
+		setDescription(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_SETTINGS));
+	}
+
+	protected String[] getValidationPropertyNames() {
+		return new String[]{EAR_PROJECT_NAME, CONFIG_FOLDER, CREATE_DEFAULT_MAIN_CLASS};
+	}
+
+	protected Composite createTopLevelComposite(Composite parent) {
+		final Composite composite = new Composite(parent, SWT.NONE);
+		composite.setLayout(new GridLayout(1, false));
+
+		//setupEarControl(composite);
+		
+		configFolderLabel = new Label(composite, SWT.NONE);
+		configFolderLabel.setText(J2EEUIMessages.getResourceString(J2EEUIMessages.SOURCEFOLDER));
+		configFolderLabel.setLayoutData(gdhfill());
+
+		configFolder = new Text(composite, SWT.BORDER);
+		configFolder.setLayoutData(gdhfill());
+		configFolder.setData("label", configFolderLabel); //$NON-NLS-1$
+		synchHelper.synchText(configFolder, CONFIG_FOLDER, null);
+		
+		createMainClass = new Button(composite, SWT.CHECK);
+		createMainClass.setText(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_CREATE_MAIN));
+		synchHelper.synchCheckbox(createMainClass, CREATE_DEFAULT_MAIN_CLASS, null);
+		
+		return composite;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientProjectFirstPage.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientProjectFirstPage.java
new file mode 100644
index 0000000..7095ea3
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientProjectFirstPage.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.ui.project.facet.appclient;
+
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPluginIcons;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEComponentFacetCreationWizardPage;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class AppClientProjectFirstPage extends J2EEComponentFacetCreationWizardPage {
+
+	public AppClientProjectFirstPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+		setTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_PROJECT_MAIN_PG_TITLE));
+		setDescription(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_PROJECT_MAIN_PG_DESC));
+		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.APP_CLIENT_PROJECT_WIZARD_BANNER));
+	}
+
+	protected String getModuleFacetID() {
+		return J2EEProjectUtilities.APPLICATION_CLIENT;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientProjectWizard.java b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientProjectWizard.java
new file mode 100644
index 0000000..86eab40
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/ui/project/facet/appclient/AppClientProjectWizard.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.ui.project.facet.appclient;
+
+import java.net.URL;
+
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.jst.j2ee.applicationclient.internal.creation.AppClientFacetProjectCreationDataModelProvider;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIMessages;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+import org.eclipse.wst.web.ui.internal.wizards.NewProjectDataModelFacetWizard;
+import org.osgi.framework.Bundle;
+
+public class AppClientProjectWizard extends NewProjectDataModelFacetWizard {
+
+	public AppClientProjectWizard(IDataModel model) {
+		super(model);
+		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_PROJECT_WIZ_TITLE));
+	}
+
+	public AppClientProjectWizard() {
+		super();
+		setWindowTitle(J2EEUIMessages.getResourceString(J2EEUIMessages.APP_CLIENT_PROJECT_WIZ_TITLE));
+	}
+
+	protected IDataModel createDataModel() {
+		return DataModelFactory.createDataModel(new AppClientFacetProjectCreationDataModelProvider());
+	}
+
+	protected ImageDescriptor getDefaultPageImageDescriptor() {
+		final Bundle bundle = Platform.getBundle(J2EEUIPlugin.PLUGIN_ID);
+		final URL url = bundle.getEntry("icons/full/wizban/appclient_wiz.gif"); //$NON-NLS-1$
+		return ImageDescriptor.createFromURL(url);
+	}
+
+	protected IFacetedProjectTemplate getTemplate() {
+		return ProjectFacetsManager.getTemplate("template.jst.appclient"); //$NON-NLS-1$
+	}
+
+	protected IWizardPage createFirstPage() {
+		return new AppClientProjectFirstPage(model, "first.page"); //$NON-NLS-1$
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.ui/plugin.properties b/plugins/org.eclipse.jst.j2ee.ui/plugin.properties
index 8aa9394..5dbe68c 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/plugin.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/plugin.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -23,7 +23,7 @@
 create.enterprise.application_ui_=Create an Enterprise Application
 create.client.module_ui_=Create an Application Client project
 client.export.action.label_ui_=Export Application Client JAR...
-jar.dependencies.props_ui_=J2EE Modules
+jar.dependencies.props_ui_=EAR Dependencies
 ejb.export.action.description_ui_=Export EJB JAR File...
 ejb.client.jar.creation.action.description_ui_=Create EJB Client Jar
 emptyEJBGroupFilter.name=Empty EJB groups
@@ -41,10 +41,10 @@
 Java_Component.description=Create a Java Component
 addmodulestoear.props_ui_=EAR modules
 J2EEDependenciesPage.name = J2EE Module Dependencies
-weblib.dependencies.props_ui_= Web Libraries 
+weblib.dependencies.props_ui_=Web Libraries
 J2EE_Rename_Participant=J2EE Rename Participant
 new-projects-wizard-category-name = Web Tools (New)
 util-project-wizard-name = Utility Project
 util-project-wizard-description = Create a Utility project
 ear-project-wizard-name = EAR Project
-ear-project-wizard-description = Create an EAR project
\ No newline at end of file
+ear-project-wizard-description = Create an EAR project
diff --git a/plugins/org.eclipse.jst.j2ee.ui/plugin.xml b/plugins/org.eclipse.jst.j2ee.ui/plugin.xml
index 9e0909f..1271256 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.ui/plugin.xml
@@ -66,10 +66,10 @@
             name="%ear_component_ui_"
             icon="icons/full/ctool16/newear_wiz.gif"
             category="org.eclipse.jst.j2ee.internal"
-            class="org.eclipse.jst.j2ee.internal.wizard.EARComponentCreationWizard"
+            class="org.eclipse.jst.j2ee.ui.project.facet.EarProjectWizard"
             project="true"
             finalPerspective="org.eclipse.jst.j2ee.J2EEPerspective"
-            id="org.eclipse.jst.j2ee.internal.wizard.EARComponentCreationWizard">
+            id="org.eclipse.jst.j2ee.ui.project.facet.EarProjectWizard">
          <description>
             %new.ear.component.description_ui_
          </description>
@@ -82,10 +82,10 @@
             name="%appclient_component_ui_"
             icon="icons/full/ctool16/newappclient_wiz.gif"
             category="org.eclipse.jst.j2ee.internal"
-            class="org.eclipse.jst.j2ee.internal.wizard.AppClientComponentCreationWizard"
+            class="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientProjectWizard"
             project="true"
             finalPerspective="org.eclipse.jst.j2ee.J2EEPerspective"
-            id="org.eclipse.jst.j2ee.internal.wizard.AppClientComponentCreationWizard">
+            id="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientProjectWizard">
          <description>
             %new.appclient.component.description_ui_
          </description>
@@ -93,6 +93,22 @@
                class="org.eclipse.core.resources.IResource">
          </selection>
       </wizard>
+<!-- Utility Component Wizard -->
+      <wizard
+      		name="%util-project-wizard-name"
+      		icon="icons/util-wiz-icon.gif"
+      		category="org.eclipse.jst.j2ee.internal"
+      		class="org.eclipse.jst.j2ee.ui.project.facet.UtilityProjectWizard"
+      		project="true"
+      		finalPerspective="org.eclipse.jst.j2ee.J2EEPerspective"
+      		id="org.eclipse.jst.j2ee.ui.project.facet.UtilityProjectWizard">
+      <description>
+      	%util-project-wizard-description
+      </description>
+         <selection
+               class="org.eclipse.core.resources.IResource">
+         </selection>
+    </wizard>
       
    </extension>
   
@@ -479,8 +495,9 @@
 <!-- Navigator Object Contributions -->
 
     <extension point="org.eclipse.ui.propertyPages">
-    
-<!-- =========== org.eclipse.jst.j2ee.internal.J2EEDependencyPage (Category Page)============ -->
+ 
+     
+<!-- =========== org.eclipse.jst.j2ee.internal.J2EEDependencyPage ============ -->
       <page
       		objectClass="org.eclipse.core.resources.IProject"
       		name="%J2EEDependenciesPage.name"
@@ -496,80 +513,15 @@
       		name="%J2EEDependenciesPage.name"
             class="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
             id="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage">
-      </page>
-<!-- =========== org.eclipse.jst.j2ee.internal.JARDependencyProperties============ -->
-      <page
-            objectClass="org.eclipse.core.resources.IProject"
-            name="%jar.dependencies.props_ui_"
-            category="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
-            class="org.eclipse.jst.j2ee.internal.JARDependencyPropertiesPage"
-            id="JARDependenciesPropertiesPage">
-          <filter
+            <filter
                name="nature"
                value="org.eclipse.wst.common.modulecore.ModuleCoreNature">
-          </filter>
-     	 </page>
-      <page
-            objectClass="org.eclipse.jdt.core.IJavaProject"
-            name="%jar.dependencies.props_ui_"
-             category="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
-            class="org.eclipse.jst.j2ee.internal.JARDependencyPropertiesPage"
-            id="JARDependenciesPropertiesPage">
-         <filter
-               name="nature"
-               value="org.eclipse.jdt.core.javanature">
-         </filter>
+          </filter>    
       </page>
-<!-- =========== org.eclipse.jst.j2ee.internal.WebLibDependencyPropertiesPage ============ -->
-         <page
-            objectClass="org.eclipse.core.resources.IProject"
-            name="%weblib.dependencies.props_ui_"
-            category="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
-            class="org.eclipse.jst.j2ee.internal.WebLibDependencyPropertiesPage"
-            id="WebLibDependencyPropertiesPage">
-          <filter
-               name="nature"
-               value="org.eclipse.wst.common.modulecore.ModuleCoreNature">
-          </filter>
-     	 </page>
-      <page
-            objectClass="org.eclipse.jdt.core.IJavaProject"
-            name="%weblib.dependencies.props_ui_"
-            category="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
-            class="org.eclipse.jst.j2ee.internal.WebLibDependencyPropertiesPage"
-            id="WebLibDependencyPropertiesPage">
-         <filter
-               name="nature"
-               value="org.eclipse.jdt.core.javanature">
-         </filter>
-      </page>
-  	</extension>
-<!-- =========== org.eclipse.jst.j2ee.internal.AddModulestoEARPropertiesPage============ -->
-	<extension point="org.eclipse.ui.propertyPages">
-         <page
-            objectClass="org.eclipse.core.resources.IProject"
-            name="%addmodulestoear.props_ui_"
-            category="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
-            class="org.eclipse.jst.j2ee.internal.AddModulestoEARPropertiesPage"
-            id="AddModulestoEARPropertiesPage">
-         <filter
-               name="nature"
-               value="org.eclipse.wst.common.modulecore.ModuleCoreNature">
-         </filter>
-      </page>
-      <page
-            objectClass="org.eclipse.jdt.core.IJavaProject"
-            name="%addmodulestoear.props_ui_"
-            category="org.eclipse.jst.j2ee.internal.J2EEDependenciesPage"
-            class="org.eclipse.jst.j2ee.internal.AddModulestoEARPropertiesPage"
-            id="AddModulestoEARPropertiesPage">
-         <filter
-               name="nature"
-               value="org.eclipse.wst.common.modulecore.ModuleCoreNature">
-         </filter>
-      </page>      
-   </extension>
-   
+      
+    </extension>
+
+<!--  
 	<extension point="org.eclipse.ltk.core.refactoring.renameParticipants">
 	  
 		<renameParticipant
@@ -591,7 +543,7 @@
 		</renameParticipant>
 	</extension>
 	
-<!--	<extension point="org.eclipse.ltk.core.refactoring.renameParticipants">
+	<extension point="org.eclipse.ltk.core.refactoring.renameParticipants">
 	  
 		<renameParticipant
 				class="org.eclipse.jst.j2ee.internal.actions.J2EEComponentRenameParticipant"
@@ -662,7 +614,7 @@
         <!-- AppClient New -->
         <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.j2ee.internal.wizard.AppClientComponentCreationWizard">
+            wizardId="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientProjectWizard">
          <enablement>
          <or>
                 <objectClass
@@ -932,7 +884,7 @@
              class="org.eclipse.jst.j2ee.internal.deployables.EnterpriseDeployableArtifactAdapterFactory"
              adaptableType="org.eclipse.core.resources.IFile">
             <adapter type= "org.eclipse.debug.ui.actions.ILaunchable"/>
-       </factory> 
+       </factory>
    </extension> 
    
    <extension
@@ -970,11 +922,11 @@
      
     <extension point="org.eclipse.wst.common.project.facet.ui.wizard">
 
-    <wizard-pages facet="jst.utility" version="1.0">
+    <!-- <wizard-pages facet="jst.utility" version="1.0">
       <install>
         <page class="org.eclipse.jst.j2ee.ui.project.facet.UtilityFacetInstallPage"/>
       </install>
-    </wizard-pages>
+    </wizard-pages> -->
 
     <wizard-pages facet="jst.ear" version="1.2">
       <install>
@@ -994,37 +946,29 @@
       </install>
     </wizard-pages>
     
-  </extension>
-  
-    <extension point="org.eclipse.ui.newWizards">
-  
-    <category
-      name="%new-projects-wizard-category-name"
-      id="org.eclipse.jst.newprojects">
-    </category>
-    
-    <wizard
-      name="%util-project-wizard-name"
-      icon="icons/util-wiz-icon.gif"
-      category="org.eclipse.jst.newprojects"
-      class="org.eclipse.jst.j2ee.ui.project.facet.UtilityProjectWizard"
-      project="true"
-      id="org.eclipse.jst.j2ee.ui.project.facet.UtilityProjectWizard">
-      <description>%util-project-wizard-description</description>
-    </wizard>
+    <wizard-pages facet="jst.appclient" version="1.2">
+      <install>
+        <page class="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientFacetInstallPage"/>
+      </install>
+    </wizard-pages>
 
-    <wizard
-      name="%ear-project-wizard-name"
-      icon="icons/ear-wiz-icon.gif"
-      category="org.eclipse.jst.newprojects"
-      class="org.eclipse.jst.j2ee.ui.project.facet.EarProjectWizard"
-      project="true"
-      id="org.eclipse.jst.j2ee.ui.project.facet.EarProjectWizard">
-      <description>%ear-project-wizard-description</description>
-    </wizard>
+    <wizard-pages facet="jst.appclient" version="1.3">
+      <install>
+        <page class="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientFacetInstallPage"/>
+      </install>
+    </wizard-pages>
 
-    
-  </extension>
+    <wizard-pages facet="jst.appclient" version="1.4">
+      <install>
+        <page class="org.eclipse.jst.j2ee.ui.project.facet.appclient.AppClientFacetInstallPage"/>
+      </install>
+    </wizard-pages>
+    </extension>
+      
+    <extension
+          point="org.eclipse.wst.common.modulecore.ComponentProjectMigrator">
+       <migratorExtension class="org.eclipse.jst.j2ee.internal.J2EEComponentProjectMigrator"/>
+    </extension>
    
 
 </plugin>
diff --git a/plugins/org.eclipse.jst.j2ee.ui/property_files/UtilityFacetInstallPage.properties b/plugins/org.eclipse.jst.j2ee.ui/property_files/UtilityFacetInstallPage.properties
index 1a31e84..0a6de07 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/property_files/UtilityFacetInstallPage.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/property_files/UtilityFacetInstallPage.properties
@@ -1,2 +1,12 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
 pageTitle = Utility Module
 pageDescription = Configure utility module settings.
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_figures.properties b/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_figures.properties
index 8ba66f7..0ada374 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_figures.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_figures.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_ui.properties b/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_ui.properties
index 9ac84f4..d390a57 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_ui.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/property_files/ejb_ui.properties
@@ -1,43 +1,46 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-0=Failed to find the image "{0}".
-1=New EJB Project
-2=EJB version:
-3=EJB Project
-4=Create an EJB project and add it to a new or existing Enterprise Application.
-5=Import an EJB jar from the file system
-6=EJB Jar Import
-7=EJB Jar file:
-8=EJB module:
-9=EJB Jar Export
-10=Export EJB project to the local file system.
-11=EJB client JAR Creation
-12=Use this wizard to create an EJB client JAR from your existing EJB
-13=Client JAR URI:
-14=Project name:
-15=Project location:
-16=EJB Module:
-17=Delete Bean Only
-18=Delete Bean Classes
-19=Delete Access Bean
-20=Delete Deployed Code
-21=Select All
-22=Deselect All
-23=The selected enterprise bean cannot be deleted because it is involved in\nrelationships with other enterprise beans.  You must first delete these\nrelationships before deleting the bean.
-24=Delete...
-25=Cannot delete Enterprise Bean
-26=Cannot delete the bean named "{0}" because it is in a binary project.
-27=Delete Enterprise Bean(s)
-28=What options would you like when deleting the selected\nEnterprise Bean(s)?
+KEY_0=Failed to find the image "{0}".
+KEY_1=New EJB Project
+KEY_2=EJB version:
+KEY_3=EJB Project
+KEY_4=Create an EJB project and add it to a new or existing Enterprise Application.
+KEY_5=Import an EJB jar from the file system
+KEY_6=EJB Jar Import
+KEY_7=EJB Jar file:
+KEY_8=EJB Project:
+KEY_9=EJB Jar Export
+KEY_10=Export EJB project to the local file system.
+KEY_11=EJB client JAR Creation
+KEY_12=Use this wizard to create an EJB client JAR from your existing EJB
+KEY_13=Client JAR URI:
+KEY_14=Project name:
+KEY_15=Project location:
+KEY_16=EJB Project:
+KEY_17=Delete Bean Only
+KEY_18=Delete Bean Classes
+KEY_19=Delete Access Bean
+KEY_20=Delete Deployed Code
+KEY_21=Select All
+KEY_22=Deselect All
+KEY_23=The selected enterprise bean cannot be deleted because it is involved in\nrelationships with other enterprise beans.  You must first delete these\nrelationships before deleting the bean.
+KEY_24=Delete...
+KEY_25=Cannot delete Enterprise Bean
+KEY_26=Cannot delete the bean named "{0}" because it is in a binary project.
+KEY_27=Delete Enterprise Bean(s)
+KEY_28=What options would you like when deleting the selected\nEnterprise Bean(s)?
 GroupedEJBJarItemProvider_UI_0=Session
 GroupedEJBJarItemProvider_UI_1=Entity
 GroupedEJBJarItemProvider_UI_2=Message
-NewEJBProjectAction_UI_0=EJB Module
+NewEJBProjectAction_UI_0=EJB Project
+pageTitle=Ejb Module
+pageDescription=Configure ejb module settings.
+configFolderLabel=Config Folder:
diff --git a/plugins/org.eclipse.jst.j2ee.ui/property_files/j2ee_ui.properties b/plugins/org.eclipse.jst.j2ee.ui/property_files/j2ee_ui.properties
index 3bb7342..c1c945e 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/property_files/j2ee_ui.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/property_files/j2ee_ui.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -103,8 +103,10 @@
 98=Generate an annotated servlet class
 
 97=Select the utility JARs from the list to be imported as utility projects or jars.
-99=Module Name:
+99=Project Name:
 100=Module Version:
+101=Configure Application Client module settings.
+102=Content Folder:
 Entity_UI_=Entity Beans
 Message_Driven_Beans_UI_=Message-Driven Beans
 Session_Beans_UI_=Session Beans
@@ -315,9 +317,9 @@
 INTERFACE_SELECTION_DIALOG_TITLE=Interface Selection
 JAVAUTILITY_MAIN_PG_TITLE=Java Component
 JAVAUTILITY_MAIN_PG_DESC=Create a Java Component
-JAVAUTIL_COMPONENT_WIZ_TITLE=New Java Component Module
+JAVAUTIL_COMPONENT_WIZ_TITLE=New Java Utility Module
 AVAILABLE_J2EE_COMPONENTS= Available J2EE modules
 EXTERNAL_JAR=Add External Jars...
 ADDVARIABLE=Add Variable...
 SUPPORTMULTIPLEMODULES=Support Multiple Modules per project
-SOURCEFOLDER=Source Folder:
\ No newline at end of file
+SOURCEFOLDER=Source Folder:
diff --git a/plugins/org.eclipse.jst.j2ee.ui/property_files/jca_ui.properties b/plugins/org.eclipse.jst.j2ee.ui/property_files/jca_ui.properties
index 6db8aca..f8ff5fa 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/property_files/jca_ui.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/property_files/jca_ui.properties
@@ -1,21 +1,23 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-0=Failed to find the image "{0}".
-1=New Connector Project
-2=J2C version:
-3=Connector Project
-4=Create a standalone Connector project or add it to a new or existing Enterprise Application project.
-5=Import a Connector module from the file system
-6=Connector Import
-7=Connector file:
-8=Connector module:
-9=Connector Export
-10=Export Connector module to the local file system.
+_0=Failed to find the image "{0}".
+_1=New Connector Project
+_2=J2C version:
+_3=Connector Project
+_4=Create a standalone Connector module or add it to a new or existing Enterprise Application project.
+_5=Import a Connector module from the file system
+_6=Connector Import
+_7=Connector file:
+_8=Connector module:
+_9=Connector Export
+_10=Export Connector module to the local file system.
+_11=Configure Connector module settings.
+connector_export_action_label_ui_=Export RAR File...
diff --git a/plugins/org.eclipse.jst.j2ee.ui/property_files/manifest_ui.properties b/plugins/org.eclipse.jst.j2ee.ui/property_files/manifest_ui.properties
index a9cd7e7..edffc57 100644
--- a/plugins/org.eclipse.jst.j2ee.ui/property_files/manifest_ui.properties
+++ b/plugins/org.eclipse.jst.j2ee.ui/property_files/manifest_ui.properties
@@ -1,3 +1,13 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
 Up_1=&Up
 Down_2=&Down
 Select_All_3=Select &All
@@ -14,15 +24,18 @@
 Project_name__UI_=Project name:
 EAR_Project_Name__UI__UI_=Enterprise application project name:
 Available_dependent_JARs__UI_=Available dependent JARs:
-Manifest_Class-Path__UI_=Manifest Class-Path:
-JAR/Module_UI_=JAR/Module
+Manifest_Class_Path__UI_=Manifest Class-Path:
+JAR_Module_UI_=JAR/Module
 Project_UI_=Project
 EAR_Modules=EAR Modules:
 EAR_Modules_Desc=This property page lets you setup the module dependencies in an Enterprise Application.
-J2EE_Modules=J2EE Modules:
+J2EE_Modules=J2EE Modules
 J2EE_Modules_Desc=This property page lets you setup the j2ee module dependencies with other j2ee modules within an Enterprise Application.  All modules involved in the dependency need to belong to the same Enterprise Application.
-Web_Libraries=Web Libraries:
+Web_Libraries=Web Libraries
 Web_Libraries_Desc=This property page lets you add the Web Library dependency to other java modules in the workpspace. This dependency resolves the java modules into the web\\lib folder of the web module at deployment time.
 EAR_Module_Dep_Error=J2EE Modules is not valid for EAR modules.
 Jar_Dep_One_Module_Error=Java Jar Dependencies is valid only for one module per flexible project.
-Web_Lib_Error=Web library settings are only valid for Web modules.
\ No newline at end of file
+Web_Lib_Error=Web library settings are only valid for Web modules.
+REDIRECT_TEXT_EDITOR_UI_=REDIRECT_TEXT_EDITOR_UI_
+Error_Checking_Project_Facets=Error checking project facets.
+Error_Checking_Project_Facets=Error checking project facets.
diff --git a/plugins/org.eclipse.jst.j2ee.web/.cvsignore b/plugins/org.eclipse.jst.j2ee.web/.cvsignore
index c72ac7d..d369c9a 100644
--- a/plugins/org.eclipse.jst.j2ee.web/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.web/.cvsignore
@@ -3,3 +3,4 @@
 runtime
 temp.folder
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.web/build.properties b/plugins/org.eclipse.jst.j2ee.web/build.properties
index feeb39b..a6a23c6 100644
--- a/plugins/org.eclipse.jst.j2ee.web/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.web/build.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -14,7 +14,8 @@
                templates/,\
                .,\
                META-INF/,\
-               about.html
+               about.html,\
+               schema/
 jars.compile.order = .
 source.. = web/,\
            war-validation/,\
diff --git a/plugins/org.eclipse.jst.j2ee.web/plugin.xml b/plugins/org.eclipse.jst.j2ee.web/plugin.xml
index 985d2da..75f75dc 100644
--- a/plugins/org.eclipse.jst.j2ee.web/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.web/plugin.xml
@@ -7,7 +7,7 @@
 <!-- Web JSFaces File URL extension -->
 <!--============================-->
 
-   <extension-point id="fileURL" name="FileURL"/>
+   <extension-point id="fileURL" name="FileURL" schema="schema/fileURL.exsd"/>
 
 
 <!--============================-->
@@ -344,29 +344,20 @@
       class="org.eclipse.jst.j2ee.internal.web.classpath.WebAppContainerInitializer"
       id="org.eclipse.jst.j2ee.internal.web.container"/>
   </extension>
+  
   <!-- Project Facets -->
-	<extension point="org.eclipse.wst.common.project.facet.core.facets">
+  
+  <extension point="org.eclipse.wst.common.project.facet.core.facets">
 
     <project-facet id="jst.web">
       <label>Dynamic Web Module</label>
       <description>Enables the project to be deployed as a dynamic web module.</description>
-      <icon>icons/war.gif</icon>
     </project-facet>
 
     <project-facet-version facet="jst.web" version="2.2">
-      <action type="install">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDelegate"/>
-        <config-factory class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDataModelProvider"/>
-      </action>
-      <action type="version-change">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetVersionChangeDelegate"/>
-      </action>
-      <action type="runtime-changed">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetRuntimeChangedDelegate"/>
-      </action>
       <constraint>
         <and>
-          <requires facet="jst.java" version="1.3" allow-newer="true"/>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -374,19 +365,9 @@
     </project-facet-version>
 
     <project-facet-version facet="jst.web" version="2.3">
-      <action type="install">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDelegate"/>
-        <config-factory class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDataModelProvider"/>
-      </action>
-      <action type="version-change">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetVersionChangeDelegate"/>
-      </action>
-      <action type="runtime-changed">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetRuntimeChangedDelegate"/>
-      </action>
       <constraint>
         <and>
-          <requires facet="jst.java" version="1.3" allow-newer="true"/>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -394,25 +375,28 @@
     </project-facet-version>
 
     <project-facet-version facet="jst.web" version="2.4">
-      <action type="install">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDelegate"/>
-        <config-factory class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDataModelProvider"/>
-      </action>
-      <action type="version-change">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetVersionChangeDelegate"/>
-      </action>
-      <action type="runtime-changed">
-        <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetRuntimeChangedDelegate"/>
-      </action>
       <constraint>
         <and>
-          <requires facet="jst.java" version="1.3" allow-newer="true"/>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
       <group-member id="modules"/>
     </project-facet-version>
     
+    <action type="install" facet="jst.web" version="&gt;=2.2,&lt;=2.4">
+      <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDelegate"/>
+      <config-factory class="org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDataModelProvider"/>
+    </action>
+
+<!-- <action type="version-change" facet="jst.web" version="&gt;=2.2,&lt;=2.4">
+      <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetVersionChangeDelegate"/>
+    </action> -->
+    
+    <action type="runtime-changed" facet="jst.web" version="&gt;=2.2,&lt;=2.4">
+      <delegate class="org.eclipse.jst.j2ee.web.project.facet.WebFacetRuntimeChangedDelegate"/>
+    </action>
+
     <template id="template.jst.web">
       <label>Dynamic Web Project</label>
       <fixed facet="jst.java"/>
diff --git a/plugins/org.eclipse.jst.j2ee.web/property_files/ProjectSupport.properties b/plugins/org.eclipse.jst.j2ee.web/property_files/ProjectSupport.properties
index 0d54403..dcfa881 100644
--- a/plugins/org.eclipse.jst.j2ee.web/property_files/ProjectSupport.properties
+++ b/plugins/org.eclipse.jst.j2ee.web/property_files/ProjectSupport.properties
@@ -1,14 +1,14 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-Creating_Web_Project..._UI_=Creating Web Project...
+Creating_Web_Project____UI_=Creating Web Project...
 The_path_for_the_links_sta_EXC_=IWAE0001E The path for the links state file is incorrect
 Syntax_Error_in_the_links_UI_=Syntax Error in the links state file
 Error_while_saving_links_s_EXC_=IWAE0002E Error while saving links state file
@@ -16,12 +16,12 @@
 Operation_failed_due_to_IO_ERROR_=IWAE0004E Operation failed due to IO error:
 Operation_failed_due_to_Co_ERROR_=IWAE0005E Operation failed due to Core error:
 Operation_failed_due_to_Ja_ERROR_=IWAE0006E Operation failed due to Java Model error:
-1concat_EXC_=IWAE0007E Error occured getting web.xml: {0}
+_1concat_EXC_=IWAE0007E Error occured getting web.xml: {0}
 Error_importing_Module_Fil_EXC_=IWAE0008E Error importing Module File
 Cannot_clone_TaglibInfo_1_EXC_=IWAE0009E Cannot clone TaglibInfo
 Could_not_read_TLD_15=Could not read TLD
 File_Serving_Enabler_7=File Serving Enabler
-Auto_Generated_-_File_Enabler_9=Auto Generated - File Enabler
+Auto_Generated___File_Enabler_9=Auto Generated - File Enabler
 Generated_by_Web_Tooling_23=Generated by Web Tooling
 Not_a_web_project_29=Not a web project
 A_web_project_must_be_open_and_must_exist_for_properties_to_be_edited_30=A web project must be open and must exist for properties to be edited
@@ -37,10 +37,11 @@
 Could_not_rename_____2=Could not rename: ''{0}'' already exists.
 Sync_WLP_Op=Synchronizing Web Library Projects\n\t
 Target_Update_Op=Updating target server for {0}\n\t
-24concat_INFO_=IWAE0011I .startupOnInitialize() for
+_24concat_INFO_=IWAE0011I .startupOnInitialize() for
 Sychronize_Class_Path_UI_=Sychronize Class Path
 Catalog_Lib_Directory__UI_=Catalog Lib Directory:
 Update_ClassPath__UI_=Update ClassPath:
 Catalog_Lib_Directory__UI_=Catalog Lib Directory:
 Update_ClassPath__UI_=Update ClassPath:
 Set_ClassPath__UI_=Set ClassPath:
+UNABLE_TO_LOAD_MODULE_ERROR_=UNABLE_TO_LOAD_MODULE_ERROR_
diff --git a/plugins/org.eclipse.jst.j2ee.web/property_files/web.properties b/plugins/org.eclipse.jst.j2ee.web/property_files/web.properties
index 97bd7c3..548ad72 100644
--- a/plugins/org.eclipse.jst.j2ee.web/property_files/web.properties
+++ b/plugins/org.eclipse.jst.j2ee.web/property_files/web.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -17,10 +17,10 @@
 
 ERR_SERVLET_MAPPING_URL_PATTERN_EMPTY=The servlet mapping url pattern cannot be empty.
 ERR_SERVLET_MAPPING_URL_PATTERN_EXIST=The servlet mapping url pattern "{0}" already exists.
-3=The filter mapping url pattern cannot be empty.
-4=The filter mapping url pattern "{0}" already exists.
-5=The filter mapping servlet cannot be empty.
-6=The filter init param name cannot be empty.
+KEY_3=The filter mapping url pattern cannot be empty.
+KEY_4=The filter mapping url pattern "{0}" already exists.
+KEY_5=The filter mapping servlet cannot be empty.
+KEY_6=The filter init param name cannot be empty.
 ERR_FILTER_PARAMETER_NAME_EXIST=The filter initialization parameter name already exists.
 ERR_FILTER_MAPPING_SERVLET_EXIST=The filter mapping servlet "{0}" already exists.
 ERR_FILTER_MAPPING_SERVLET_DISPATCHER_TYPES_EMPTY=The dispatcher types cannot be empty.
@@ -86,4 +86,4 @@
 ERR_FILTER_LIST_EMPTY=The list of filters to be removed cannot be empty.
 ERR_LISTENER_LIST_EMPTY=The list of listeners to be removed cannot be empty.
 
-WEB_CONT_DESCRIPTION = Web App Libraries [{0}]
\ No newline at end of file
+WEB_CONT_DESCRIPTION = Web App Libraries [{0}]
diff --git a/plugins/org.eclipse.jst.j2ee.web/schema/fileURL.exsd b/plugins/org.eclipse.jst.j2ee.web/schema/fileURL.exsd
new file mode 100644
index 0000000..f3e39e8
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.web/schema/fileURL.exsd
@@ -0,0 +1,118 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- Schema file written by PDE -->
+<schema targetNamespace="org.eclipse.jst.j2ee.web">
+<annotation>
+      <appInfo>
+         <meta.schema plugin="org.eclipse.jst.j2ee.web" id="fileURL" name="File URL"/>
+      </appInfo>
+      <documentation>
+         This is for the Web JSFaces File URL extension.
+      </documentation>
+   </annotation>
+
+   <element name="extension">
+      <complexType>
+         <sequence>
+            <element ref="fileURL"/>
+         </sequence>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+                  a fully qualified identifier of the target extension point
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  an optional identifier of the extension instance
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+                  an optional name of the extension instance
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="fileURL">
+      <complexType>
+         <sequence>
+            <element ref="run"/>
+         </sequence>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="run">
+      <complexType>
+         <attribute name="class" type="string" use="required">
+            <annotation>
+               <documentation>
+                  
+               </documentation>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="since"/>
+      </appInfo>
+      <documentation>
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="examples"/>
+      </appInfo>
+      <documentation>
+         
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="apiInfo"/>
+      </appInfo>
+      <documentation>
+         
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="implementation"/>
+      </appInfo>
+      <documentation>
+         
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="copyright"/>
+      </appInfo>
+      <documentation>
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
+      </documentation>
+   </annotation>
+
+</schema>
diff --git a/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarHelper.java b/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarHelper.java
index a869a2a..5c54733 100644
--- a/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -28,4 +28,4 @@
 	public UIWarHelper() {
 		super();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarValidator.java b/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarValidator.java
index a7075a5..7871d8f 100644
--- a/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarValidator.java
+++ b/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/UIWarValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -163,4 +163,4 @@
 			}
 		}
 	}*/	
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/WarHelper.java b/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/WarHelper.java
index bce70d6..8886eec 100644
--- a/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/WarHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.web/war-validation/org/eclipse/jst/j2ee/internal/web/validation/WarHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.validation;
 
 
@@ -116,4 +118,4 @@
 		return null;
 	}	
 	
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/ModuleAdapter.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/ModuleAdapter.java
index f52ee36..27ab2ee 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/ModuleAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/ModuleAdapter.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 8, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebDeployableArtifactUtil.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebDeployableArtifactUtil.java
index ad98505..440e4b8 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebDeployableArtifactUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebDeployableArtifactUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -324,4 +324,4 @@
 		return J2EEProjectUtilities.isDynamicWebProject(project);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebModuleArtifact.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebModuleArtifact.java
index 1c998db..9f213a9 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebModuleArtifact.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/deployables/WebModuleArtifact.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtension.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtension.java
index 4f6bbef..53e2075 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtension.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -80,4 +80,4 @@
 	public void setId(String id) {
 		this.id = id;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtensionReader.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtensionReader.java
index acdcc7e..c188cc3 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtensionReader.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/jfaces/extension/FileURLExtensionReader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -113,4 +113,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/AddServletOperation.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/AddServletOperation.java
index 4b3a02a..a994659 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/AddServletOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/AddServletOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -304,4 +304,4 @@
 			webApp.getServletMappings().add(mapping);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/CreateServletTemplateModel.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/CreateServletTemplateModel.java
index 16fa0aa..2dd2372 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/CreateServletTemplateModel.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/CreateServletTemplateModel.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -169,4 +169,4 @@
 			return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/INewServletClassDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/INewServletClassDataModelProperties.java
index 608ebf8..cd739b1 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/INewServletClassDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/INewServletClassDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.operations;
 
 import org.eclipse.jst.j2ee.application.internal.operations.IAnnotationsDataModel;
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassDataModelProvider.java
index 05c4574..bc5e52c 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -357,7 +357,7 @@
 		if (status.isOK()) {
 			// Do not allow the name to be "Servlet"
 			if (className.equals("Servlet")) { //$NON-NLS-1$
-				String msg = WebMessages.getResourceString(WebMessages.ERR_SERVLET_JAVA_CLASS_NAME_INVALID);
+				String msg = WebMessages.ERR_SERVLET_JAVA_CLASS_NAME_INVALID;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 			return WTPCommonPlugin.OK_STATUS;
@@ -381,7 +381,7 @@
 			// Ensure there are not duplicate entries in the list
 			boolean dup = hasDuplicatesInStringArrayList(prop);
 			if (dup) {
-				String msg = WebMessages.getResourceString(WebMessages.ERR_DUPLICATED_INIT_PARAMETER);
+				String msg = WebMessages.ERR_DUPLICATED_INIT_PARAMETER;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 		}
@@ -404,11 +404,11 @@
 			// Ensure there are not duplicates in the mapping list
 			boolean dup = hasDuplicatesInStringArrayList(prop);
 			if (dup) {
-				String msg = WebMessages.getResourceString(WebMessages.ERR_DUPLICATED_URL_MAPPING);
+				String msg = WebMessages.ERR_DUPLICATED_URL_MAPPING;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 		} else {
-			String msg = WebMessages.getResourceString(WebMessages.ERR_SERVLET_MAPPING_URL_PATTERN_EMPTY);
+			String msg = WebMessages.ERR_SERVLET_MAPPING_URL_PATTERN_EMPTY;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		// Return OK
@@ -513,7 +513,7 @@
 	private IStatus validateDisplayName(String prop) {
 		// Ensure the servlet display name is not null or empty
 		if (prop == null || prop.trim().length() == 0) {
-			String msg = WebMessages.getResourceString(WebMessages.ERR_DISPLAY_NAME_EMPTY);
+			String msg = WebMessages.ERR_DISPLAY_NAME_EMPTY;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		if (getTargetProject() == null || getTargetComponent() == null)
@@ -521,6 +521,8 @@
 		ArtifactEdit edit = null;
 		try {
 			edit = getArtifactEditForRead();
+			if (edit == null)
+				return WTPCommonPlugin.OK_STATUS;
 			WebApp webApp = (WebApp) edit.getContentModelRoot();
 			if (webApp == null)
 				return WTPCommonPlugin.OK_STATUS;
@@ -556,4 +558,4 @@
 			return Boolean.TRUE;
 		return Boolean.FALSE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassOperation.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassOperation.java
index c6c286a..87da02d 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/NewServletClassOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -17,8 +17,10 @@
 import org.eclipse.core.resources.ICommand;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
@@ -26,14 +28,17 @@
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.emf.codegen.jet.JETEmitter;
 import org.eclipse.emf.codegen.jet.JETException;
 import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaModelMarker;
 import org.eclipse.jdt.core.IPackageFragment;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.internal.annotations.controller.AnnotationsController;
 import org.eclipse.jst.common.internal.annotations.controller.AnnotationsControllerManager;
@@ -78,6 +83,7 @@
  */
 public class NewServletClassOperation extends ArtifactEditProviderOperation {
 	
+	private static final String WEB_PLUGIN_JAR = "org.eclipse.jst.j2ee.web_1.0.0.jar"; //$NON-NLS-1$
 	/**
 	 * The extension name for a java class
 	 */
@@ -202,7 +208,7 @@
 		// Using the WTPJetEmitter, generate the java source based on the servlet template model
 		try {
 			source = generateTemplateSource(tempModel, monitor);
-		} catch (JETException e) {
+		} catch (Exception e) {
 			throw new WFTWrappedException(e);
 		}
 		if (fragment != null) {
@@ -290,11 +296,29 @@
 		// Otherwise use non annotated template
 		else
 			templateURL = WebPlugin.getDefault().find(new Path(TEMPLATE_DIR+getDataModel().getStringProperty(INewServletClassDataModelProperties.NON_ANNOTATED_TEMPLATE_FILE)));
+		cleanUpOldEmitterProject();
 		WTPJETEmitter emitter = new WTPJETEmitter(templateURL.toString(), this.getClass().getClassLoader());
 		emitter.setIntelligentLinkingEnabled(true);
 		emitter.addVariable(WEB_PLUGIN, WebPlugin.PLUGIN_ID);
 		return emitter.generate(monitor, new Object[]{tempModel});
 	}
+	
+	private void cleanUpOldEmitterProject() {
+		IProject project = ProjectUtilities.getProject(WTPJETEmitter.PROJECT_NAME);
+		if (project == null || !project.exists())
+			return;
+		try {
+			IMarker[] markers = project.findMarkers(IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
+			for (int i = 0, l = markers.length; i < l; i++) {
+				if (((Integer) markers[i].getAttribute(IMarker.SEVERITY)).intValue() == IMarker.SEVERITY_ERROR) {
+					project.delete(true,new NullProgressMonitor());
+					break;
+				}
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 
 	/**
 	 * This method is intended for internal use only.  This method will create an instance of the
@@ -335,4 +359,4 @@
 		// Return the source folder
 		return folder;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/WebMessages.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/WebMessages.java
index 22af763..ae2e896 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/WebMessages.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/operations/WebMessages.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,10 +16,7 @@
  */
 package org.eclipse.jst.j2ee.internal.web.operations;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.jst.j2ee.internal.common.J2EECommonMessages;
+import org.eclipse.osgi.util.NLS;
 
 
 /**
@@ -28,133 +25,95 @@
  * To change the template for this generated type comment go to Window - Preferences - Java - Code
  * Generation - Code and Comments
  */
-public class WebMessages extends J2EECommonMessages {
-	public static final String ERR_JAR_NAME_EMPTY = "ERR_JAR_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_JAR_NAME_EXIST = "ERR_JAR_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_JAVA_PROJECT_NAME_EMPTY = "ERR_JAVA_PROJECT_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_JAVA_PROJECT_NAME_EXIST = "ERR_JAVA_PROJECT_NAME_EXIST"; //$NON-NLS-1$
+public class WebMessages extends NLS {
+	private static final String BUNDLE_NAME = "web";//$NON-NLS-1$
 
-	public static final String ERR_DUPLICATED_INIT_PARAMETER = "ERR_DUPLICATED_INIT_PARAMETER"; //$NON-NLS-1$
-	public static final String ERR_DUPLICATED_URL_MAPPING = "ERR_DUPLICATED_URL_MAPPING"; //$NON-NLS-1$
+	private WebMessages() {
+		// Do not instantiate
+	}
 
-	public static final String ERR_DISPLAY_NAME_EMPTY = "ERR_DISPLAY_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_NAME_EXIST = "ERR_SERVLET_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_DISPLAY_NAME_EXIST = "ERR_SERVLET_DISPLAY_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_CLASS_NAME_USED = "ERR_SERVLET_CLASS_NAME_USED"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_JAVA_CLASS_NAME_INVALID = "ERR_SERVLET_JAVA_CLASS_NAME_INVALID"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_MAPPING_SERVLET_NOT_EXIST = "ERR_SERVLET_MAPPING_SERVLET_NOT_EXIST"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_MAPPING_URL_PATTERN_EMPTY = "ERR_SERVLET_MAPPING_URL_PATTERN_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_MAPPING_URL_PATTERN_EXIST = "ERR_SERVLET_MAPPING_URL_PATTERN_EXIST"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_PARAMETER_NAME_EMPTY = "ERR_SERVLET_PARAMETER_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_PARAMETER_NAME_EXIST = "ERR_SERVLET_PARAMETER_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_PARAMETER_VALUE_EMPTY = "ERR_SERVLET_PARAMETER_VALUE_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_PARAMETER_VALUE_EXIST = "ERR_SERVLET_PARAMETER_VALUE_EXIST"; //$NON-NLS-1$
+	public static String ERR_JAR_NAME_EMPTY;
+	public static String ERR_JAR_NAME_EXIST;
+	public static String ERR_JAVA_PROJECT_NAME_EMPTY;
+	public static String ERR_JAVA_PROJECT_NAME_EXIST;
+	public static String ERR_DUPLICATED_INIT_PARAMETER;
+	public static String ERR_DUPLICATED_URL_MAPPING;
 
+	public static String ERR_SERVLET_MAPPING_URL_PATTERN_EMPTY;
+	public static String ERR_SERVLET_MAPPING_URL_PATTERN_EXIST;
+	public static String KEY_3;
+	public static String KEY_4;
+	public static String KEY_5;
+	public static String KEY_6;
+	public static String ERR_FILTER_PARAMETER_NAME_EXIST;
+	public static String ERR_FILTER_MAPPING_SERVLET_EXIST;
+	public static String ERR_FILTER_MAPPING_SERVLET_DISPATCHER_TYPES_EMPTY;
+	public static String ERR_DISPLAY_NAME_EMPTY;
+	public static String ERR_SERVLET_NAME_EXIST;
+	public static String ERR_SERVLET_DISPLAY_NAME_EXIST;
+	public static String ERR_SERVLET_CLASS_NAME_USED;
+	public static String ERR_SERVLET_JAVA_CLASS_NAME_INVALID;
+	public static String ERR_SERVLET_MAPPING_SERVLET_NOT_EXIST;
+	public static String ERR_SERVLET_PARAMETER_NAME_EMPTY;
+	public static String ERR_SERVLET_PARAMETER_NAME_EXIST;
+	public static String ERR_SERVLET_PARAMETER_VALUE_EMPTY;
+	public static String ERR_SERVLET_PARAMETER_VALUE_EXIST;
+	public static String ERR_SERVLET_ROLE_REF_NAME_EMPTY;
+	public static String ERR_SERVLET_ROLE_REF_NAME_EXIST;
+	public static String ERR_SERVLET_ROLE_LINK_EMPTY;
 
-	public static final String ERR_PAGE_ENCODING_EMPTY = "ERR_PAGE_ENCODING_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_PAGE_ENCODING_EXIST = "ERR_PAGE_ENCODING_EXIST"; //$NON-NLS-1$
-	public static final String ERR_URL_PATTERN_EXIST = "ERR_URL_PATTERN_EXIST"; //$NON-NLS-1$
-	public static final String ERR_INCLUDE_PRELUDES_EXIST = "ERR_INCLUDE_PRELUDES_EXIST"; //$NON-NLS-1$
-	public static final String ERR_INCLUDE_CODAS_EXIST = "ERR_INCLUDE_CODAS_EXIST"; //$NON-NLS-1$
+	public static String ERR_FILTER_DISPLAY_NAME_EXIST;
+	public static String ERR_FILTER_CLASS_NAME_USED;
+	public static String ERR_FILTER_CLASS_NAME_INVALID;
+	public static String ERR_LISTENER_DISPLAY_NAME_EXIST;
+	public static String ERR_LISTENER_CLASS_NAME_USED;
+	public static String ERR_LISTENER_CLASS_NAME_INVALID;
 
-	public static final String ERR_SECURITY_CONSTRAINT_NAME_EMPTY = "ERR_SECURITY_CONSTRAINT_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SECURITY_CONSTRAINT_NAME_EXIST = "ERR_SECURITY_CONSTRAINT_NAME_EXIST"; //$NON-NLS-1$
+	public static String ERR_PAGE_ENCODING_EMPTY;
+	public static String ERR_PAGE_ENCODING_EXIST;
+	public static String ERR_URL_PATTERN_EXIST;
+	public static String ERR_INCLUDE_PRELUDES_EXIST;
+	public static String ERR_INCLUDE_CODAS_EXIST;
+	public static String ERR_SECURITY_CONSTRAINT_NAME_EMPTY;
+	public static String ERR_SECURITY_CONSTRAINT_NAME_EXIST;
+	public static String ERR_CONTEXT_PARAMETER_NAME_EMPTY;
+	public static String ERR_CONTEXT_PARAMETER_NAME_EXIST;
+	public static String ERR_RESOURCE_NAME_EMPTY;
+	public static String ERR_RESOURCE_NAME_EXIST;
+	public static String ERR_URL_PATTERNS_EMPTY;
+	public static String ERR_MIME_MAPPING_EXTENSION_EMPTY;
+	public static String ERR_MIME_MAPPING_EXTENSION_EXIST;
+	public static String ERR_WELCOME_PAGE_EMPTY;
+	public static String ERR_WELCOME_PAGE_EXIST;
+	public static String ERR_ENV_ENTRY_NAME_EMPTY;
+	public static String ERR_ENV_ENTRY_NAME_EXIST;
+	public static String ERR_ERROR_CODE_EMPTY;
+	public static String ERR_ERROR_CODE_MUST_BE_3_DIGITS;
+	public static String ERR_ERROR_PAGE_LOCATION_EMPTY;
+	public static String ERR_ERROR_PAGE_LOCATION_EXIST;
+	public static String ERR_ERROR_PAGE_LOCATION_MUST_START_WITH_SLASH;
+	public static String ERR_EXCEPTION_TYPE_EMPTY;
+	public static String ERR_EXCEPTION_SECURITY_ID_NO_BEANS;
+	public static String ERR_EXCEPTION_ROLE_NAME_EMPTY;
+	public static String ERR_LOCALE_NAME_EMPTY;
+	public static String ERR_LOCALE_NAME_EXIST;
+	public static String ERR_TAGLIBREF_URL_EMPTY;
+	public static String ERR_TAGLIBREF_URL_EXIST;
+	public static String ERR_MESSAGE_DESTINATION_NAME_EMPTY;
+	public static String ERR_MESSAGE_DESTINATION_NAME_EXIST;
+	public static String ERR_EXCEPTION_METHOD_ELEMENT_EMPTY;
+	public static String ERR_EXCEPTION_METHOD_TRANSACTION_ATTRIBUTES_EMPTY;
+	public static String ERR_SERVLET_LIST_EMPTY;
+	public static String ERR_FILTER_LIST_EMPTY;
+	public static String ERR_LISTENER_LIST_EMPTY;
 
-	public static final String ERR_SERVLET_ROLE_REF_NAME_EMPTY = "ERR_SERVLET_ROLE_REF_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_ROLE_REF_NAME_EXIST = "ERR_SERVLET_ROLE_REF_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_SERVLET_ROLE_LINK_EMPTY = "ERR_SERVLET_ROLE_LINK_EMPTY"; //$NON-NLS-1$
+	public static String WEB_CONT_DESCRIPTION;
 
-	public static final String ERR_CONTEXT_PARAMETER_NAME_EMPTY = "ERR_CONTEXT_PARAMETER_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_CONTEXT_PARAMETER_NAME_EXIST = "ERR_CONTEXT_PARAMETER_NAME_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_RESOURCE_NAME_EMPTY = "ERR_RESOURCE_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_RESOURCE_NAME_EXIST = "ERR_RESOURCE_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_URL_PATTERNS_EMPTY = "ERR_URL_PATTERNS_EMPTY"; //$NON-NLS-1$
-
-	public static final String ERR_MIME_MAPPING_EXTENSION_EMPTY = "ERR_MIME_MAPPING_EXTENSION_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_MIME_MAPPING_EXTENSION_EXIST = "ERR_MIME_MAPPING_EXTENSION_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_FILTER_DISPLAY_NAME_EXIST = "ERR_FILTER_DISPLAY_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_FILTER_CLASS_NAME_USED = "ERR_FILTER_CLASS_NAME_USED"; //$NON-NLS-1$
-	public static final String ERR_FILTER_CLASS_NAME_INVALID = "ERR_FILTER_CLASS_NAME_INVALID"; //$NON-NLS-1$
-	public static final String ERR_FILTER_MAPPING_URL_PATTERN_EMPTY = "3"; //$NON-NLS-1$
-	public static final String ERR_FILTER_MAPPING_URL_PATTERN_EXIST = "4"; //$NON-NLS-1$
-	public static final String ERR_FILTER_MAPPING_SERVLET_EMPTY = "5"; //$NON-NLS-1$
-	public static final String ERR_FILTER_MAPPING_SERVLET_EXIST = "ERR_FILTER_MAPPING_SERVLET_EXIST"; //$NON-NLS-1$
-	public static final String ERR_FILTER_MAPPING_SERVLET_DISPATCHER_TYPES_EMPTY = "ERR_FILTER_MAPPING_SERVLET_DISPATCHER_TYPES_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_FILTER_PARAM_NAME_EMPTY = "6"; //$NON-NLS-1$
-	public static final String ERR_FILTER_PARAM_NAME_EXISTS = "ERR_FILTER_PARAMETER_NAME_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_LISTENER_DISPLAY_NAME_EXIST = "ERR_LISTENER_DISPLAY_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_LISTENER_CLASS_NAME_USED = "ERR_LISTENER_CLASS_NAME_USED"; //$NON-NLS-1$
-	public static final String ERR_LISTENER_CLASS_NAME_INVALID = "ERR_LISTENER_CLASS_NAME_INVALID"; //$NON-NLS-1$
-
-	public static final String ERR_ENV_ENTRY_NAME_EMPTY = "ERR_ENV_ENTRY_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_ENV_ENTRY_NAME_EXIST = "ERR_ENV_ENTRY_NAME_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_WELCOME_PAGE_EMPTY = "ERR_WELCOME_PAGE_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_WELCOME_PAGE_EXIST = "ERR_WELCOME_PAGE_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_ERROR_CODE_EMPTY = "ERR_ERROR_CODE_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_ERROR_CODE_MUST_BE_3_DIGITS = "ERR_ERROR_CODE_MUST_BE_3_DIGITS"; //$NON-NLS-1$
-
-	public static final String ERR_ERROR_PAGE_LOCATION_EMPTY = "ERR_ERROR_PAGE_LOCATION_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_ERROR_PAGE_LOCATION_EXIST = "ERR_ERROR_PAGE_LOCATION_EXIST"; //$NON-NLS-1$
-	public static final String ERR_ERROR_PAGE_LOCATION_MUST_START_WITH_SLASH = "ERR_ERROR_PAGE_LOCATION_MUST_START_WITH_SLASH"; //$NON-NLS-1$
-
-	public static final String ERR_EXCEPTION_TYPE_EMPTY = "ERR_EXCEPTION_TYPE_EMPTY"; //$NON-NLS-1$
-
-	public static final String ERR_LOCALE_NAME_EMPTY = "ERR_LOCALE_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_LOCALE_NAME_EXIST = "ERR_LOCALE_NAME_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_TAGLIBREF_URL_EMPTY = "ERR_TAGLIBREF_URL_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_TAGLIBREF_URL_EXIST = "ERR_TAGLIBREF_URL_EXIST"; //$NON-NLS-1$
-
-	public static final String ERR_MESSAGE_DESTINATION_NAME_EMPTY = "ERR_MESSAGE_DESTINATION_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_MESSAGE_DESTINATION_NAME_EXIST = "ERR_MESSAGE_DESTINATION_NAME_EXIST"; //$NON-NLS-1$
-
-	//	Security Identity Wizard, EJB EDITOR
-	public static final String ERR_EXCEPTION_SECURITY_ID_EMPTY_ROLE_NAME = "ERR_EXCEPTION_ROLE_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_EXCEPTION_SECURITY_ID_NO_BEANS = "ERR_EXCEPTION_SECURITY_ID_NO_BEANS"; //$NON-NLS-1$
-
-	//Method Permission Wizard, EJB EDITOR
-	public static final String ERR_EXCEPTION_SECURITY_ROLES_EMPTY = ERR_EXCEPTION_SECURITY_ID_EMPTY_ROLE_NAME;
-	public static final String ERR_EXCEPTION_METHOD_ELEMENTS_EMPTY = "ERR_EXCEPTION_METHOD_ELEMENT_EMPTY"; //$NON-NLS-1$
-
-	//Method Transaction Wizard, EJB EDITOR
-	public static final String ERR_EXCEPTION_METHOD_TRANSACTION_EMPTY = "ERR_EXCEPTION_METHOD_TRANSACTION_ATTRIBUTES_EMPTY"; //$NON-NLS-1$
-
-	public static final String ERR_SERVLET_LIST_EMPTY = "ERR_SERVLET_LIST_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_FILTER_LIST_EMPTY = "ERR_FILTER_LIST_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_LISTENER_LIST_EMPTY = "ERR_LISTENER_LIST_EMPTY"; //$NON-NLS-1$
-
-	private static final WebMessages INSTANCE = new WebMessages();
-
-	/**
-	 * Returns the string from the resource bundle, or 'key' if not found.
-	 */
-	public static String getResourceString(String key) {
-		return INSTANCE.doGetResourceString(key);
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, WebMessages.class);
 	}
 
 	public static String getResourceString(String key, Object[] args) {
-		return INSTANCE.doGetResourceString(key, args);
+		return NLS.bind(key, args);
 	}
-
-	protected WebMessages() {
-		super();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.common.frameworks.internal.Messages#initializeBundle()
-	 */
-	protected void initializeBundle() {
-		try {
-			this.resourceBundle = ResourceBundle.getBundle("web"); //$NON-NLS-1$
-		} catch (MissingResourceException x) {
-			//Do nothing
-		}
-	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebModuleExtensionImpl.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebModuleExtensionImpl.java
index d650e37..52d3f91 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebModuleExtensionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebModuleExtensionImpl.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Sep 29, 2003
  * 
@@ -24,8 +26,8 @@
 import org.eclipse.jst.j2ee.internal.moduleextension.EarModuleExtensionImpl;
 import org.eclipse.jst.j2ee.internal.moduleextension.WebModuleExtension;
 import org.eclipse.jst.j2ee.internal.project.J2EEJavaProjectInfo;
-import org.eclipse.jst.j2ee.internal.web.archive.operations.WebComponentCreationDataModelProvider;
 import org.eclipse.jst.j2ee.internal.web.archive.operations.WebComponentImportDataModelProvider;
+import org.eclipse.jst.j2ee.internal.web.archive.operations.WebFacetProjectCreationDataModelProvider;
 import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
@@ -179,7 +181,7 @@
 	 * @see org.eclipse.jst.j2ee.internal.internal.moduleextension.EarModuleExtension#createProjectDataModel()
 	 */
 	public IDataModel createProjectDataModel() {
-		return DataModelFactory.createDataModel(new WebComponentCreationDataModelProvider());
+		return DataModelFactory.createDataModel(new WebFacetProjectCreationDataModelProvider());
 	}
 
 	/*
@@ -191,4 +193,4 @@
 		return DataModelFactory.createDataModel(new WebComponentImportDataModelProvider());
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebPlugin.java b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebPlugin.java
index d506aef..3aedb61 100644
--- a/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.web/web/org/eclipse/jst/j2ee/internal/web/plugin/WebPlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -294,4 +294,4 @@
 		return getString(key,substitutions);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/AuthConstraintItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/AuthConstraintItemProvider.java
index b3ccd19..82553e9 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/AuthConstraintItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/AuthConstraintItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -222,4 +222,4 @@
 		}
 		return super.createCommand(object, editingDomain, commandClass, commandParameter);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ContextParamItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ContextParamItemProvider.java
index 2a031c8..e110ef8 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ContextParamItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ContextParamItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -187,4 +187,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorCodeErrorPageItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorCodeErrorPageItemProvider.java
index 934ba8c..0bc3551 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorCodeErrorPageItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorCodeErrorPageItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -121,4 +121,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorPageItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorPageItemProvider.java
index 34ff93b..190fa5f 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorPageItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ErrorPageItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -137,4 +137,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ExceptionTypeErrorPageItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ExceptionTypeErrorPageItemProvider.java
index 12221b7..2b4befc 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ExceptionTypeErrorPageItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ExceptionTypeErrorPageItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -115,4 +115,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterItemProvider.java
index 1707362..89c494d 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.providers;
 
 
@@ -258,4 +260,4 @@
 			super.setPropertyValue(object, property, value);
 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterMappingItemProvider.java
index 7be1223..a46c2f8 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FilterMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -193,4 +193,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FormLoginConfigItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FormLoginConfigItemProvider.java
index 69fbd57..f9fe867 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FormLoginConfigItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/FormLoginConfigItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -175,4 +175,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/HTTPMethodTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/HTTPMethodTypeItemProvider.java
index fe4923c..1828e70 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/HTTPMethodTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/HTTPMethodTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -146,4 +146,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/InitParamItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/InitParamItemProvider.java
index 4800e2a..0a0a6d5 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/InitParamItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/InitParamItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -220,4 +220,4 @@
 			super.setPropertyValue(object, property, value);
 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ItemHolder.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ItemHolder.java
index ca7e20a..19a4b49 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ItemHolder.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ItemHolder.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -80,4 +80,4 @@
 	public void setWebArtifactEdit(WebArtifactEdit webArtifactEdit) {
 		this.webArtifactEdit = webArtifactEdit;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPConfigItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPConfigItemProvider.java
index ef37d7d..1a59fa8 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPConfigItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPConfigItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -151,4 +151,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPPropertyGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPPropertyGroupItemProvider.java
index f8e3531..d05194d 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPPropertyGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPPropertyGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -215,4 +215,4 @@
 		//		return J2EEPlugin.getDefault();
 		return WebAppEditResourceHandler.RESOURCE_LOCATOR;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPTypeItemProvider.java
index 875ce65..9f7ac5b 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JSPTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -120,4 +120,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JspItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JspItemProviderAdapterFactory.java
index a8b3c55..9682d72 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JspItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/JspItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -229,4 +229,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingItemProvider.java
index 98a71c2..2f23448 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,4 +145,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingListItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingListItemProvider.java
index 643f387..986dc41 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingListItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LocalEncodingMappingListItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -133,4 +133,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LoginConfigItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LoginConfigItemProvider.java
index 24e2b66..19bf93a 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LoginConfigItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/LoginConfigItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -221,4 +221,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/MimeMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/MimeMappingItemProvider.java
index 3c2c454..6c086d2 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/MimeMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/MimeMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -168,4 +168,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/RoleNameTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/RoleNameTypeItemProvider.java
index 45fec9c..c91f022 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/RoleNameTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/RoleNameTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -133,4 +133,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SecurityConstraintItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SecurityConstraintItemProvider.java
index a44aac8..30134bd 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SecurityConstraintItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SecurityConstraintItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -239,4 +239,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletItemProvider.java
index 43c3f5d..5e84866 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.providers;
 
 import java.util.ArrayList;
@@ -292,4 +294,4 @@
 			super.setPropertyValue(object, property, value);
 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletMappingItemProvider.java
index d83594c..602a2da 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -174,4 +174,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletTypeItemProvider.java
index 835994e..2039a89 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/ServletTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -120,4 +120,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SessionConfigItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SessionConfigItemProvider.java
index 6196e75..e4c8b44 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SessionConfigItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/SessionConfigItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,4 +145,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefItemProvider.java
index 31e6a6e..ff337fe 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -167,4 +167,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefTypeItemProvider.java
index 2a988ee..9430cfc 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/TagLibRefTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,4 +145,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/URLPatternTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/URLPatternTypeItemProvider.java
index b3fcb11..25339c3 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/URLPatternTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/URLPatternTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,4 +145,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/UserDataConstraintItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/UserDataConstraintItemProvider.java
index 9b523cd..02c04b1 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/UserDataConstraintItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/UserDataConstraintItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -186,4 +186,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppEditResourceHandler.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppEditResourceHandler.java
index f59fffa..8e82792 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppEditResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppEditResourceHandler.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.providers;
 
 import java.net.URL;
@@ -92,4 +94,4 @@
 
 		return getString(key);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppItemProvider.java
index b1584ee..4d6dbf5 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebAppItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -344,4 +344,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebResourceCollectionItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebResourceCollectionItemProvider.java
index ebc2373..4b294a6 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebResourceCollectionItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebResourceCollectionItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -291,4 +291,4 @@
 		}
 		return super.createCommand(object, editingDomain, commandClass, commandParameter);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebapplicationItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebapplicationItemProviderAdapterFactory.java
index 6edc0ed..3cebe0b 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebapplicationItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WebapplicationItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -683,4 +683,4 @@
 	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
 		this.parentAdapterFactory = parentAdapterFactory;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileItemProvider.java
index 1c22185..7ea31c7 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -142,4 +142,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileListItemProvider.java b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileListItemProvider.java
index 19d4a6b..6893d09 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileListItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webedit/org/eclipse/jst/j2ee/internal/web/providers/WelcomeFileListItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -158,4 +158,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WTProjectStrategyUtils.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WTProjectStrategyUtils.java
index 9f4a42b..34c0477 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WTProjectStrategyUtils.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WTProjectStrategyUtils.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.archive.operations;
 
 
@@ -85,4 +87,4 @@
 
 		return path.toString();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationDataModelProvider.java
index 92484ca..b4b4988 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -34,6 +34,11 @@
 import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonMessages;
 import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
 
+/**
+ * @deprecated 
+ * @see WebFacetProjectCreationDataModelProvider
+ */
+
 public class WebComponentCreationDataModelProvider extends J2EEComponentCreationDataModelProvider implements IWebComponentCreationDataModelProperties {
 
 	public WebComponentCreationDataModelProvider() {
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationFacetOperation.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationFacetOperation.java
index 063a4d3..dd94086 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationFacetOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentCreationFacetOperation.java
@@ -10,9 +10,6 @@
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.archive.operations;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IAdaptable;
@@ -20,7 +17,7 @@
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.J2EEComponentCreationFacetOperation;
 import org.eclipse.jst.j2ee.web.datamodel.properties.IWebComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.web.project.facet.IWebFacetInstallDataModelProperties;
@@ -29,6 +26,7 @@
 import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
@@ -41,24 +39,22 @@
 	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
 		IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
 		String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
-		
+
 		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, projectName);
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION,
-				model.getProperty(IComponentCreationDataModelProperties.LOCATION));
-		
-		List facetDMs = new ArrayList();
-		facetDMs.add(setupJavaInstallAction());
+
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+		map.add(setupJavaInstallAction());
 		IDataModel newModel = setupWebInstallAction();
-		facetDMs.add(newModel);
-		setRuntime(newModel,dm); //Setting runtime property
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
+		map.add(newModel);
+		setRuntime(newModel, dm); // Setting runtime property
+
 		IStatus stat = dm.getDefaultOperation().execute(monitor, info);
-		if( stat.isOK()){
+		if (stat.isOK()) {
 			String earProjectName = (String) model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME);
-			IProject earProject = ProjectUtilities.getProject( earProjectName );
+			IProject earProject = ProjectUtilities.getProject(earProjectName);
 			if (earProject != null && earProject.exists())
 				stat = addtoEar(projectName, earProjectName);
-		}		
+		}
 
 		return stat;
 	}
@@ -68,10 +64,13 @@
 		IDataModel webFacetInstallDataModel = DataModelFactory.createDataModel(new WebFacetInstallDataModelProvider());
 		webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME));
 		webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, versionStr);
-		webFacetInstallDataModel.setProperty(IWebFacetInstallDataModelProperties.CONTENT_DIR, model.getStringProperty(IWebComponentCreationDataModelProperties.WEBCONTENT_FOLDER));
-		if (model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR))
-			webFacetInstallDataModel.setProperty(IWebFacetInstallDataModelProperties.EAR_PROJECT_NAME, model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME));		
-		webFacetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(IJ2EEComponentCreationDataModelProperties.RUNTIME_TARGET_ID));
+		webFacetInstallDataModel.setProperty(IWebFacetInstallDataModelProperties.CONFIG_FOLDER, model.getStringProperty(IWebComponentCreationDataModelProperties.WEBCONTENT_FOLDER));
+		webFacetInstallDataModel.setProperty(IWebFacetInstallDataModelProperties.CONTEXT_ROOT, model.getStringProperty(IWebComponentCreationDataModelProperties.CONTEXT_ROOT));
+		webFacetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR));
+		if (model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR)) {
+			webFacetInstallDataModel.setProperty(IWebFacetInstallDataModelProperties.EAR_PROJECT_NAME, model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME));
+		}
+		webFacetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(IJ2EEComponentCreationDataModelProperties.RUNTIME_TARGET_ID));
 		return webFacetInstallDataModel;
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportDataModelProvider.java
index 6df0c8f..a749b68 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportOperation.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportOperation.java
index 3746c8d..2cb7bde 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentExportOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -41,7 +41,7 @@
 		} catch (SaveFailureException ex) {
 			throw ex;
 		} catch (Exception e) {
-			throw new SaveFailureException(AppClientArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_OpeningArchive"), e);//$NON-NLS-1$
+			throw new SaveFailureException(AppClientArchiveOpsResourceHandler.ARCHIVE_OPERATION_OpeningArchive, e);
 		}	}
 
 	protected String archiveString() {
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentImportDataModelProvider.java
index f616f59..8f9483a 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentImportDataModelProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.archive.operations;
 
 import java.util.ArrayList;
@@ -95,4 +97,4 @@
 		return new WebComponentImportOperation(model);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentLoadStrategyImpl.java
index faf2559..ca39260 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebComponentLoadStrategyImpl.java
@@ -53,21 +53,21 @@
 		IVirtualReference[] libModules = getLibModules();
 		for (int i = 0; i < libModules.length; i++) {
 			IVirtualReference iLibModule = libModules[i];
-			IVirtualComponent vComponent = iLibModule.getReferencedComponent();
-			if (vComponent.isBinary()) {
-				VirtualArchiveComponent archiveComp = (VirtualArchiveComponent) vComponent;
+			IVirtualComponent looseComponent = iLibModule.getReferencedComponent();
+			if (looseComponent.isBinary()) {
+				VirtualArchiveComponent archiveComp = (VirtualArchiveComponent) looseComponent;
 				java.io.File diskFile = archiveComp.getUnderlyingDiskFile();
-				String uri = iLibModule.getRuntimePath().toString() + "/" + diskFile.getName();
+				String uri = iLibModule.getRuntimePath().makeRelative().toString() + "/" + diskFile.getName(); //$NON-NLS-1$
 				addExternalFile(uri, diskFile);
 			} else {
-				String uri = iLibModule.getRuntimePath().toString() + "/" + vComponent.getName() + ".jar";
+				String uri = iLibModule.getRuntimePath().makeRelative().toString() + "/" + looseComponent.getName() + ".jar";  //$NON-NLS-1$//$NON-NLS-2$
 				try {
-					Archive utilJAR = J2EEProjectUtilities.asArchive(uri, vComponent.getProject(), isExportSource());
+					Archive utilJAR = J2EEProjectUtilities.asArchive(uri, looseComponent.getProject(), isExportSource());
 					if (utilJAR == null)
 						continue;
 					filesHolder.addFile(utilJAR);
 				} catch (OpenFailureException oe) {
-					String message = ProjectSupportResourceHandler.getString("UNABLE_TO_LOAD_MODULE_ERROR_", new Object[]{uri, getComponent().getProject().getName(), oe.getConcatenatedMessages()}); //$NON-NLS-1$
+					String message = ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.UNABLE_TO_LOAD_MODULE_ERROR_, new Object[]{uri, getComponent().getProject().getName(), oe.getConcatenatedMessages()}); //$NON-NLS-1$
 					org.eclipse.jem.util.logger.proxy.Logger.getLogger().logTrace(message);
 				}
 			}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebFacetProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebFacetProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..6e7bff1
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/archive/operations/WebFacetProjectCreationDataModelProvider.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal.web.archive.operations;
+
+import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
+import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.web.project.facet.IWebFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.web.project.facet.WebFacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class WebFacetProjectCreationDataModelProvider extends FacetProjectCreationDataModelProvider {
+
+	public WebFacetProjectCreationDataModelProvider() {
+		super();
+	}
+
+	public void init() {
+		super.init();
+		FacetDataModelMap map = (FacetDataModelMap) getProperty(FACET_DM_MAP);
+		IDataModel javaFacet = DataModelFactory.createDataModel(new JavaFacetInstallDataModelProvider());
+		map.add(javaFacet);
+		IDataModel webFacet = DataModelFactory.createDataModel(new WebFacetInstallDataModelProvider());
+		map.add(webFacet);
+		javaFacet.setProperty(IJavaFacetInstallDataModelProperties.SOURCE_FOLDER_NAME,webFacet.getStringProperty(IWebFacetInstallDataModelProperties.SOURCE_FOLDER));
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainer.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainer.java
index a75da86..d137018 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainer.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainer.java
@@ -50,7 +50,7 @@
     
     public String getDescription()
     {
-        return resource( "WEB_CONT_DESCRIPTION", this.component );
+        return WebMessages.getResourceString(WebMessages.WEB_CONT_DESCRIPTION, new String[] {this.component});
     }
     
     public void install()
@@ -99,11 +99,4 @@
         
         return false;
     }
-    
-    private static String resource( final String key,
-                                    final String arg )
-    {
-        return WebMessages.getResourceString( key, new String[] { arg } );
-    }
-    
 }
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainerInitializer.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainerInitializer.java
index aafcc76..a06f4ae 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainerInitializer.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppContainerInitializer.java
@@ -20,18 +20,31 @@
  * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
  */
 
-public final class WebAppContainerInitializer 
+public final class WebAppContainerInitializer
 
-    extends FlexibleProjectContainerInitializer
+extends FlexibleProjectContainerInitializer
 
 {
-    public void initialize( final IPath path,
-                            final IJavaProject jproj ) 
-    
-        throws CoreException
+	public void initialize(final IPath path, final IJavaProject jproj)
 
-    {
-        ( new WebAppContainer( path, jproj ) ).install();
-    }
+	throws CoreException
+
+	{
+//		WorkspaceJob job = new WorkspaceJob("Initializing Web Container") {
+//
+//			public IStatus runInWorkspace(IProgressMonitor monitor) {
+//				try {
+					new WebAppContainer(path, jproj).install();
+//				}
+//
+//				catch (Exception e) {
+//					return Status.CANCEL_STATUS;
+//				}
+//				return Status.OK_STATUS;
+//			}
+//		};
+//		job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
+//		job.schedule();
+	}
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/ProjectSupportResourceHandler.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/ProjectSupportResourceHandler.java
index cb94cc5..e3c57f1 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/ProjectSupportResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/ProjectSupportResourceHandler.java
@@ -1,63 +1,65 @@
-package org.eclipse.jst.j2ee.internal.web.operations;
-
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal.web.operations;
 
-public class ProjectSupportResourceHandler {
+import org.eclipse.osgi.util.NLS;
 
-	private static ResourceBundle fgResourceBundle;
+public class ProjectSupportResourceHandler extends NLS {
+	private static final String BUNDLE_NAME = "ProjectSupport";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("ProjectSupport");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String) will return the key
-			// it was called with
-		}
-		return null;
+	private ProjectSupportResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String Folder_name_cannot_be_the_same_as_Java_source_folder_5;
+	public static String Target_Update_Op;
+	public static String Operation_failed_due_to_SA_ERROR_;
+	public static String Creating_Web_Project____UI_;
+	public static String Update_ClassPath__UI_;
+	public static String Could_not_rename_____2;
+	public static String A_web_project_must_be_open_and_must_exist_for_properties_to_be_edited_30;
+	public static String Operation_failed_due_to_IO_ERROR_;
+	public static String Cannot_clone_TaglibInfo_1_EXC_;
+	public static String Syntax_Error_in_the_links_UI_;
+	public static String Sync_WLP_Op;
+	public static String Catalog_Lib_Directory__UI_;
+	public static String Generated_by_Web_Tooling_23;
+	public static String _1concat_EXC_;
+	public static String File_Serving_Enabler_7;
+	public static String Sychronize_Class_Path_UI_;
+	public static String Auto_Generated___File_Enabler_9;
+	public static String Not_a_web_project_29;
+	public static String Names_cannot_begin_or_end_with_whitespace_5;
+	public static String The_character_is_invalid_in_a_context_root;
+	public static String _24concat_INFO_;
+	public static String Folder_name_cannot_be_the_same_as_Java_class_folder_6;
+	public static String The_path_for_the_links_sta_EXC_;
+	public static String Operation_failed_due_to_Ja_ERROR_;
+	public static String Folder_name_cannot_be_empty_2;
+	public static String Error_importing_Module_Fil_EXC_;
+	public static String Operation_failed_due_to_Co_ERROR_;
+	public static String Folder_names_cannot_be_equal_4;
+	public static String Could_not_read_TLD_15;
+	public static String Folder_name_is_not_valid;
+	public static String Invalid_Servlet_Level_set_on_WebNature_3_EXC_;
+	public static String Set_ClassPath__UI_;
+	public static String Context_Root_cannot_be_empty_2;
+	public static String Error_while_saving_links_s_EXC_;
+	public static String UNABLE_TO_LOAD_MODULE_ERROR_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, ProjectSupportResourceHandler.class);
 	}
 
 	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
+		return NLS.bind(key, args);
 	}
-
-	public static String getString(String key, Object[] args, int x) {
-
-		return getString(key);
-	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/RelationData.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/RelationData.java
index 5e36d97..dcafff0 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/RelationData.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/RelationData.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -800,7 +800,7 @@
 						if (line != null) {
 							indices.addElement(line);
 						} else {
-							System.out.println(ProjectSupportResourceHandler.getString("Syntax_Error_in_the_links_UI_")); //$NON-NLS-1$ = "Syntax Error in the links state file"
+							System.out.println(ProjectSupportResourceHandler.Syntax_Error_in_the_links_UI_); //$NON-NLS-1$ = "Syntax Error in the links state file"
 							return false;
 						}
 					}
@@ -976,7 +976,7 @@
 				out.flush();
 				out.close();
 			} catch (IOException e) {
-				org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ProjectSupportResourceHandler.getString("Error_while_saving_links_s_EXC_")); //$NON-NLS-1$ = "Error while saving links state file"
+				org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ProjectSupportResourceHandler.Error_while_saving_links_s_EXC_); //$NON-NLS-1$ = "Error while saving links state file"
 			}
 		}
 	}
@@ -990,4 +990,4 @@
 	void setFileOk(boolean newFileOk) {
 		fileOk = newFileOk;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebPropertiesUtil.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebPropertiesUtil.java
index 1ae877a..15e5373 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebPropertiesUtil.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebPropertiesUtil.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.operations;
 
 import java.util.Enumeration;
@@ -75,7 +77,7 @@
 			if (getModuleServerRoot(project).getProjectRelativePath().equals(newPath))
 				return false;
 			if (project.exists(newPath)) {
-				IStatus status = new Status(IStatus.ERROR, "org.eclipse.jst.j2ee", IStatus.OK, ProjectSupportResourceHandler.getString("Could_not_rename_____2", new Object[]{webContentName}), null); //$NON-NLS-1$ //$NON-NLS-2$	
+				IStatus status = new Status(IStatus.ERROR, "org.eclipse.jst.j2ee", IStatus.OK, ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Could_not_rename_____2, new Object[]{webContentName}), null); //$NON-NLS-1$ //$NON-NLS-2$	
 				throw new CoreException(status);
 			}
 
@@ -193,7 +195,7 @@
 			if (monitor == null) {
 				monitor = new NullProgressMonitor();
 			}
-			monitor.beginTask(ProjectSupportResourceHandler.getString("Sychronize_Class_Path_UI_"), 4); //$NON-NLS-1$
+			monitor.beginTask(ProjectSupportResourceHandler.Sychronize_Class_Path_UI_, 4); //$NON-NLS-1$
 			//$NON-NLS-1$ = "Sychronize Class Path"
 
 			IContainer lib_folder = getWebLibFolder(project);
@@ -210,7 +212,7 @@
 			// Create a map of the lib projects in the current project
 			Hashtable lib_jars = new Hashtable();
 			IResource[] children = lib_folder.members();
-			monitor.subTask(ProjectSupportResourceHandler.getString("Catalog_Lib_Directory__UI_")); //$NON-NLS-1$
+			monitor.subTask(ProjectSupportResourceHandler.Catalog_Lib_Directory__UI_); //$NON-NLS-1$
 			//$NON-NLS-1$ = "Catalog Lib Directory:"
 			for (int j = 0; j < children.length; j++) {
 				IResource child = children[j];
@@ -225,7 +227,7 @@
 			}
 
 			monitor.worked(1);
-			monitor.subTask(ProjectSupportResourceHandler.getString("Update_ClassPath__UI_")); //$NON-NLS-1$
+			monitor.subTask(ProjectSupportResourceHandler.Update_ClassPath__UI_); //$NON-NLS-1$
 			//$NON-NLS-1$ = "Update ClassPath:"
 			// Loop through all the classpath dirs looking for ones that may have
 			// been deleted
@@ -250,13 +252,13 @@
 						needsToBeModified = true;
 					}
 				} else {
-					monitor.subTask(ProjectSupportResourceHandler.getString("Catalog_Lib_Directory__UI_") + cp[j].getPath()); //$NON-NLS-1$
+					monitor.subTask(ProjectSupportResourceHandler.Catalog_Lib_Directory__UI_ + cp[j].getPath()); //$NON-NLS-1$
 					//$NON-NLS-1$ = "Catalog Lib Directory:"
 					newClassPathVector.add(cp[j]);
 				}
 			}
 			monitor.worked(1);
-			monitor.subTask(ProjectSupportResourceHandler.getString("Update_ClassPath__UI_")); //$NON-NLS-1$
+			monitor.subTask(ProjectSupportResourceHandler.Update_ClassPath__UI_); //$NON-NLS-1$
 			//$NON-NLS-1$ = "Update ClassPath:"
 
 			// Add any entries not already found
@@ -272,7 +274,7 @@
 			}
 
 			monitor.worked(1);
-			monitor.subTask(ProjectSupportResourceHandler.getString("Set_ClassPath__UI_")); //$NON-NLS-1$
+			monitor.subTask(ProjectSupportResourceHandler.Set_ClassPath__UI_); //$NON-NLS-1$
 			//$NON-NLS-1$ = "Set ClassPath:"
 
 			// Tansfer the vector to an array
@@ -341,7 +343,7 @@
 		if (name.equals("") || name == null) { //$NON-NLS-1$
 			// this was added because the error message shouldnt be shown initially. It should be
 			// shown only if context root field is edited to
-			errorMessage = ProjectSupportResourceHandler.getString("Context_Root_cannot_be_empty_2"); //$NON-NLS-1$
+			errorMessage = ProjectSupportResourceHandler.Context_Root_cannot_be_empty_2; //$NON-NLS-1$
 			return errorMessage;
 		}
 
@@ -363,7 +365,7 @@
 							// ResourceHandler.getString("_Context_root_cannot_conta_UI_");//$NON-NLS-1$
 							// = " Context root cannot contain whitespaces."
 						} else {
-							errorMessage = ProjectSupportResourceHandler.getString("The_character_is_invalid_in_a_context_root", new Object[]{(new Character(token.charAt(i))).toString()}); //$NON-NLS-1$
+							errorMessage = ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.The_character_is_invalid_in_a_context_root, new Object[]{(new Character(token.charAt(i))).toString()}); //$NON-NLS-1$
 							break outer;
 						}
 					}
@@ -371,7 +373,7 @@
 			}
 		} // en/ end of if(name.trim
 		else
-			errorMessage = ProjectSupportResourceHandler.getString("Names_cannot_begin_or_end_with_whitespace_5"); //$NON-NLS-1$
+			errorMessage = ProjectSupportResourceHandler.Names_cannot_begin_or_end_with_whitespace_5; //$NON-NLS-1$
 
 		return errorMessage;
 	}
@@ -391,10 +393,10 @@
 
 	public static String validateFolderName(String folderName) {
 		if (folderName.length() == 0)
-			return ProjectSupportResourceHandler.getString("Folder_name_cannot_be_empty_2"); //$NON-NLS-1$
+			return ProjectSupportResourceHandler.Folder_name_cannot_be_empty_2; //$NON-NLS-1$
 
 		if (contains(folderName, BAD_CHARS))
-			return ProjectSupportResourceHandler.getString("Folder_name_is_not_valid", new Object[]{folderName}); //$NON-NLS-1$
+			return ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Folder_name_is_not_valid, new Object[]{folderName}); //$NON-NLS-1$
 
 		return null;
 	}
@@ -407,7 +409,7 @@
 			return msg;
 
 		if (javaSourceName != null && webContentName.equals(javaSourceName))
-			return ProjectSupportResourceHandler.getString("Folder_names_cannot_be_equal_4"); //$NON-NLS-1$
+			return ProjectSupportResourceHandler.Folder_names_cannot_be_equal_4; //$NON-NLS-1$
 
 		// If given a java project, check to make sure current package fragment
 		// root folders do not overlap with new web content name
@@ -425,9 +427,9 @@
 								String rootFolder = path.segment(1);
 								if (webContentName.equals(rootFolder)) {
 									if (root.getKind() == IPackageFragmentRoot.K_SOURCE)
-										return ProjectSupportResourceHandler.getString("Folder_name_cannot_be_the_same_as_Java_source_folder_5"); //$NON-NLS-1$
+										return ProjectSupportResourceHandler.Folder_name_cannot_be_the_same_as_Java_source_folder_5; //$NON-NLS-1$
 
-									return ProjectSupportResourceHandler.getString("Folder_name_cannot_be_the_same_as_Java_class_folder_6"); //$NON-NLS-1$
+									return ProjectSupportResourceHandler.Folder_name_cannot_be_the_same_as_Java_class_folder_6; //$NON-NLS-1$
 								}
 							}
 						}
@@ -575,4 +577,4 @@
 	// }
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebToolingException.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebToolingException.java
index 9594ca2..b6df10b 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebToolingException.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/operations/WebToolingException.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -23,10 +23,10 @@
  * The WebToolingException class is the generic class for exceptions generated by the web tooling.
  */
 public class WebToolingException extends Exception {
-	public static final String SAX_ERROR_MESSAGE = ProjectSupportResourceHandler.getString("Operation_failed_due_to_SA_ERROR_"); //$NON-NLS-1$ = "Operation failed due to SAX error: "
-	public static final String IO_ERROR_MESSAGE = ProjectSupportResourceHandler.getString("Operation_failed_due_to_IO_ERROR_"); //$NON-NLS-1$ = "Operation failed due to IO error: "
-	public static final String CORE_ERROR_MESSAGE = ProjectSupportResourceHandler.getString("Operation_failed_due_to_Co_ERROR_"); //$NON-NLS-1$ = "Operation failed due to Core error: "
-	public static final String JAVA_MODEL_ERROR_MESSAGE = ProjectSupportResourceHandler.getString("Operation_failed_due_to_Ja_ERROR_"); //$NON-NLS-1$ = "Operation failed due to Java Model error: "
+	public static final String SAX_ERROR_MESSAGE = ProjectSupportResourceHandler.Operation_failed_due_to_SA_ERROR_; //$NON-NLS-1$ = "Operation failed due to SAX error: "
+	public static final String IO_ERROR_MESSAGE = ProjectSupportResourceHandler.Operation_failed_due_to_IO_ERROR_; //$NON-NLS-1$ = "Operation failed due to IO error: "
+	public static final String CORE_ERROR_MESSAGE = ProjectSupportResourceHandler.Operation_failed_due_to_Co_ERROR_; //$NON-NLS-1$ = "Operation failed due to Core error: "
+	public static final String JAVA_MODEL_ERROR_MESSAGE = ProjectSupportResourceHandler.Operation_failed_due_to_Ja_ERROR_; //$NON-NLS-1$ = "Operation failed due to Java Model error: "
 
 	/**
 	 * Create a new WebToolingException with no message.
@@ -95,4 +95,4 @@
 	public WebToolingException(SAXException exception) {
 		this(SAX_ERROR_MESSAGE, exception);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebArtifactEditUtilities.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebArtifactEditUtilities.java
index ba11378..be022f8 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebArtifactEditUtilities.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebArtifactEditUtilities.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.util;
 
 import org.eclipse.core.resources.IProject;
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebEditAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebEditAdapterFactory.java
index 242ea7d..d954a9c 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebEditAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/util/WebEditAdapterFactory.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.web.util;
 
 import org.eclipse.core.runtime.IAdapterFactory;
@@ -46,4 +48,4 @@
 	public Class[] getAdapterList() {
 		return new Class[]{ArtifactEdit.class, WebArtifactEdit.class};
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/componentcore/util/WebArtifactEdit.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/componentcore/util/WebArtifactEdit.java
index fdc0d8c..af8c67c 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/componentcore/util/WebArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/componentcore/util/WebArtifactEdit.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.web.componentcore.util;
 
 import java.util.ArrayList;
@@ -99,10 +101,18 @@
 	 * @param toAccessAsReadOnly
 	 * @throws IllegalArgumentException
 	 */
-	protected WebArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
+	public WebArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
 		super(aProject, toAccessAsReadOnly, forCreate, J2EEProjectUtilities.DYNAMIC_WEB);
 	}
-
+	
+	/**
+	 * @param aHandle
+	 * @param toAccessAsReadOnly
+	 * @throws IllegalArgumentException
+	 */
+	protected WebArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate, String editModelID) throws IllegalArgumentException {
+		super(aProject, toAccessAsReadOnly, forCreate, editModelID);
+	}
 
 	/**
 	 * <p>
@@ -609,4 +619,4 @@
 			webEdit.dispose();
 		} 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentCreationDataModelProperties.java
index c065c68..bcf1661 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentCreationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentExportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentExportDataModelProperties.java
index 938f8d4..129150d 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentExportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentExportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentImportDataModelProperties.java
index 07a7831..94cc033 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/datamodel/properties/IWebComponentImportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/IWebFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/IWebFacetInstallDataModelProperties.java
index 5a14ed9..f779cb8 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/IWebFacetInstallDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/IWebFacetInstallDataModelProperties.java
@@ -10,17 +10,15 @@
  *******************************************************************************/
 package org.eclipse.jst.j2ee.web.project.facet;
 
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
 
 
 
-public interface IWebFacetInstallDataModelProperties extends IJ2EEFacetInstallDataModelProperties {
+public interface IWebFacetInstallDataModelProperties extends IJ2EEModuleFacetInstallDataModelProperties {
 
 
-	public static final String CONTEXT_ROOT = "IWebFacetInstallDataModelProperties.CONTEXT_ROOT";
+	public static final String CONTEXT_ROOT = "IWebFacetInstallDataModelProperties.CONTEXT_ROOT"; //$NON-NLS-1$
 	
-	public static final String CONTENT_DIR ="IWebFacetInstallDataModelProperties.CONTENT_DIR";
-	
-	public static final String CREATE_WEB_INF_SRC = "IWebFacetInstallDataModelProperties.CREATE_WEB_INF_SRC";
+	public static final String SOURCE_FOLDER = "IWebFacetInstallDataModelProperties.SOURCE_FOLDER"; //$NON-NLS-1$
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDataModelProvider.java
index 617f07c..849e0cb 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDataModelProvider.java
@@ -11,32 +11,96 @@
 package org.eclipse.jst.j2ee.web.project.facet;
 
 import java.util.Set;
+import java.util.StringTokenizer;
 
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
-import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.internal.project.ProjectSupportResourceHandler;
+import org.eclipse.jst.j2ee.project.facet.J2EEModuleFacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
-public class WebFacetInstallDataModelProvider extends FacetInstallDataModelProvider implements IWebFacetInstallDataModelProperties {
+public class WebFacetInstallDataModelProvider extends J2EEModuleFacetInstallDataModelProvider implements IWebFacetInstallDataModelProperties {
 
 	public Set getPropertyNames() {
 		Set names = super.getPropertyNames();
-		names.add(EAR_PROJECT_NAME);
 		names.add(CONTEXT_ROOT);
-		names.add(CONTENT_DIR);
-		names.add(CREATE_WEB_INF_SRC);
-		names.add(RUNTIME_TARGET_ID);
+		names.add(SOURCE_FOLDER);
 		return names;
 	}
-	
+
 	public Object getDefaultProperty(String propertyName) {
-		if(propertyName.equals(CONTENT_DIR)){
-			return "WebContent";
-		} else if(propertyName.equals(CREATE_WEB_INF_SRC)){
+		if (propertyName.equals(ADD_TO_EAR)) {
 			return Boolean.FALSE;
-		} else if(propertyName.equals(CONTEXT_ROOT)){
+		} else if (propertyName.equals(CONFIG_FOLDER)) {
+			return "WebContent";
+		} else if (propertyName.equals(SOURCE_FOLDER)) {
+			return "src";
+		} else if (propertyName.equals(CONTEXT_ROOT)) {
 			return getProperty(FACET_PROJECT_NAME);
-		} else if(propertyName.equals(FACET_ID)){
+		} else if (propertyName.equals(FACET_ID)) {
 			return J2EEProjectUtilities.DYNAMIC_WEB;
 		}
 		return super.getDefaultProperty(propertyName);
 	}
+
+	public boolean propertySet(String propertyName, Object propertyValue) {
+		if (ADD_TO_EAR.equals(propertyName)) {
+			model.notifyPropertyChange(CONTEXT_ROOT, IDataModel.ENABLE_CHG);
+		} else if (FACET_PROJECT_NAME.equals(propertyName)) {
+			model.notifyPropertyChange(CONTEXT_ROOT, IDataModel.VALID_VALUES_CHG);
+		} else if (propertyName.equals(CONFIG_FOLDER)) {
+			return true;
+		} else if (propertyName.equals(SOURCE_FOLDER)) {
+			IDataModel masterModel = (IDataModel) model.getProperty(MASTER_PROJECT_DM);
+			if (masterModel != null) {
+				FacetDataModelMap map = (FacetDataModelMap) masterModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+				IDataModel javaModel = map.getFacetDataModel(IModuleConstants.JST_JAVA);
+				if (javaModel != null)
+					javaModel.setProperty(IJavaFacetInstallDataModelProperties.SOURCE_FOLDER_NAME, propertyValue);
+			}
+		}
+		return super.propertySet(propertyName, propertyValue);
+	}
+
+	public boolean isPropertyEnabled(String propertyName) {
+		return super.isPropertyEnabled(propertyName);
+	}
+
+	protected int convertFacetVersionToJ2EEVersion(IProjectFacetVersion version) {
+		return J2EEVersionUtil.convertWebVersionStringToJ2EEVersionID(version.getVersionString());
+	}
+
+	public IStatus validate(String name) {
+		if (name.equals(CONTEXT_ROOT) && getBooleanProperty(ADD_TO_EAR)) {
+			return validateContextRoot(getStringProperty(CONTEXT_ROOT));
+		}
+		return super.validate(name);
+	}
+
+	protected IStatus validateContextRoot(String contextRoot) {
+		if (contextRoot.equals("") || contextRoot == null) { //$NON-NLS-1$
+			return J2EEPlugin.newErrorStatus(ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Context_Root_cannot_be_empty_2, new Object[]{contextRoot}), null); //$NON-NLS-1$
+		} else if (contextRoot.trim().equals(contextRoot)) {
+			StringTokenizer stok = new StringTokenizer(contextRoot, "."); //$NON-NLS-1$
+			while (stok.hasMoreTokens()) {
+				String token = stok.nextToken();
+				for (int i = 0; i < token.length(); i++) {
+					if (!(token.charAt(i) == '_') && !(token.charAt(i) == '-') && !(token.charAt(i) == '/') && Character.isLetterOrDigit(token.charAt(i)) == false) {
+						Object[] invalidChar = new Object[]{(new Character(token.charAt(i))).toString()};
+						String errorStatus = ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.The_character_is_invalid_in_a_context_root, invalidChar); //$NON-NLS-1$
+						return J2EEPlugin.newErrorStatus(errorStatus, null);
+					}
+				}
+			}
+		} else
+			return J2EEPlugin.newErrorStatus(ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Names_cannot_begin_or_end_with_whitespace_5, new Object[]{contextRoot}), null); //$NON-NLS-1$
+		return OK_STATUS;
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDelegate.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDelegate.java
index 70c3f21..adcd1ef 100644
--- a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetInstallDelegate.java
@@ -12,7 +12,9 @@
 package org.eclipse.jst.j2ee.web.project.facet;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IFolder;
@@ -23,25 +25,35 @@
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
+import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.project.facet.WtpUtils;
+import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
+import org.eclipse.jst.j2ee.application.ApplicationPackage;
+import org.eclipse.jst.j2ee.application.Module;
 import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationDataModelProvider;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationOp;
+import org.eclipse.jst.j2ee.application.internal.operations.IAddComponentToEnterpriseApplicationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.jst.j2ee.project.facet.J2EEFacetInstallDelegate;
 import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
-import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
 import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.FacetDataModelProvider;
 import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 
 public final class WebFacetInstallDelegate extends J2EEFacetInstallDelegate implements IDelegate {
 
@@ -54,7 +66,7 @@
 		}
 
 		try {
-			IDataModel model = (IDataModel) cfg;
+			final IDataModel model = (IDataModel) cfg;
 
 			final IJavaProject jproj = JavaCore.create(project);
 
@@ -67,7 +79,8 @@
 			final IWorkspace ws = ResourcesPlugin.getWorkspace();
 			final IPath pjpath = project.getFullPath();
 
-			final IPath contentdir = pjpath.append(model.getStringProperty(IWebFacetInstallDataModelProperties.CONTENT_DIR));
+			final IPath contentdir = setContentPropertyIfNeeded(model, pjpath, project);
+			final IPath sourcedir = setSourcePropertyIfNeeded(model, pjpath, project);
 			mkdirs(ws.getRoot().getFolder(contentdir));
 
 			final IPath webinf = contentdir.append("WEB-INF");
@@ -77,22 +90,16 @@
 			final IPath webinflib = webinf.append("lib");
 			mkdirs(ws.getRoot().getFolder(webinflib));
 
+
+
 			try {
-				createManifest(project, model.getStringProperty(IWebFacetInstallDataModelProperties.CONTENT_DIR), monitor);
+				createManifest(project, ws.getRoot().getFolder(contentdir), monitor);
 			} catch (InvocationTargetException e) {
 				Logger.getLogger().logError(e);
 			} catch (InterruptedException e) {
 				Logger.getLogger().logError(e);
 			}
 
-			// Setup WEB-INF/src, if necessary.
-
-			if (model.getBooleanProperty(IWebFacetInstallDataModelProperties.CREATE_WEB_INF_SRC)) {
-				final IPath webinfsrc = webinf.append("src");
-				mkdirs(ws.getRoot().getFolder(webinfsrc));
-
-				addToClasspath(jproj, JavaCore.newSourceEntry(webinfsrc));
-			}
 
 			// Setup the flexible project structure.
 
@@ -100,22 +107,11 @@
 
 			c.create(0, null);
 
-			// final ComponentType ctype = ComponentcoreFactory.eINSTANCE.createComponentType();
-			//
-			// ctype.setComponentTypeId(IModuleConstants.JST_WEB_MODULE);
-			// ctype.setVersion(fv.getVersionString());
-
-			c.setMetaProperty("context-root", model.getStringProperty(IWebFacetInstallDataModelProperties.CONTEXT_ROOT));
-			c.setMetaProperty("java-output-path", "/build/classes/");
-
-			// final StructureEdit edit = StructureEdit.getStructureEditForWrite(project);
-			//
-			// try {
-			// StructureEdit.setComponentType(c, ctype);
-			// edit.saveIfNecessary(null);
-			// } finally {
-			// edit.dispose();
-			// }
+			String contextRoot = model.getStringProperty(IWebFacetInstallDataModelProperties.CONTEXT_ROOT);
+			if (contextRoot == null || contextRoot.length() == 0)
+				contextRoot = project.getName();
+			setContextRootPropertyIfNeeded(c, contextRoot);
+			setJavaOutputPropertyIfNeeded(c);
 
 			final IVirtualFolder jsrc = c.getRootFolder().getFolder("/WEB-INF/classes");
 			final IClasspathEntry[] cp = jproj.getRawClasspath();
@@ -129,8 +125,8 @@
 			}
 
 			final IVirtualFolder webroot = c.getRootFolder();
-
-			webroot.createLink(new Path("/" + model.getStringProperty(IWebFacetInstallDataModelProperties.CONTENT_DIR)), 0, null);
+			if (webroot.getProjectRelativePath().equals(new Path("/")))
+				webroot.createLink(new Path("/" + model.getStringProperty(IWebFacetInstallDataModelProperties.CONFIG_FOLDER)), 0, null);
 
 			// Create the deployment descriptor (web.xml) if one doesn't exist
 			if (!webinfFolder.getFile("web.xml").exists()) {
@@ -156,39 +152,99 @@
 
 			// Associate with an EAR, if necessary.
 
-			final String earProjectName = model.getStringProperty(IWebFacetInstallDataModelProperties.EAR_PROJECT_NAME);
 
-			if (earProjectName != null && !earProjectName.equals("")) { //$NON-NLS-1$
-				String ver = fv.getVersionString();
-				String j2eeVersionText = J2EEVersionUtil.convertVersionIntToString(J2EEVersionUtil.convertWebVersionStringToJ2EEVersionID(ver));
-				installEARFacet(j2eeVersionText, earProjectName, monitor);
-                
-                IProject earProject = ProjectUtilities.getProject( earProjectName );
-                IVirtualComponent earComp = ComponentCore.createComponent( earProject );
-                
-                IDataModel dataModel = DataModelFactory.createDataModel( new AddComponentToEnterpriseApplicationDataModelProvider());
-                dataModel.setProperty( ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp );
-                List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
-                modList.add(c);
-                dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
-                try {
-                    dataModel.getDefaultOperation().execute(null, null);
-                } catch (ExecutionException e) {
-                    Logger.getLogger().logError(e);
-                }
+			if (model.getBooleanProperty(IWebFacetInstallDataModelProperties.ADD_TO_EAR)) {
+				final String earProjectName = model.getStringProperty(IWebFacetInstallDataModelProperties.EAR_PROJECT_NAME);
+				if (earProjectName != null && !earProjectName.equals("")) { //$NON-NLS-1$
+					String ver = fv.getVersionString();
+					String j2eeVersionText = J2EEVersionUtil.convertVersionIntToString(J2EEVersionUtil.convertWebVersionStringToJ2EEVersionID(ver));
+					IFacetedProject facetedProject = ProjectFacetsManager.create(project);
+					installEARFacet(j2eeVersionText, earProjectName, facetedProject.getRuntime(), monitor);
+
+					IProject earProject = ProjectUtilities.getProject(earProjectName);
+					IVirtualComponent earComp = ComponentCore.createComponent(earProject);
+
+					final IDataModel dataModel = DataModelFactory.createDataModel(new AddComponentToEnterpriseApplicationDataModelProvider() {
+						public Object getDefaultProperty(String propertyName) {
+							if (IAddComponentToEnterpriseApplicationDataModelProperties.TARGET_COMPONENTS_TO_URI_MAP.equals(propertyName)) {
+								Map map = new HashMap();
+								List components = (List) getProperty(TARGET_COMPONENT_LIST);
+								for (int i = 0; i < components.size(); i++) {
+									IVirtualComponent component = (IVirtualComponent) components.get(i);
+									String name = component.getName();
+									name += ".war"; //$NON-NLS-1$
+									map.put(component, name);
+								}
+								return map;
+							}
+							return super.getDefaultProperty(propertyName);
+						}
+
+						public IDataModelOperation getDefaultOperation() {
+							return new AddComponentToEnterpriseApplicationOp(model) {
+								protected Module createNewModule(IVirtualComponent wc) {
+									return ((ApplicationPackage) EPackage.Registry.INSTANCE.getEPackage(ApplicationPackage.eNS_URI)).getApplicationFactory().createWebModule();
+								}
+							};
+						}
+					});
+					dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp);
+					List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+					modList.add(c);
+					dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
+					try {
+						dataModel.getDefaultOperation().execute(null, null);
+					} catch (ExecutionException e) {
+						Logger.getLogger().logError(e);
+					}
+
+				}
+			}
+
+			try {
+				((IDataModelOperation) model.getProperty(FacetDataModelProvider.NOTIFICATION_OPERATION)).execute(monitor, null);
+			} catch (ExecutionException e) {
+				Logger.getLogger().logError(e);
 			}
 
 			if (monitor != null) {
 				monitor.worked(1);
 			}
-		}
-		finally {
+		} finally {
 			if (monitor != null) {
 				monitor.done();
 			}
 		}
 	}
 
+	private void setJavaOutputPropertyIfNeeded(final IVirtualComponent c) {
+		String existing = c.getMetaProperties().getProperty("java-output-path");
+		if (existing == null)
+			c.setMetaProperty("java-output-path", "/build/classes/");
+	}
+
+	private void setContextRootPropertyIfNeeded(final IVirtualComponent c, String contextRoot) {
+		String existing = c.getMetaProperties().getProperty("context-root");
+		if (existing == null)
+			c.setMetaProperty("context-root", contextRoot);
+	}
+
+	private IPath setSourcePropertyIfNeeded(final IDataModel model, final IPath pjpath, IProject project) {
+		IVirtualComponent c = ComponentCore.createComponent(project);
+		if (c.exists()) {
+			return J2EEProjectUtilities.getSourcePathOrFirst(project, null).makeAbsolute();
+		}
+		return pjpath.append(model.getStringProperty(IWebFacetInstallDataModelProperties.SOURCE_FOLDER));
+	}
+
+	private IPath setContentPropertyIfNeeded(final IDataModel model, final IPath pjpath, IProject project) {
+		IVirtualComponent c = ComponentCore.createComponent(project);
+		if (c.exists()) {
+			return c.getRootFolder().getUnderlyingResource().getFullPath();
+		}
+		return pjpath.append(model.getStringProperty(IWebFacetInstallDataModelProperties.CONFIG_FOLDER));
+	}
+
 	private static void addToClasspath(final IJavaProject jproj, final IClasspathEntry entry)
 
 	throws CoreException
@@ -200,6 +256,7 @@
 		updated[current.length] = entry;
 		jproj.setRawClasspath(updated, null);
 	}
+
 	private static void mkdirs(final IFolder folder)
 
 	throws CoreException
diff --git a/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetUtils.java b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetUtils.java
new file mode 100644
index 0000000..d883271
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/web/project/facet/WebFacetUtils.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.web.project.facet;
+
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+
+public class WebFacetUtils {
+
+	public static final IProjectFacetVersion WEB_22 = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_WEB_MODULE).getVersion("2.2"); //$NON-NLS-1$
+	public static final IProjectFacetVersion WEB_23 = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_WEB_MODULE).getVersion("2.3"); //$NON-NLS-1$
+	public static final IProjectFacetVersion WEB_24 = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_WEB_MODULE).getVersion("2.4"); //$NON-NLS-1$
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/.cvsignore b/plugins/org.eclipse.jst.j2ee.webservice.ui/.cvsignore
index f06198c..49af781 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/.cvsignore
@@ -4,3 +4,4 @@
 servletui.jar
 webserviceui.jar
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/.project b/plugins/org.eclipse.jst.j2ee.webservice.ui/.project
index ed8635f..1b17773 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/.project
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/.project
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>org.eclipse.jst.j2ee.webservices.ui</name>
+	<name>org.eclipse.jst.j2ee.webservice.ui</name>
 	<comment></comment>
 	<projects>
 	</projects>
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.j2ee.webservice.ui/META-INF/MANIFEST.MF
index 7caad8a..0324853 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/META-INF/MANIFEST.MF
@@ -1,7 +1,7 @@
 Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: WTP Webservice UI Plug-in
-Bundle-SymbolicName: org.eclipse.jst.j2ee.webservices.ui; singleton:=true
+Bundle-SymbolicName: org.eclipse.jst.j2ee.webservice.ui; singleton:=true
 Bundle-Version: 1.0.0
 Bundle-Activator: org.eclipse.jst.j2ee.internal.webservice.plugin.WebServiceUIPlugin
 Bundle-Vendor: Eclipse.org
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/build.properties b/plugins/org.eclipse.jst.j2ee.webservice.ui/build.properties
index a648102..e0ae1a0 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/build.properties
@@ -1,3 +1,13 @@
+###############################################################################
+# Copyright (c) 2005 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
 source.. = property_files/,\
                           webservices_ui/
 output.. = bin/
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/plugin.xml b/plugins/org.eclipse.jst.j2ee.webservice.ui/plugin.xml
index 3fa058e..da19dfa 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/plugin.xml
@@ -40,14 +40,6 @@
    
    <!-- J2EE View Web Services contribution -->
    
- <!-- <extension
-         point="org.eclipse.wst.common.navigator.views.navigatorViewer">
-      <navigatorViewer
-            rootContentExtensionId="org.eclipse.wst.common.frameworks.internal.navigator.webservice"
-            viewerId="org.eclipse.wst.navigator.ui.WTPCommonNavigator">
-      </navigatorViewer>
-   </extension> -->
-   
    <extension
          point="org.eclipse.wst.common.navigator.views.navigatorViewer">
       <navigatorViewer
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/property_files/webserviceui.properties b/plugins/org.eclipse.jst.j2ee.webservice.ui/property_files/webserviceui.properties
index b803c30..8af63ed 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/property_files/webserviceui.properties
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/property_files/webserviceui.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -43,4 +43,4 @@
 HANDLER_UI_=Handler:
 WSDL_PORT_UI_=WSDL Port:
 SERVICE_IMPL_UI_=ServiceImpl:
-WSDL_UI_=WSDL:
\ No newline at end of file
+WSDL_UI_=WSDL:
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/OpenExternalWSDLAction.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/OpenExternalWSDLAction.java
index a9c74d0..3d768c3 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/OpenExternalWSDLAction.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/OpenExternalWSDLAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -56,4 +56,4 @@
 			uri = ((Resource) obj).getURI().toString();
 		return super.updateSelection(s);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceAdapterFactory.java
index 73c45d5..c3b8aab 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -60,4 +60,4 @@
 		else
 			return super.getAdapter(adaptableObject, adapterType);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceFilesContribution.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceFilesContribution.java
index cc6a61c..37f0a65 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceFilesContribution.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceFilesContribution.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -47,7 +47,7 @@
 	 * @see java.lang.Object#toString()
 	 */
 	public String toString() {
-		return WebServiceUIResourceHandler.getString("WebServiceFilesContribution_UI_0"); //$NON-NLS-1$
+		return WebServiceUIResourceHandler.WebServiceFilesContribution_UI_0; 
 	}
 
 	public String getWSDLFile() {
@@ -74,4 +74,4 @@
 		return webService;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroup.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroup.java
index 4878ef1..665e515 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroup.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroup.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -27,7 +27,7 @@
  */
 public class WebServiceNavigatorGroup {
 
-	private String label = WebServiceUIResourceHandler.getString("WebServiceNavigatorGroup_UI_0"); //$NON-NLS-1$
+	private String label = WebServiceUIResourceHandler.WebServiceNavigatorGroup_UI_0; 
 	private IWorkspaceRoot root;
 
 	/**
@@ -60,4 +60,4 @@
 		this.root = root;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroupType.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroupType.java
index 19eb6f9..adfd94b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroupType.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceNavigatorGroupType.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -32,9 +32,9 @@
 	public static final int CLIENTS = 2;
 	public static final int HANDLERS = 3;
 
-	public static final String SERVICES_UI = WebServiceUIResourceHandler.getString("WebServiceNavigatorGroupType_UI_0"); //$NON-NLS-1$
-	public static final String CLIENTS_UI = WebServiceUIResourceHandler.getString("WebServiceNavigatorGroupType_UI_1"); //$NON-NLS-1$
-	public static final String HANDLERS_UI = WebServiceUIResourceHandler.getString("WebServiceNavigatorGroupType_UI_2"); //$NON-NLS-1$
+	public static final String SERVICES_UI = WebServiceUIResourceHandler.WebServiceNavigatorGroupType_UI_0; 
+	public static final String CLIENTS_UI = WebServiceUIResourceHandler.WebServiceNavigatorGroupType_UI_1; 
+	public static final String HANDLERS_UI = WebServiceUIResourceHandler.WebServiceNavigatorGroupType_UI_2; 
 
 	private int TYPE;
 	private EObject wsdlService = null;
@@ -130,4 +130,4 @@
 	public ServiceRef getServiceRef() {
 		return serviceRef;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceUIResourceHandler.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceUIResourceHandler.java
index 8cc1ca3..ea5227f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceUIResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServiceUIResourceHandler.java
@@ -1,65 +1,63 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-/*
- * Created on Feb 27, 2004
  *
- * To change the template for this generated file go to
- * Window - Preferences - Java - Code Generation - Code and Comments
- */
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-/**
- * @author jialin
- * 
- * To change the template for this generated type comment go to Window - Preferences - Java - Code
- * Generation - Code and Comments
- */
-public class WebServiceUIResourceHandler {
+public final class WebServiceUIResourceHandler extends NLS {
 
-	private static ResourceBundle fgResourceBundle;
+	private static final String BUNDLE_NAME = "webserviceui";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("webserviceui");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private WebServiceUIResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String NEW_BUTTON_LABEL;
+	public static String NEW_HANDLER_WIZARD_WINDOW_TITLE;
+	public static String NEW_HANDLER_WIZARD_PAGE_TITLE;
+	public static String NEW_HANDLER_WIZARD_PAGE_DESC;
+	public static String HANDLER_DISPLAY_NAME_LABEL;
+	public static String HANDLER_DESCRIPTION_LABEL;
+	public static String HANDLER_NAME_LABEL;
+	public static String HANDLER_CLASS_NAME_LABEL;
+	public static String HANDLER_INIT_PARAM_WIZARD_WINDOW_TITLE;
+	public static String HANDLER_INIT_PARAM_WIZARD_PAGE_TITLE;
+	public static String HANDLER_INIT_PARAM_WIZARD_PAGE_DESC;
+	public static String HANDLER_SOAP_HEADER_WIZARD_WINDOW_TITLE;
+	public static String HANDLER_SOAP_HEADER_WIZARD_PAGE_TITLE;
+	public static String HANDLER_SOAP_HEADER_WIZARD_PAGE_DESC;
+	public static String HANDLER_NAMESPACE_URL_LABEL;
+	public static String HANDLER_LOCAL_PART_LABEL;
+	public static String PortComponentRefLabelProvider_UI_1;
+	public static String PortComponentRefLabelProvider_UI_2;
+	public static String WebServiceNavigatorGroupType_UI_0;
+	public static String WebServiceNavigatorGroupType_UI_1;
+	public static String WebServiceNavigatorGroupType_UI_2;
+	public static String WebServiceFilesContribution_UI_0;
+	public static String WebServiceGroupContentExtension_UI_1;
+	public static String WebServiceNavigatorGroup_UI_0;
+	public static String Server_Invalid_For_Exisitng_EAR_UI_;
+	public static String ServiceReferenceSelectionWizard_UI_6;
+	public static String ServiceReferenceSelectionWizard_UI_7;
+	public static String ServiceReferenceSelectionPage_UI_0;
+	public static String ServiceReferenceSelectionPage_UI_1;
+	public static String ServiceReferenceSelectionPage_UI_2;
+	public static String SERVICE_CLASSES_UI_;
+	public static String PORT_UI_;
+	public static String HANDLER_UI_;
+	public static String WSDL_PORT_UI_;
+	public static String SERVICE_IMPL_UI_;
+	public static String WSDL_UI_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, WebServiceUIResourceHandler.class);
 	}
-
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorContentProvider.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorContentProvider.java
index 94a89e6..5471539 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorContentProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorContentProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -292,4 +292,4 @@
 	public TreeViewer getViewer() {
 		return viewer;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorGroupOpenListener.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorGroupOpenListener.java
index 874c4c9..23607b3 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorGroupOpenListener.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorGroupOpenListener.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 10, 2005
  *
@@ -34,7 +44,7 @@
  */
 public class WebServicesNavigatorGroupOpenListener implements IOpenListener {
 
-	private OpenExternalWSDLAction openExternalWSDLAction = new OpenExternalWSDLAction(WebServiceUIResourceHandler.getString("WebServiceGroupContentExtension_UI_1")); //$NON-NLS-1$
+	private OpenExternalWSDLAction openExternalWSDLAction = new OpenExternalWSDLAction(WebServiceUIResourceHandler.WebServiceGroupContentExtension_UI_1); 
 	private OpenJ2EEResourceAction openAction = new OpenJ2EEResourceAction();
 	
 	/* (non-Javadoc)
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorLabelProvider.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorLabelProvider.java
index 4bb527a..5f1d285 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorLabelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorLabelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -97,17 +97,17 @@
 		if (element instanceof WebServiceDescription)
 			return getWebServiceDescriptionText((WebServiceDescription) element);
 		else if (element instanceof PortComponent)
-			return WebServiceUIResourceHandler.getString("PORT_UI_") + space + super.getText(element); //$NON-NLS-1$
+			return WebServiceUIResourceHandler.PORT_UI_ + space + super.getText(element); 
 		else if (element instanceof Handler)
-			return WebServiceUIResourceHandler.getString("HANDLER_UI_") + space + super.getText(element); //$NON-NLS-1$
+			return WebServiceUIResourceHandler.HANDLER_UI_ + space + super.getText(element); 
 		else if (element instanceof WSDLPort)
-			return WebServiceUIResourceHandler.getString("WSDL_PORT_UI_") + space + super.getText(element); //$NON-NLS-1$
+			return WebServiceUIResourceHandler.WSDL_PORT_UI_ + space + super.getText(element); 
 		else if (element instanceof ServiceImplBean)
-			return WebServiceUIResourceHandler.getString("SERVICE_CLASSES_UI_"); //$NON-NLS-1$
+			return WebServiceUIResourceHandler.SERVICE_CLASSES_UI_; 
 		else if (element instanceof EJBLink)
-			return WebServiceUIResourceHandler.getString("SERVICE_IMPL_UI_") + space + super.getText(element); //$NON-NLS-1$
+			return WebServiceUIResourceHandler.SERVICE_IMPL_UI_ + space + super.getText(element); 
 		else if (element instanceof ServletLink)
-			return WebServiceUIResourceHandler.getString("SERVICE_IMPL_UI_") + space + super.getText(element); //$NON-NLS-1$
+			return WebServiceUIResourceHandler.SERVICE_IMPL_UI_ + space + super.getText(element); 
 		else if (serviceHelper.isService(element))
 			return serviceHelper.getServiceLocalPart(element);
 		else if (serviceHelper.isWSDLResource(element)) {
@@ -117,7 +117,7 @@
 				result = file.getFullPath().toString();
 			else
 				result = ((Resource) element).getURI().toString();
-			return WebServiceUIResourceHandler.getString("WSDL_UI_") + space + result; //$NON-NLS-1$
+			return WebServiceUIResourceHandler.WSDL_UI_ + space + result; 
 		} else if (element instanceof ServiceRef) {
 			String beanName14 = ""; //$NON-NLS-1$
 			if (WebServicesManager.getInstance().isJ2EE14((ServiceRef) element)) {
@@ -186,4 +186,4 @@
 
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorSynchronizer.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorSynchronizer.java
index 91f3a59..66be80f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorSynchronizer.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WebServicesNavigatorSynchronizer.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -102,4 +102,4 @@
 		}
 		super.notifyChanged(notification);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WsdlResourceAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WsdlResourceAdapterFactory.java
index c5e3a0f..06c866b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WsdlResourceAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/WsdlResourceAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -58,4 +58,4 @@
 		else
 			return super.getAdapter(adaptableObject, adapterType);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServiceUIPlugin.java b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServiceUIPlugin.java
index 4fd51a0..19bd202 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServiceUIPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice.ui/webservices_ui/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServiceUIPlugin.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Nov 15, 2004
  *
@@ -18,7 +28,7 @@
  */
 public class WebServiceUIPlugin extends AbstractUIPlugin {
 	
-	public static final String PLUGIN_ID = "org.eclipse.jst.j2ee.webservices.ui"; //$NON-NLS-1$
+	public static final String PLUGIN_ID = "org.eclipse.jst.j2ee.webservice.ui"; //$NON-NLS-1$
 	
 	//	The shared instance.
 	private static WebServiceUIPlugin plugin;
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/.cvsignore b/plugins/org.eclipse.jst.j2ee.webservice/.cvsignore
index 85e29b8..14417fe 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee.webservice/.cvsignore
@@ -3,3 +3,4 @@
 build.xml
 webservice.jar
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/build.properties b/plugins/org.eclipse.jst.j2ee.webservice/build.properties
index 9d323b1..f40d5ee 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/build.properties
+++ b/plugins/org.eclipse.jst.j2ee.webservice/build.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/component.xml b/plugins/org.eclipse.jst.j2ee.webservice/component.xml
index 850b6ad..780cb13 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/component.xml
+++ b/plugins/org.eclipse.jst.j2ee.webservice/component.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><component  xmlns="http://eclipse.org/wtp/releng/tools/component-model" name="org.eclipse.jst.j2ee.webservice"><component-depends unrestricted="true"></component-depends><plugin id="org.eclipse.jst.j2ee.webservice" fragment="false"/><plugin id="org.eclipse.jst.j2ee.webservices.ui" fragment="false"/></component>
\ No newline at end of file
+<?xml version="1.0" encoding="UTF-8"?><component  xmlns="http://eclipse.org/wtp/releng/tools/component-model" name="org.eclipse.jst.j2ee.webservice"><component-depends unrestricted="true"></component-depends><plugin id="org.eclipse.jst.j2ee.webservice" fragment="false"/><plugin id="org.eclipse.jst.j2ee.webservice.ui" fragment="false"/></component>
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/plugin.properties b/plugins/org.eclipse.jst.j2ee.webservice/plugin.properties
index 8a9695e..d783f2f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/plugin.properties
+++ b/plugins/org.eclipse.jst.j2ee.webservice/plugin.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/plugin.xml b/plugins/org.eclipse.jst.j2ee.webservice/plugin.xml
index 2a3952e..6605628 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee.webservice/plugin.xml
@@ -2,7 +2,6 @@
 <?eclipse version="3.0"?>
 <plugin>
 
-    
 <!--  Dyanmic Content Provider extensions -->
    <extension
          point="org.eclipse.wst.common.emfworkbench.integration.adapterFactory">
@@ -95,15 +94,6 @@
       </editModelExtension>
    </extension>
 
-<!-- ========================================================================== -->
-<!-- @deprecated: Extension point: org.eclipse.jst.j2ee.internal.webservice.atk.ui.webserviceseditmodel -->
-<!-- ========================================================================== -->
-   <extension-point id="webserviceseditmodelcontainer" name="%EDITOR_EDITMODELS_WEB_SERVICES"/>
-<!-- ========================================================================== -->
-<!-- @deprecated: Extension point: org.eclipse.jst.j2ee.internal.webservice.atk.ui.webservicesclienteditmodel -->
-<!-- ========================================================================== -->
-   <extension-point id="webservicesclienteditmodelcontainer" name="%EDITOR_EDITMODELS_WEB_SERVICES_CLIENT"/>
-
    <extension
          id="WSDLServiceHelper"
          name="WSDLServiceHelper"
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterCCombo.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterCCombo.java
index 6e5cc19..5cf43b5 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterCCombo.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterCCombo.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -128,4 +130,4 @@
 		if (combo_ != null && !combo_.isDisposed())
 			combo_.removeSelectionListener(this);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterElement.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterElement.java
index a51ff88..faf03da 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterElement.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterElement.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -194,4 +196,4 @@
 
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterExpiresCCombo.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterExpiresCCombo.java
index 67c763a..a39e822 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterExpiresCCombo.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterExpiresCCombo.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -157,4 +159,4 @@
 				msecond_.setText(modelValue.substring(s + 1, ms));
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterHandlerClassText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterHandlerClassText.java
index 1a26d66..a3ab5bf 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterHandlerClassText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterHandlerClassText.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -124,4 +126,4 @@
 		artifactEdit = anArtifactEdit;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterPCRefText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterPCRefText.java
index 356e267..831d04d 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterPCRefText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterPCRefText.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -113,4 +113,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameElement.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameElement.java
index 5f846e4..6a030e0 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameElement.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameElement.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -19,7 +19,6 @@
 import org.eclipse.emf.ecore.EFactory;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.j2ee.common.CommonFactory;
 import org.eclipse.jst.j2ee.common.CommonPackage;
 import org.eclipse.jst.j2ee.common.QName;
 import org.eclipse.jst.j2ee.internal.webservice.command.CommandAddElement;
@@ -58,7 +57,7 @@
 		childEClass_ = childEClass;
 		childFeature_ = childFeature;
 		childNillable_ = childNillable;
-		CommonPackage commonPKG = CommonFactory.eINSTANCE.getCommonPackage();
+		CommonPackage commonPKG = CommonPackage.eINSTANCE;
 		// Set up QName features
 		features_ = new EStructuralFeature[2];
 		features_[0] = commonPKG.getQName_NamespaceURI();
@@ -245,4 +244,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameText.java
index a0da4cc..60968f2 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterQNameText.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -59,4 +59,4 @@
 
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterServiceInterfaceText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterServiceInterfaceText.java
index 50050c6..4c1184c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterServiceInterfaceText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterServiceInterfaceText.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -112,4 +114,4 @@
 				text_.setText(text);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterText.java
index c27a592..3fdd4dd 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterText.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -118,4 +120,4 @@
 		artifactEdit = anArtifactEdit;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterTextCCombo.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterTextCCombo.java
index 68df84c..63822fe 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterTextCCombo.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/adapter/AdapterTextCCombo.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.adapter;
 
@@ -100,4 +102,4 @@
 				text_.setText(text);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddClientHandler.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddClientHandler.java
index ff69fe2..6da963b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddClientHandler.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddClientHandler.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -188,4 +190,4 @@
 	public Object getAddedObject() {
 		return newChild_;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddElement.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddElement.java
index d38eec3..34a7ffc 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddElement.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddElement.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -202,4 +204,4 @@
 	public Object getAddedObject() {
 		return newChild_;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddPortComponentRef.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddPortComponentRef.java
index 76bf9de..b33c0ff 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddPortComponentRef.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddPortComponentRef.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -188,4 +190,4 @@
 	public Object getAddedObject() {
 		return newChild_;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddServiceRef.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddServiceRef.java
index cf8ce0f..2392005 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddServiceRef.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandAddServiceRef.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -180,4 +182,4 @@
 	public Object getAddedObject() {
 		return newChild_;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyElement.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyElement.java
index 826c8e0..3f26254 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyElement.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyElement.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -177,4 +179,4 @@
 		return super.chain(command);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyHandlerClassText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyHandlerClassText.java
index 96ce31b..a91436f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyHandlerClassText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyHandlerClassText.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -178,4 +180,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyNSURI.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyNSURI.java
index a9b5561..9ba37eb 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyNSURI.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyNSURI.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -178,4 +180,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifySEI.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifySEI.java
index 5c2957f..c030e0f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifySEI.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifySEI.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -193,4 +193,4 @@
 	 */
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyServiceInterfaceText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyServiceInterfaceText.java
index 033dd44..1688d32 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyServiceInterfaceText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyServiceInterfaceText.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -178,4 +180,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyText.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyText.java
index 4d7bb77..de6eb00 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyText.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandModifyText.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -176,4 +178,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandMoveServiceRefs.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandMoveServiceRefs.java
index d7d169a..79893fb 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandMoveServiceRefs.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandMoveServiceRefs.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -286,4 +288,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandRemoveElement.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandRemoveElement.java
index 177388b..5206165 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandRemoveElement.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandRemoveElement.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -195,4 +197,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandSetElement.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandSetElement.java
index 55d309d..46cec0c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandSetElement.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/command/CommandSetElement.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.command;
 
@@ -193,4 +195,4 @@
 	public Command chain(Command command) {
 		return super.chain(command);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/JaxRPCMapArtifactEdit.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/JaxRPCMapArtifactEdit.java
index 64cc4d7..da5c99c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/JaxRPCMapArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/JaxRPCMapArtifactEdit.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.componentcore.util;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSCDDArtifactEdit.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSCDDArtifactEdit.java
index 045b418..faac06d 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSCDDArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSCDDArtifactEdit.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.componentcore.util;
 
 import java.util.List;
@@ -20,17 +30,16 @@
 
 /**
  * <p>
- * WSDDArtifactEdit obtains a WS Deployment Descriptor metamodel specifec data from a
- * {@see org.eclipse.jst.j2ee.ejb.EJBResource}&nbsp; which stores the metamodel. The
- * {@see org.eclipse.jst.j2ee.ejb.EJBResource}&nbsp;is retrieved from the
- * {@see org.eclipse.wst.common.modulecore.ArtifactEditModel}&nbsp;using a constant {@see
- * J2EEConstants#EJBJAR_DD_URI_OBJ}. The defined methods extract data or manipulate the contents of
- * the underlying resource.
+ * WSDDArtifactEdit obtains a WS Deployment Descriptor metamodel specifec data
+ * from a {@see org.eclipse.jst.j2ee.ejb.EJBResource}&nbsp; which stores the
+ * metamodel. The {@see org.eclipse.jst.j2ee.ejb.EJBResource}&nbsp;is retrieved
+ * from the {@see org.eclipse.wst.common.modulecore.ArtifactEditModel}&nbsp;using
+ * a constant {@see J2EEConstants#EJBJAR_DD_URI_OBJ}. The defined methods
+ * extract data or manipulate the contents of the underlying resource.
  * </p>
- * 
- */ 
+ */
 public class WSCDDArtifactEdit extends EnterpriseArtifactEdit {
-	
+
 	/**
 	 * <p>
 	 * Identifier used to link WSDDArtifactEdit to a WsddAdapterFactory {@see
@@ -39,7 +48,6 @@
 	 */
 
 	public static final Class ADAPTER_TYPE = WSCDDArtifactEdit.class;
-	
 
 	/**
 	 * @param aHandle
@@ -61,62 +69,61 @@
 	public WSCDDArtifactEdit(ArtifactEditModel model) {
 		super(model);
 	}
-	
+
 	/**
 	 * <p>
 	 * Creates an instance facade for the given {@see ArtifactEditModel}
 	 * </p>
+	 * <p>
+	 * Note: This method is for internal use only. Clients should not call this
+	 * method.
+	 * </p>
 	 * 
-	 * <p>Note: This method is for internal use only. Clients should not call this method.</p>
 	 * @param aNature
 	 *            A non-null {@see ModuleCoreNature}for an accessible project
 	 * @param aModule
-	 *            A non-null {@see WorkbenchComponent}pointing to a module from the given
-	 *            {@see ModuleCoreNature}
-	 */ 
-	protected WSCDDArtifactEdit(ModuleCoreNature aNature, IVirtualComponent aModule, boolean toAccessAsReadOnly) {
+	 *            A non-null {@see WorkbenchComponent}pointing to a module from
+	 *            the given {@see ModuleCoreNature}
+	 */
+	public WSCDDArtifactEdit(ModuleCoreNature aNature, IVirtualComponent aModule, boolean toAccessAsReadOnly) {
 		super(aNature, aModule, toAccessAsReadOnly);
 	}
-	
+
 	/**
-	 * 
 	 * @return WsddResource from (@link getDeploymentDescriptorResource())
-	 *  
 	 */
 
 	public WebServicesResource getWscddXmiResource() {
 		return (WebServicesResource) getDeploymentDescriptorResource();
 	}
-	
+
 	/**
 	 * <p>
 	 * Retrieves J2EE version information from EJBResource.
 	 * </p>
 	 * 
 	 * @return an integer representation of a J2EE Spec version
-	 *  
 	 */
 
 	public int getJ2EEVersion() {
 		return getWscddXmiResource().getJ2EEVersionID();
 	}
-	
-	
+
 	/**
 	 * <p>
-	 * Retrieves the underlying resource from the ArtifactEditModel using defined URI.
+	 * Retrieves the underlying resource from the ArtifactEditModel using
+	 * defined URI.
 	 * </p>
 	 * 
 	 * @return Resource
-	 *  
 	 */
 
 	public Resource getDeploymentDescriptorResource() {
 		return getArtifactEditModel().getResource(getWebServicesClientXmlResourceURI());
 	}
-	
+
 	public URI getWebServicesClientXmlResourceURI() {
-		
+
 		URI resourceURI = J2EEConstants.WEB_SERVICES_CLIENT_WEB_INF_DD_URI_OBJ;
 		if (isValidAppClientModule(ComponentCore.createComponent(getProject())))
 			resourceURI = J2EEConstants.WEB_SERVICES_CLIENT_META_INF_DD_URI_OBJ;
@@ -124,25 +131,23 @@
 			resourceURI = J2EEConstants.WEB_SERVICES_CLIENT_META_INF_DD_URI_OBJ; //$NON-NLS-1$
 		return resourceURI;
 	}
-	
+
 	/**
-	 * 
 	 * @return WebServices from (@link getDeploymentDescriptorRoot())
-	 *  
 	 */
 	public WebServicesClient getWebServicesClient() {
 		return (WebServicesClient) getDeploymentDescriptorRoot();
 	}
-	
+
 	/**
 	 * <p>
-	 * Obtains the WebServices (@see WebServices) root object from the WsddResource. If the root object does
-	 * not exist, then one is created (@link addEJBJarIfNecessary(getEJBJarXmiResource())).
-	 * The root object contains all other resource defined objects.
+	 * Obtains the WebServices (@see WebServices) root object from the
+	 * WsddResource. If the root object does not exist, then one is created
+	 * (@link addEJBJarIfNecessary(getEJBJarXmiResource())). The root object
+	 * contains all other resource defined objects.
 	 * </p>
 	 * 
 	 * @return EObject
-	 *  
 	 */
 	public EObject getDeploymentDescriptorRoot() {
 		List contents = getDeploymentDescriptorResource().getContents();
@@ -151,58 +156,58 @@
 		addWebServicesClientIfNecessary(getWscddXmiResource());
 		return (EObject) contents.get(0);
 	}
-	
+
 	/**
 	 * <p>
-	 * Creates a deployment descriptor root object (WebServices) and populates with data. Adds the root
-	 * object to the deployment descriptor resource.
+	 * Creates a deployment descriptor root object (WebServices) and populates
+	 * with data. Adds the root object to the deployment descriptor resource.
 	 * </p>
-	 * 
 	 * <p>
 	 * 
 	 * @param aModule
-	 *            A non-null pointing to a {@see XMLResource}
-	 * Note: This method is typically used for JUNIT - move?
-	 * </p>
+	 *            A non-null pointing to a {@see XMLResource} Note: This method
+	 *            is typically used for JUNIT - move?
+	 *            </p>
 	 */
 	protected void addWebServicesClientIfNecessary(WebServicesResource aResource) {
 		if (aResource != null) {
-		    if(aResource.getContents() == null || aResource.getContents().isEmpty()) {
+			if (aResource.getContents() == null || aResource.getContents().isEmpty()) {
 				WebServicesClient ws_client = Webservice_clientFactory.eINSTANCE.createWebServicesClient();
 				aResource.getContents().add(ws_client);
-		    }
+			}
 			aResource.getContents().get(0);
 			getArtifactEditModel().getModuleURI();
 			try {
 				aResource.saveIfNecessary();
-			}
-			catch (Exception e) {
+			} catch (Exception e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 	}
-	
+
 	/**
 	 * <p>
-	 * Returns an instance facade to manage the underlying edit model for the given
-	 * {@see WorkbenchComponent}. Instances of ArtifactEdit that are returned through this method
-	 * must be {@see #dispose()}ed of when no longer in use.
+	 * Returns an instance facade to manage the underlying edit model for the
+	 * given {@see WorkbenchComponent}. Instances of ArtifactEdit that are
+	 * returned through this method must be {@see #dispose()}ed of when no
+	 * longer in use.
 	 * </p>
 	 * <p>
-	 * Use to acquire an ArtifactEdit facade for a specific {@see WorkbenchComponent}&nbsp;that
-	 * will not be used for editing. Invocations of any save*() API on an instance returned from
-	 * this method will throw exceptions.
+	 * Use to acquire an ArtifactEdit facade for a specific
+	 * {@see WorkbenchComponent}&nbsp;that will not be used for editing.
+	 * Invocations of any save*() API on an instance returned from this method
+	 * will throw exceptions.
 	 * </p>
 	 * <p>
 	 * <b>The following method may return null. </b>
 	 * </p>
 	 * 
 	 * @param aModule
-	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that resolves to an
-	 *            accessible project in the workspace
-	 * @return An instance of ArtifactEdit that may only be used to read the underlying content
-	 *         model
+	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that
+	 *            resolves to an accessible project in the workspace
+	 * @return An instance of ArtifactEdit that may only be used to read the
+	 *         underlying content model
 	 */
 	public static WSCDDArtifactEdit getWSCDDArtifactEditForRead(IProject aProject) {
 		WSCDDArtifactEdit artifactEdit = null;
@@ -213,25 +218,27 @@
 		}
 		return artifactEdit;
 	}
+
 	/**
 	 * <p>
-	 * Returns an instance facade to manage the underlying edit model for the given
-	 * {@see WorkbenchComponent}. Instances of ArtifactEdit that are returned through this method
-	 * must be {@see #dispose()}ed of when no longer in use.
+	 * Returns an instance facade to manage the underlying edit model for the
+	 * given {@see WorkbenchComponent}. Instances of ArtifactEdit that are
+	 * returned through this method must be {@see #dispose()}ed of when no
+	 * longer in use.
 	 * </p>
 	 * <p>
-	 * Use to acquire an ArtifactEdit facade for a specific {@see WorkbenchComponent}&nbsp;that
-	 * will be used for editing.
+	 * Use to acquire an ArtifactEdit facade for a specific
+	 * {@see WorkbenchComponent}&nbsp;that will be used for editing.
 	 * </p>
 	 * <p>
 	 * <b>The following method may return null. </b>
 	 * </p>
 	 * 
 	 * @param aModule
-	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that resolves to an
-	 *            accessible project in the workspace
-	 * @return An instance of ArtifactEdit that may be used to modify and persist changes to the
-	 *         underlying content model
+	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that
+	 *            resolves to an accessible project in the workspace
+	 * @return An instance of ArtifactEdit that may be used to modify and
+	 *         persist changes to the underlying content model
 	 */
 	public static WSCDDArtifactEdit getWSCDDArtifactEditForWrite(IProject aProject) {
 		WSCDDArtifactEdit artifactEdit = null;
@@ -242,128 +249,140 @@
 		}
 		return artifactEdit;
 	}
-	
+
 	/**
 	 * <p>
-	 * Returns an instance facade to manage the underlying edit model for the given
-	 * {@see WorkbenchComponent}. Instances of WSDDArtifactEdit that are returned through this method
-	 * must be {@see #dispose()}ed of when no longer in use.
+	 * Returns an instance facade to manage the underlying edit model for the
+	 * given {@see WorkbenchComponent}. Instances of WSDDArtifactEdit that are
+	 * returned through this method must be {@see #dispose()}ed of when no
+	 * longer in use.
 	 * </p>
 	 * <p>
-	 * Use to acquire an WSDDArtifactEdit facade for a specific {@see WorkbenchComponent}&nbsp;that will not
-	 * be used for editing. Invocations of any save*() API on an instance returned from this method
+	 * Use to acquire an WSDDArtifactEdit facade for a specific
+	 * {@see WorkbenchComponent}&nbsp;that will not be used for editing.
+	 * Invocations of any save*() API on an instance returned from this method
 	 * will throw exceptions.
 	 * </p>
 	 * <p>
 	 * <b>This method may return null. </b>
 	 * </p>
+	 * <p>
+	 * Note: This method is for internal use only. Clients should not call this
+	 * method.
+	 * </p>
 	 * 
-	 * <p>Note: This method is for internal use only. Clients should not call this method.</p>
 	 * @param aModule
-	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that resolves to an accessible
-	 *            project in the workspace
-	 * @return An instance of WSDDArtifactEdit that may only be used to read the underlying content
-	 *         model
+	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that
+	 *            resolves to an accessible project in the workspace
+	 * @return An instance of WSDDArtifactEdit that may only be used to read the
+	 *         underlying content model
 	 * @throws UnresolveableURIException
 	 *             could not resolve uri.
 	 */
 	public static WSCDDArtifactEdit getWSCDDArtifactEditForRead(IVirtualComponent aModule) {
-		
-				IProject project = aModule.getProject();
-				ModuleCoreNature nature = ModuleCoreNature.getModuleCoreNature(project);
-				if (aModule != null && isValidWSCDDModule(aModule))
-					return new WSCDDArtifactEdit(nature, aModule, true);
-				else
-					return null;
+
+		IProject project = aModule.getProject();
+		ModuleCoreNature nature = ModuleCoreNature.getModuleCoreNature(project);
+		if (aModule != null && isValidWSCDDModule(aModule))
+			return new WSCDDArtifactEdit(nature, aModule, true);
+		return null;
 	}
-	
+
 	/**
 	 * <p>
-	 * Returns an instance facade to manage the underlying edit model for the given
-	 * {@see WorkbenchComponent}. Instances of EJBArtifactEdit that are returned through this method
-	 * must be {@see #dispose()}ed of when no longer in use.
+	 * Returns an instance facade to manage the underlying edit model for the
+	 * given {@see WorkbenchComponent}. Instances of EJBArtifactEdit that are
+	 * returned through this method must be {@see #dispose()}ed of when no
+	 * longer in use.
 	 * </p>
 	 * <p>
-	 * Use to acquire an WSDDArtifactEdit facade for a specific {@see WorkbenchComponent}&nbsp;that
-	 * will be used for editing.
+	 * Use to acquire an WSDDArtifactEdit facade for a specific
+	 * {@see WorkbenchComponent}&nbsp;that will be used for editing.
 	 * </p>
 	 * <p>
 	 * <b>This method may return null. </b>
 	 * </p>
+	 * <p>
+	 * Note: This method is for internal use only. Clients should not call this
+	 * method.
+	 * </p>
 	 * 
-	 * <p>Note: This method is for internal use only. Clients should not call this method.</p>
 	 * @param aModule
-	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that resolves to an accessible
-	 *            project in the workspace
-	 * @return An instance of WSDDArtifactEdit that may be used to modify and persist changes to the
-	 *         underlying content model
+	 *            A valid {@see WorkbenchComponent}&nbsp;with a handle that
+	 *            resolves to an accessible project in the workspace
+	 * @return An instance of WSDDArtifactEdit that may be used to modify and
+	 *         persist changes to the underlying content model
 	 */
 	public static WSCDDArtifactEdit getWSCDDArtifactEditForWrite(IVirtualComponent aModule) {
-				IProject project = aModule.getProject();
-				ModuleCoreNature nature = ModuleCoreNature.getModuleCoreNature(project);
-				if (aModule != null && isValidWSCDDModule(aModule))
-					return new WSCDDArtifactEdit(nature, aModule, false);
-				else
-					return null;
+		IProject project = aModule.getProject();
+		ModuleCoreNature nature = ModuleCoreNature.getModuleCoreNature(project);
+		if (aModule != null && isValidWSCDDModule(aModule))
+			return new WSCDDArtifactEdit(nature, aModule, false);
+		return null;
 	}
-	
+
 	/**
 	 * @param component
 	 *            A {@see IVirtualComponent}
 	 * @return True if the supplied module
-	 *         {@see ArtifactEdit#isValidEditableModule(IVirtualComponent)}and the moduleTypeId is a
-	 *         JST module
+	 *         {@see ArtifactEdit#isValidEditableModule(IVirtualComponent)}and
+	 *         the moduleTypeId is a JST module
 	 */
 	public static boolean isValidEJBModule(IVirtualComponent aComponent) {
 		return J2EEProjectUtilities.isEJBProject(aComponent.getProject());
 	}
+
 	/**
 	 * @param component
 	 *            A {@see IVirtualComponent}
 	 * @return True if the supplied module
-	 *         {@see ArtifactEdit#isValidWSDDModule(IVirtualComponent)}and
-	 *         the moduleTypeId is a JST module
+	 *         {@see ArtifactEdit#isValidWSDDModule(IVirtualComponent)}and the
+	 *         moduleTypeId is a JST module
 	 */
 	protected static boolean isValidWSCDDModule(IVirtualComponent aComponent) {
-		return (isValidAppClientModule(aComponent) ||
-				isValidWebModule(aComponent) ||
-				isValidEJBModule(aComponent));
+		return (isValidAppClientModule(aComponent) || isValidWebModule(aComponent) || isValidEJBModule(aComponent));
 	}
+
 	/**
 	 * @param component
 	 *            A {@see IVirtualComponent}
 	 * @return True if the supplied module
-	 *         {@see ArtifactEdit#isValidEditableModule(IVirtualComponent)}and the moduleTypeId is a
-	 *         JST module
+	 *         {@see ArtifactEdit#isValidEditableModule(IVirtualComponent)}and
+	 *         the moduleTypeId is a JST module
 	 */
 	public static boolean isValidWebModule(IVirtualComponent aComponent) {
 		return J2EEProjectUtilities.isDynamicWebProject(aComponent.getProject());
 	}
+
 	/**
 	 * @param component
 	 *            A {@see IVirtualComponent}
 	 * @return True if the supplied module
-	 *         {@see ArtifactEdit#isValidEditableModule(IVirtualComponent)}and the moduleTypeId is a
-	 *         JST module
+	 *         {@see ArtifactEdit#isValidEditableModule(IVirtualComponent)}and
+	 *         the moduleTypeId is a JST module
 	 */
 	public static boolean isValidAppClientModule(IVirtualComponent aComponent) {
 		return J2EEProjectUtilities.isApplicationClientProject(aComponent.getProject());
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see org.eclipse.jst.j2ee.internal.modulecore.util.EnterpriseArtifactEdit#createModelRoot()
 	 */
 	public EObject createModelRoot() {
-	    return createModelRoot(getJ2EEVersion());
+		return createModelRoot(getJ2EEVersion());
 	}
-			
-	/* (non-Javadoc)
+
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see org.eclipse.jst.j2ee.internal.modulecore.util.EnterpriseArtifactEdit#createModelRoot(int)
 	 */
 	public EObject createModelRoot(int version) {
-	    WebServicesResource res = getWscddXmiResource();
-	    res.setModuleVersionID(version);
-	    addWebServicesClientIfNecessary(res);
+		WebServicesResource res = getWscddXmiResource();
+		res.setModuleVersionID(version);
+		addWebServicesClientIfNecessary(res);
 		return getWebServicesClient();
 	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSDDArtifactEdit.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSDDArtifactEdit.java
index cd446d0..9adcc7b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSDDArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/componentcore/util/WSDDArtifactEdit.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.componentcore.util;
 
 import java.util.ArrayList;
@@ -33,7 +43,6 @@
  * a constant {@see J2EEConstants#EJBJAR_DD_URI_OBJ}. The defined methods
  * extract data or manipulate the contents of the underlying resource.
  * </p>
- * 
  */
 public class WSDDArtifactEdit extends EnterpriseArtifactEdit {
 
@@ -55,8 +64,7 @@
 	 * @param toAccessAsReadOnly
 	 * @throws IllegalArgumentException
 	 */
-	public WSDDArtifactEdit(IProject aProject, boolean toAccessAsReadOnly)
-			throws IllegalArgumentException {
+	public WSDDArtifactEdit(IProject aProject, boolean toAccessAsReadOnly) throws IllegalArgumentException {
 		super(aProject, toAccessAsReadOnly);
 		// TODO Auto-generated constructor stub
 	}
@@ -76,7 +84,6 @@
 	 * <p>
 	 * Creates an instance facade for the given {@see ArtifactEditModel}
 	 * </p>
-	 * 
 	 * <p>
 	 * Note: This method is for internal use only. Clients should not call this
 	 * method.
@@ -88,15 +95,12 @@
 	 *            A non-null {@see WorkbenchComponent}pointing to a module from
 	 *            the given {@see ModuleCoreNature}
 	 */
-	protected WSDDArtifactEdit(ModuleCoreNature aNature,
-			IVirtualComponent aModule, boolean toAccessAsReadOnly) {
+	public WSDDArtifactEdit(ModuleCoreNature aNature, IVirtualComponent aModule, boolean toAccessAsReadOnly) {
 		super(aNature, aModule, toAccessAsReadOnly);
 	}
 
 	/**
-	 * 
 	 * @return WsddResource from (@link getDeploymentDescriptorResource())
-	 * 
 	 */
 
 	public WsddResource getWsddXmiResource() {
@@ -109,7 +113,6 @@
 	 * </p>
 	 * 
 	 * @return an integer representation of a J2EE Spec version
-	 * 
 	 */
 
 	public int getJ2EEVersion() {
@@ -123,12 +126,10 @@
 	 * </p>
 	 * 
 	 * @return Resource
-	 * 
 	 */
 
 	public Resource getDeploymentDescriptorResource() {
-		return getArtifactEditModel().getResource(
-				getWebServicesXmlResourceURI());
+		return getArtifactEditModel().getResource(getWebServicesXmlResourceURI());
 	}
 
 	public URI getWebServicesXmlResourceURI() {
@@ -142,9 +143,7 @@
 	}
 
 	/**
-	 * 
 	 * @return WebServices from (@link getDeploymentDescriptorRoot())
-	 * 
 	 */
 	public WebServices getWebServices() {
 		if (!getProject().isAccessible())
@@ -163,7 +162,6 @@
 	 * </p>
 	 * 
 	 * @return EObject
-	 * 
 	 */
 	public EObject getDeploymentDescriptorRoot() {
 		List contents = getDeploymentDescriptorResource().getContents();
@@ -180,7 +178,6 @@
 	 * Creates a deployment descriptor root object (WebServices) and populates
 	 * with data. Adds the root object to the deployment descriptor resource.
 	 * </p>
-	 * 
 	 * <p>
 	 * 
 	 * @param aModule
@@ -190,8 +187,7 @@
 	 */
 	protected void addWebServicesIfNecessary(WsddResource aResource) {
 		if (aResource != null) {
-			if (aResource.getContents() == null
-					|| aResource.getContents().isEmpty()) {
+			if (aResource.getContents() == null || aResource.getContents().isEmpty()) {
 				WebServices ws = WsddFactory.eINSTANCE.createWebServices();
 				aResource.getContents().add(ws);
 			}
@@ -292,7 +288,6 @@
 	 * <p>
 	 * <b>This method may return null. </b>
 	 * </p>
-	 * 
 	 * <p>
 	 * Note: This method is for internal use only. Clients should not call this
 	 * method.
@@ -306,14 +301,12 @@
 	 * @throws UnresolveableURIException
 	 *             could not resolve uri.
 	 */
-	public static WSDDArtifactEdit getWSDDArtifactEditForRead(
-			IVirtualComponent aModule) {
+	public static WSDDArtifactEdit getWSDDArtifactEditForRead(IVirtualComponent aModule) {
 		IProject project = aModule.getProject();
 		ModuleCoreNature nature = ModuleCoreNature.getModuleCoreNature(project);
 		if (aModule != null && isValidWSDDModule(aModule))
 			return new WSDDArtifactEdit(nature, aModule, true);
-		else
-			return null;
+		return null;
 	}
 
 	/**
@@ -330,7 +323,6 @@
 	 * <p>
 	 * <b>This method may return null. </b>
 	 * </p>
-	 * 
 	 * <p>
 	 * Note: This method is for internal use only. Clients should not call this
 	 * method.
@@ -342,14 +334,12 @@
 	 * @return An instance of WSDDArtifactEdit that may be used to modify and
 	 *         persist changes to the underlying content model
 	 */
-	public static WSDDArtifactEdit getWSDDArtifactEditForWrite(
-			IVirtualComponent aModule) {
+	public static WSDDArtifactEdit getWSDDArtifactEditForWrite(IVirtualComponent aModule) {
 		IProject project = aModule.getProject();
 		ModuleCoreNature nature = ModuleCoreNature.getModuleCoreNature(project);
 		if (aModule != null && isValidWSDDModule(aModule))
 			return new WSDDArtifactEdit(nature, aModule, false);
-		else
-			return null;
+		return null;
 	}
 
 	/**
@@ -371,8 +361,7 @@
 	 *         moduleTypeId is a JST module
 	 */
 	protected static boolean isValidWSDDModule(IVirtualComponent aComponent) {
-		return (isValidAppClientModule(aComponent)
-				|| isValidWebModule(aComponent) || isValidEJBModule(aComponent));
+		return (isValidAppClientModule(aComponent) || isValidWebModule(aComponent) || isValidEJBModule(aComponent));
 	}
 
 	/**
@@ -383,8 +372,7 @@
 	 *         the moduleTypeId is a JST module
 	 */
 	public static boolean isValidWebModule(IVirtualComponent aComponent) {
-		return J2EEProjectUtilities
-				.isDynamicWebProject(aComponent.getProject());
+		return J2EEProjectUtilities.isDynamicWebProject(aComponent.getProject());
 	}
 
 	/**
@@ -395,8 +383,7 @@
 	 *         the moduleTypeId is a JST module
 	 */
 	public static boolean isValidAppClientModule(IVirtualComponent aComponent) {
-		return J2EEProjectUtilities.isApplicationClientProject(aComponent
-				.getProject());
+		return J2EEProjectUtilities.isApplicationClientProject(aComponent.getProject());
 	}
 
 	/*
@@ -429,9 +416,8 @@
 		List files = ProjectUtilities.getAllProjectFiles(getProject());
 		for (int i = 0; i < files.size(); i++) {
 			IFile file = (IFile) files.get(i);
-			if (file.getFileExtension().equals(WSIL_FILE_EXT)) {
-				IVirtualResource[] vResources = ComponentCore
-						.createResources(file);
+			if (file.getFileExtension() != null && file.getFileExtension().equals(WSIL_FILE_EXT)) {
+				IVirtualResource[] vResources = ComponentCore.createResources(file);
 				if (vResources.length > 0 && !result.contains(file))
 					result.add(file);
 			}
@@ -448,8 +434,7 @@
 		List result = new ArrayList();
 		for (int i = 0; i < resources.size(); i++) {
 			Resource res = (Resource) resources.get(i);
-			if (res != null && res.getURI().fileExtension() != null
-					&& res.getURI().fileExtension().equals(ext))
+			if (res != null && res.getURI().fileExtension() != null && res.getURI().fileExtension().equals(ext))
 				result.add(res);
 		}
 		return result;
@@ -466,8 +451,7 @@
 		} catch (Exception e) {
 			// Ignore
 		}
-		WSDLServiceHelper serviceHelper = WSDLServiceExtManager
-				.getServiceHelper();
+		WSDLServiceHelper serviceHelper = WSDLServiceExtManager.getServiceHelper();
 		if (res != null && res.isLoaded() && serviceHelper.isWSDLResource(res))
 			return res;
 		return null;
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/constants/ATKUIConstants.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/constants/ATKUIConstants.java
index b9f0e0c..0101578 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/constants/ATKUIConstants.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/constants/ATKUIConstants.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.internal.webservice.constants;
 
@@ -141,4 +143,4 @@
 	public String defaultComponentName() {
 		return new String(WebServicePlugin.getMessage("%_UI_PortComponentRef_type")); //$NON-NLS-1$
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLHelper.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLHelper.java
index fdc2e89..d05b17c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLHelper.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -355,4 +355,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLServiceHelperImpl.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLServiceHelperImpl.java
index 47224b4..df42d7c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLServiceHelperImpl.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WSDLServiceHelperImpl.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceEvent.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceEvent.java
index d53e0f1..efdb26b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceEvent.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceEvent.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.helper;
 
 public class WebServiceEvent {
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceManagerListener.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceManagerListener.java
index 72d71fb..e1dcaee 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceManagerListener.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServiceManagerListener.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.helper;
 
 public interface WebServiceManagerListener {
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServicesManager.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServicesManager.java
index 6709463..e2b3013 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServicesManager.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/helper/WebServicesManager.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -589,10 +589,11 @@
 
 		List result = new ArrayList();
 		WSCDDArtifactEdit wsClientArtifactEdit = (WSCDDArtifactEdit) getWSClientArtifactEdits().get(handle);
-		WebServicesResource res = wsClientArtifactEdit.getWscddXmiResource();
-		if (res != null && res.isLoaded() && res.getWebServicesClient() != null)
-			result.addAll(res.getWebServicesClient().getServiceRefs());
-
+		if (wsClientArtifactEdit !=null) {
+			WebServicesResource res = wsClientArtifactEdit.getWscddXmiResource();
+			if (res != null && res.isLoaded() && res.getWebServicesClient() != null)
+				result.addAll(res.getWebServicesClient().getServiceRefs());
+		}
 		return result;
 	}
 
@@ -685,14 +686,16 @@
 	 */
 	public List get13ServiceRefs(EnterpriseBean bean) {
 		WSCDDArtifactEdit artifactEdit = (WSCDDArtifactEdit) getWSClientArtifactEdits().get(WorkbenchResourceHelper.getFile(bean).getProject());
-		WebServicesResource res = artifactEdit.getWscddXmiResource();
-		if (res != null && res.getWebServicesClient() != null) {
-			String ejbName = bean.getName();
-			List scopes = res.getWebServicesClient().getComponentScopedRefs();
-			for (Iterator iter = scopes.iterator(); iter.hasNext();) {
-				ComponentScopedRefs scope = (ComponentScopedRefs) iter.next();
-				if (scope.getComponentName().equals(ejbName))
-					return scope.getServiceRefs();
+		if (artifactEdit !=null) {
+			WebServicesResource res = artifactEdit.getWscddXmiResource();
+			if (res != null && res.getWebServicesClient() != null) {
+				String ejbName = bean.getName();
+				List scopes = res.getWebServicesClient().getComponentScopedRefs();
+				for (Iterator iter = scopes.iterator(); iter.hasNext();) {
+					ComponentScopedRefs scope = (ComponentScopedRefs) iter.next();
+					if (scope.getComponentName().equals(ejbName))
+						return scope.getServiceRefs();
+				}
 			}
 		}
 		return Collections.EMPTY_LIST;
@@ -707,11 +710,13 @@
 		if (handle == null)
 			return Collections.EMPTY_LIST;
 		WSCDDArtifactEdit artifactEdit = (WSCDDArtifactEdit) getWSClientArtifactEdits().get(handle);
-		WebServicesResource res = artifactEdit.getWscddXmiResource();
-		if (res != null) {
-			WebServicesClient webClient = res.getWebServicesClient();
-			if (webClient != null)
-				return webClient.getServiceRefs();
+		if (artifactEdit !=null) {
+			WebServicesResource res = artifactEdit.getWscddXmiResource();
+			if (res != null) {
+				WebServicesClient webClient = res.getWebServicesClient();
+				if (webClient != null)
+					return webClient.getServiceRefs();
+			}
 		}
 		return Collections.EMPTY_LIST;
 	}
@@ -725,11 +730,13 @@
 		if (handle == null)
 			return Collections.EMPTY_LIST;
 		WSCDDArtifactEdit artifactEdit = (WSCDDArtifactEdit) getWSClientArtifactEdits().get(handle);
-		WebServicesResource res = artifactEdit.getWscddXmiResource();
-		if (res != null) {
-			WebServicesClient webClient = res.getWebServicesClient();
-			if (webClient != null)
-				return webClient.getServiceRefs();
+		if (artifactEdit !=null) {
+			WebServicesResource res = artifactEdit.getWscddXmiResource();
+			if (res != null) {
+				WebServicesClient webClient = res.getWebServicesClient();
+				if (webClient != null)
+					return webClient.getServiceRefs();
+			}
 		}
 		return Collections.EMPTY_LIST;
 	}
@@ -903,4 +910,4 @@
 		}
 		return list;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServicePlugin.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServicePlugin.java
index 49b41dc..7094e0e 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServicePlugin.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/plugin/WebServicePlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -228,4 +228,4 @@
 		// TODO For now...  translate not supported
 		return getString(key,substitutions);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIComponentScopedRefsItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIComponentScopedRefsItemProvider.java
index d5ec473..213f348 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIComponentScopedRefsItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIComponentScopedRefsItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.provider;
 
 import java.util.ArrayList;
@@ -82,4 +84,4 @@
 			result.addAll(super.getChildren(it.next()));
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIHandlerItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIHandlerItemProvider.java
index a97b3df..002f32a 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIHandlerItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIHandlerItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.provider;
 
 import java.util.ArrayList;
@@ -93,4 +95,4 @@
 		return result;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIServiceRefItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIServiceRefItemProvider.java
index 7087b84..afa4a7c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIServiceRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIServiceRefItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.provider;
 
 import java.util.ArrayList;
@@ -93,4 +95,4 @@
 		return result;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIWebServicesClientItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIWebServicesClientItemProvider.java
index 03e5bc7..bc1f1aa 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIWebServicesClientItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ATKUIWebServicesClientItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.provider;
 
 import java.util.ArrayList;
@@ -86,4 +88,4 @@
 			result.addAll(super.getChildren(it.next()));
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/AbstractATKUIItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/AbstractATKUIItemProvider.java
index 802a319..f060cf4 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/AbstractATKUIItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/AbstractATKUIItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservice.provider;
 
 import java.util.ArrayList;
@@ -78,4 +80,4 @@
 	protected String toDisplayString(String s) {
 		return (s != null) ? s : ""; //$NON-NLS-1$
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ComponentScopedRefsItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ComponentScopedRefsItemProvider.java
index f12223d..a0e2139 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ComponentScopedRefsItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ComponentScopedRefsItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -162,4 +162,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ConstructorParameterOrderItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ConstructorParameterOrderItemProvider.java
index 432ccf4..6d56f5b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ConstructorParameterOrderItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ConstructorParameterOrderItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -152,4 +152,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/EJBLinkItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/EJBLinkItemProvider.java
index 8abccb2..f3fb6f9 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/EJBLinkItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/EJBLinkItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -155,4 +155,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ElementNameItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ElementNameItemProvider.java
index b464857..5b29e1e 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ElementNameItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ElementNameItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,4 +145,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ExceptionMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ExceptionMappingItemProvider.java
index db49e21..9fbb3a8 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ExceptionMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ExceptionMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -197,4 +197,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/HandlerItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/HandlerItemProvider.java
index 0c7b546..5910edd 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/HandlerItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/HandlerItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -219,4 +219,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/InitParamItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/InitParamItemProvider.java
index d4233a5..c80243f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/InitParamItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/InitParamItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -217,4 +217,4 @@
 		return children;
 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaWSDLMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaWSDLMappingItemProvider.java
index 20c7bda..d74ac56 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaWSDLMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaWSDLMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -181,4 +181,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaXMLTypeMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaXMLTypeMappingItemProvider.java
index 8ee5111..aebe191 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaXMLTypeMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JavaXMLTypeMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -211,4 +211,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JaxrpcmapItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JaxrpcmapItemProviderAdapterFactory.java
index cbdd286..cc3d6ef 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JaxrpcmapItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/JaxrpcmapItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -675,4 +675,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/MethodParamPartsMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/MethodParamPartsMappingItemProvider.java
index 51880a2..987258b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/MethodParamPartsMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/MethodParamPartsMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -180,4 +180,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PackageMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PackageMappingItemProvider.java
index c2306a7..c634e9e 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PackageMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PackageMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -160,4 +160,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentItemProvider.java
index 1f174c4..5441d28 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -333,4 +333,4 @@
 		}
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentRefItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentRefItemProvider.java
index 0845800..b203f2f 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortComponentRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -151,4 +151,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortMappingItemProvider.java
index 5f39938..247d8e0 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -159,4 +159,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortNameItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortNameItemProvider.java
index 7f2a76a..200633c 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortNameItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/PortNameItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -156,4 +156,4 @@
 	/*
 	 * public ResourceLocator getResourceLocator() { return Webservicej2eeEditPlugin.INSTANCE; }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/SOAPRoleItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/SOAPRoleItemProvider.java
index ccba387..eb1d361 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/SOAPRoleItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/SOAPRoleItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -157,4 +157,4 @@
 	/*
 	 * public ResourceLocator getResourceLocator() { return Webservicej2eeEditPlugin.INSTANCE; }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointInterfaceMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointInterfaceMappingItemProvider.java
index bec1720..cffbbaf 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointInterfaceMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointInterfaceMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -187,4 +187,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointMethodMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointMethodMappingItemProvider.java
index 65fc189..2d3251e 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointMethodMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceEndpointMethodMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -211,4 +211,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceImplBeanItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceImplBeanItemProvider.java
index e7181ee..1a7a6de 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceImplBeanItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceImplBeanItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -250,4 +250,4 @@
 		}
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceInterfaceMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceInterfaceMappingItemProvider.java
index 43224b4..5ee3d04 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceInterfaceMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceInterfaceMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -182,4 +182,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefEditorItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefEditorItemProvider.java
index 389adae..0c4add8 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefEditorItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefEditorItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -61,4 +61,4 @@
 	public boolean hasChildren(Object arg0) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefItemProvider.java
index a5af9ba..98a1570 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServiceRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -225,4 +225,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServletLinkItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServletLinkItemProvider.java
index 07ac6b7..1096775 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServletLinkItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/ServletLinkItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -153,4 +153,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/VariableMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/VariableMappingItemProvider.java
index 47362ec..c4e815b 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/VariableMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/VariableMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -202,4 +202,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessageMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessageMappingItemProvider.java
index 9855d1f..e84f8dd 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessageMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessageMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -194,4 +194,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessagePartNameItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessagePartNameItemProvider.java
index 03b8b25..af6c536 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessagePartNameItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLMessagePartNameItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -146,4 +146,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLOperationItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLOperationItemProvider.java
index a2f2e88..d3880fd 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLOperationItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLOperationItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -145,4 +145,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLReturnValueMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLReturnValueMappingItemProvider.java
index 73d3677..fc62613 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLReturnValueMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WSDLReturnValueMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -180,4 +180,4 @@
 	public ResourceLocator getResourceLocator() {
 		return Webservicej2eeEditPlugin.INSTANCE;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServiceDescriptionItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServiceDescriptionItemProvider.java
index c338bc6..df59e82 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServiceDescriptionItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServiceDescriptionItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -341,4 +341,4 @@
 		}
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesClientItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesClientItemProvider.java
index a91b9b1..123b610 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesClientItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesClientItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -151,4 +151,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesItemProvider.java
index 48db24c..4e3323e 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WebServicesItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -160,4 +160,4 @@
 	public ResourceLocator getResourceLocator() {
 		return WebServicePlugin.getInstance();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/Webservice_clientItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/Webservice_clientItemProviderAdapterFactory.java
index 4eec513..ffed806 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/Webservice_clientItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/Webservice_clientItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -276,4 +276,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WscommonItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WscommonItemProviderAdapterFactory.java
index 5ae5c56..aa84566 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WscommonItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WscommonItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -304,4 +304,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WsddItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WsddItemProviderAdapterFactory.java
index 8517115..1a91929 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WsddItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/webservice/provider/WsddItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -371,4 +371,4 @@
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/wsdd/provider/HandlerItemProvider.java b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/wsdd/provider/HandlerItemProvider.java
index 4ecf42c..d0fb4e1 100644
--- a/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/wsdd/provider/HandlerItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee.webservice/webservice/org/eclipse/jst/j2ee/internal/wsdd/provider/HandlerItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -268,4 +268,4 @@
 		}
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/.classpath b/plugins/org.eclipse.jst.j2ee/.classpath
index c9c9cf2..4bb03a4 100644
--- a/plugins/org.eclipse.jst.j2ee/.classpath
+++ b/plugins/org.eclipse.jst.j2ee/.classpath
@@ -11,5 +11,6 @@
 	<classpathentry kind="src" path="property_files"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="refactor"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.jst.j2ee/.cvsignore b/plugins/org.eclipse.jst.j2ee/.cvsignore
index 60d3bb9..c57b639 100644
--- a/plugins/org.eclipse.jst.j2ee/.cvsignore
+++ b/plugins/org.eclipse.jst.j2ee/.cvsignore
@@ -3,3 +3,4 @@
 temp.folder
 build.xml
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.j2ee/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.j2ee/META-INF/MANIFEST.MF
index cb5ddd4..57c5ba4 100644
--- a/plugins/org.eclipse.jst.j2ee/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.j2ee/META-INF/MANIFEST.MF
@@ -36,7 +36,10 @@
  org.eclipse.jst.j2ee.internal.validation,
  org.eclipse.jst.j2ee.internal.webservices,
  org.eclipse.jst.j2ee.project.datamodel.properties,
- org.eclipse.jst.j2ee.project.facet
+ org.eclipse.jst.j2ee.project.facet,
+ org.eclipse.jst.j2ee.refactor,
+ org.eclipse.jst.j2ee.refactor.listeners,
+ org.eclipse.jst.j2ee.refactor.operations
 Require-Bundle: org.eclipse.emf.edit,
  org.eclipse.jem.workbench,
  org.eclipse.jst.j2ee.core,
@@ -64,5 +67,6 @@
  org.eclipse.wst.common.uriresolver,
  org.eclipse.wst.common.project.facet.core,
  org.eclipse.jst.common.project.facet.core,
- org.eclipse.wst.xml.core
+ org.eclipse.wst.xml.core,
+ org.eclipse.wst.web
 Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/componentcore/util/AppClientArtifactEdit.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/componentcore/util/AppClientArtifactEdit.java
index cb47aaa..5867c92 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/componentcore/util/AppClientArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/componentcore/util/AppClientArtifactEdit.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.applicationclient.componentcore.util;
 
 import java.util.List;
@@ -58,7 +68,7 @@
 		super(aProject, toAccessAsReadOnly);		
 	}
 	
-	protected AppClientArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
+	public AppClientArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
 		super(aProject, toAccessAsReadOnly, forCreate, J2EEProjectUtilities.APPLICATION_CLIENT);		
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationDataModelProvider.java
index c305797..e909e95 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -15,7 +15,7 @@
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.jst.j2ee.application.internal.operations.J2EEComponentCreationDataModelProvider;
-import org.eclipse.jst.j2ee.commonarchivecore.internal.impl.CommonarchiveFactoryImpl;
+import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonarchivePackage;
 import org.eclipse.jst.j2ee.datamodel.properties.IAppClientComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.J2EEConstants;
 import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
@@ -25,6 +25,11 @@
 import org.eclipse.wst.common.frameworks.datamodel.DataModelPropertyDescriptor;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 
+/**
+ * @deprecated 
+ * @see AppClientFacetProjectCreationDataModelProvider
+ */
+
 public class AppClientComponentCreationDataModelProvider extends J2EEComponentCreationDataModelProvider implements IAppClientComponentCreationDataModelProperties {
 
 	public AppClientComponentCreationDataModelProvider() {
@@ -88,7 +93,7 @@
 	}
 
 	protected EClass getComponentType() {
-		return CommonarchiveFactoryImpl.getPackage().getApplicationClientFile();
+		return CommonarchivePackage.eINSTANCE.getApplicationClientFile();
 	}
 
 	protected String getComponentExtension() {
@@ -107,7 +112,7 @@
 		boolean doSet = super.propertySet(propertyName, propertyValue);
 		if (propertyName.equals(JAVASOURCE_FOLDER)){
 			//unless MANIFEST folder is opened up, it is set as same as Java source folder
-			setProperty(MANIFEST_FOLDER, getProperty(JAVASOURCE_FOLDER)+ "/" + J2EEConstants.META_INF);
+			setProperty(MANIFEST_FOLDER, getProperty(JAVASOURCE_FOLDER)+ "/" + J2EEConstants.META_INF); //$NON-NLS-1$
 		}		
 		return doSet;
 	}	
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationFacetOperation.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationFacetOperation.java
index 7015efd..075f3d5 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationFacetOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentCreationFacetOperation.java
@@ -1,8 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.applicationclient.internal.creation;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IAdaptable;
@@ -12,7 +19,7 @@
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.datamodel.properties.IJavaComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.AppClientFacetInstallDataModelProvider;
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.J2EEComponentCreationFacetOperation;
 import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
@@ -21,7 +28,7 @@
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
-public class AppClientComponentCreationFacetOperation extends J2EEComponentCreationFacetOperation {
+public class AppClientComponentCreationFacetOperation extends J2EEComponentCreationFacetOperation implements IFacetProjectCreationDataModelProperties {
 
 	public AppClientComponentCreationFacetOperation(IDataModel model) {
 		super(model);
@@ -31,22 +38,21 @@
 		IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
 		String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
 		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, projectName);
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION,
-				model.getProperty(IComponentCreationDataModelProperties.LOCATION));
-		
-		List facetDMs = new ArrayList();
-		facetDMs.add(setupJavaInstallAction());
+
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(FACET_DM_MAP);
+		IDataModel javaDM = setupJavaInstallAction();
+		map.add(javaDM);
 		IDataModel newModel = setupAppClientFacetInstallAction();
-		facetDMs.add(newModel);
-		setRuntime(newModel,dm); //Setting runtime property
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
+		map.add(newModel);
+		setRuntime(newModel, dm); // Setting runtime property
+
 		IStatus stat = dm.getDefaultOperation().execute(monitor, info);
-		if( stat.isOK()){
+		if (stat.isOK()) {
 			String earProjectName = (String) model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME);
-			IProject earProject = ProjectUtilities.getProject( earProjectName );
+			IProject earProject = ProjectUtilities.getProject(earProjectName);
 			if (earProject != null && earProject.exists())
 				stat = addtoEar(projectName, earProjectName);
-		}		
+		}
 
 		return stat;
 	}
@@ -56,10 +62,11 @@
 		IDataModel facetInstallDataModel = DataModelFactory.createDataModel(new AppClientFacetInstallDataModelProvider());
 		facetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME));
 		facetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, versionStr);
-		facetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER, model.getStringProperty(IJavaComponentCreationDataModelProperties.JAVASOURCE_FOLDER) );
+		facetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER, model.getStringProperty(IJavaComponentCreationDataModelProperties.JAVASOURCE_FOLDER));
+		facetInstallDataModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR,model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR));
 		if (model.getBooleanProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR))
-			facetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.EAR_PROJECT_NAME, model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME));		
-		facetInstallDataModel.setProperty(IJ2EEFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(IJ2EEComponentCreationDataModelProperties.RUNTIME_TARGET_ID));
+			facetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME, model.getProperty(IJ2EEComponentCreationDataModelProperties.EAR_COMPONENT_NAME));
+		facetInstallDataModel.setProperty(IJ2EEModuleFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(IJ2EEComponentCreationDataModelProperties.RUNTIME_TARGET_ID));
 		return facetInstallDataModel;
-	}		
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentImportDataModelProvider.java
index 438c150..9cf32af 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientComponentImportDataModelProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.applicationclient.internal.creation;
 
 import org.eclipse.jst.j2ee.application.internal.operations.J2EEComponentImportDataModelProvider;
@@ -41,4 +43,4 @@
 	protected IDataModel createJ2EEComponentCreationDataModel() {
 		return DataModelFactory.createDataModel(new AppClientComponentCreationDataModelProvider());
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientCreationResourceHandler.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientCreationResourceHandler.java
index 9a1e7ba..c35ede9 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientCreationResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientCreationResourceHandler.java
@@ -1,53 +1,31 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.applicationclient.internal.creation;
 
+import org.eclipse.osgi.util.NLS;
 
+public final class AppClientCreationResourceHandler extends NLS {
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+	private static final String BUNDLE_NAME = "appclientcreation";//$NON-NLS-1$
 
-public class AppClientCreationResourceHandler {
-
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("appclientcreation");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private AppClientCreationResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String Error_occured_getting_appl_ERROR_;
+	public static String Creating_Application_Clien_UI_;
+	public static String Error_occured_loading_appl_UI_;
+	public static String Not_an_Application_Client_project_ERROR_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, AppClientCreationResourceHandler.class);
 	}
-
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientFacetProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientFacetProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..0e18b0b
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/AppClientFacetProjectCreationDataModelProvider.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.applicationclient.internal.creation;
+
+import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
+import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.AppClientFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class AppClientFacetProjectCreationDataModelProvider extends FacetProjectCreationDataModelProvider {
+
+	public AppClientFacetProjectCreationDataModelProvider() {
+		super();
+	}
+	
+	public void init() {
+		super.init();
+		FacetDataModelMap map = (FacetDataModelMap) getProperty(FACET_DM_MAP);
+		IDataModel javaFacet = DataModelFactory.createDataModel(new JavaFacetInstallDataModelProvider());
+		map.add(javaFacet);
+		IDataModel appClientFacet = DataModelFactory.createDataModel(new AppClientFacetInstallDataModelProvider());
+		map.add(appClientFacet);
+		javaFacet.setProperty(IJavaFacetInstallDataModelProperties.SOURCE_FOLDER_NAME,appClientFacet.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER));
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/IConfigurationConstants.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/IConfigurationConstants.java
index fcef1d1..8848cf0 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/IConfigurationConstants.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/creation/IConfigurationConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,4 +18,4 @@
  */
 public interface IConfigurationConstants {
 	final String PLUG_IN_ID = "org.eclipse.jst.j2ee"; //$NON-NLS-1$
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/modulecore/util/AppClientEditAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/modulecore/util/AppClientEditAdapterFactory.java
index 87c002c..f3f5095 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/modulecore/util/AppClientEditAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/applicationclient/internal/modulecore/util/AppClientEditAdapterFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.applicationclient.internal.modulecore.util;
 
 import org.eclipse.core.runtime.IAdapterFactory;
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDataModelProvider.java
index a6f28b9..adb516f 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDataModelProvider.java
@@ -1,27 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
 import java.util.Set;
 
+import org.eclipse.jst.j2ee.internal.common.CreationConstants;
+import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
-import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
-public class AppClientFacetInstallDataModelProvider
-	extends FacetInstallDataModelProvider
-	implements IJ2EEFacetInstallDataModelProperties{
+public class AppClientFacetInstallDataModelProvider extends J2EEModuleFacetInstallDataModelProvider implements IAppClientFacetInstallDataModelProperties {
+
+	public AppClientFacetInstallDataModelProvider() {
+		super();
+	}
 
 	public Set getPropertyNames() {
 		Set names = super.getPropertyNames();
-		names.add(EAR_PROJECT_NAME);
-		names.add(CONFIG_FOLDER);
-		names.add(RUNTIME_TARGET_ID);
+		names.add(CREATE_DEFAULT_MAIN_CLASS);
 		return names;
 	}
-	
+
 	public Object getDefaultProperty(String propertyName) {
-		if(propertyName.equals(FACET_ID)){
+		if (propertyName.equals(FACET_ID))
 			return J2EEProjectUtilities.APPLICATION_CLIENT;
-		}
+		else if (propertyName.equals(CREATE_DEFAULT_MAIN_CLASS))
+			return Boolean.TRUE;
+		else if (propertyName.equals(CONFIG_FOLDER))
+			return CreationConstants.DEFAULT_APPCLIENT_SOURCE_FOLDER;
 		return super.getDefaultProperty(propertyName);
 	}
 	
+	protected int convertFacetVersionToJ2EEVersion(IProjectFacetVersion version) {
+		return J2EEVersionUtil.convertAppClientVersionStringToJ2EEVersionID(version.getVersionString());
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDelegate.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDelegate.java
index 8f4697f..4d7a707 100644
--- a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/AppClientFacetInstallDelegate.java
@@ -1,7 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IWorkspace;
@@ -10,107 +26,200 @@
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
+import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jem.workbench.utility.JemProjectUtilities;
 import org.eclipse.jst.common.project.facet.WtpUtils;
+import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
+import org.eclipse.jst.j2ee.application.ApplicationPackage;
+import org.eclipse.jst.j2ee.application.Module;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationDataModelProvider;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationOp;
+import org.eclipse.jst.j2ee.application.internal.operations.IAddComponentToEnterpriseApplicationDataModelProperties;
+import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProperties;
+import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProvider;
 import org.eclipse.jst.j2ee.applicationclient.componentcore.util.AppClientArtifactEdit;
 import org.eclipse.jst.j2ee.internal.J2EEConstants;
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
-import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
+import org.eclipse.jst.j2ee.internal.common.operations.INewJavaClassDataModelProperties;
+import org.eclipse.jst.j2ee.internal.common.operations.NewJavaClassDataModelProvider;
 import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.FacetDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.componentcore.internal.operation.IArtifactEditOperationDataModelProperties;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 
 public class AppClientFacetInstallDelegate extends J2EEFacetInstallDelegate implements IDelegate {
 
 	public void execute(IProject project, IProjectFacetVersion fv, Object config, IProgressMonitor monitor) throws CoreException {
-		if (monitor != null) {
-			monitor.beginTask("", 1);
-		}
-
+		if (monitor != null)
+			monitor.beginTask("", 1); //$NON-NLS-1$
 		try {
 			IDataModel model = (IDataModel) config;
-
-			final IJavaProject jproj = JavaCore.create(project);
+			JavaCore.create(project);
 
 			// Add WTP natures.
-
 			WtpUtils.addNatures(project);
 
-			// Create the directory structure.
-
-			final IWorkspace ws = ResourcesPlugin.getWorkspace();
-			final IPath pjpath = project.getFullPath();
-
 			// Setup the flexible project structure.
-
-			final IVirtualComponent c = ComponentCore.createComponent(project);
-
-			c.create(0, null);
-			c.setMetaProperty("java-output-path", "/build/classes/");
-
-
-
-			final IVirtualFolder root = c.getRootFolder();
-			String configFolder = model.getStringProperty(IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER);
-			root.createLink(new Path("/" + configFolder), 0, null);
-
-
-			String configFolderName = model.getStringProperty(IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER);
-			IPath configFolderpath = pjpath.append(configFolderName);
-
-			IFolder configIFolder = ws.getRoot().getFolder(configFolderpath);
-
-			if (!configIFolder.getFile(J2EEConstants.APP_CLIENT_DD_URI).exists()) {
-				String ver = model.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
-				int nVer = J2EEVersionUtil.convertVersionStringToInt(ver);
-				AppClientArtifactEdit.createDeploymentDescriptor(project, nVer);
-			}
-
-			try {
-				createManifest(project, configFolder, monitor);
-			} catch (InvocationTargetException e) {
-				Logger.getLogger().logError(e);
-			} catch (InterruptedException e) {
-				Logger.getLogger().logError(e);
-			}
+			IVirtualComponent c = createFlexibleProject(monitor, project, model);
 
 			// Setup the classpath.
 			ClasspathHelper.removeClasspathEntries(project, fv);
-
 			if (!ClasspathHelper.addClasspathEntries(project, fv)) {
 				// TODO: Support the no runtime case.
 				// ClasspathHelper.addClasspathEntries( project, fv, <something> );
 			}
 
 			// Associate with an EAR, if necessary.
+			final String earProjectName = (String) model.getProperty(IJ2EEModuleFacetInstallDataModelProperties.EAR_PROJECT_NAME);
+			if (model.getBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR)) {
+				if (earProjectName != null && !earProjectName.equals("")) { //$NON-NLS-1$
+					String ver = fv.getVersionString();
+//					String j2eeVersionText = J2EEVersionUtil.convertVersionIntToString
+//					(J2EEVersionUtil.convertWebVersionStringToJ2EEVersionID(ver));
+					
+					String j2eeVersionText = ver;
+					IFacetedProject facetedProject = ProjectFacetsManager.create(project);
+					installEARFacet(j2eeVersionText, earProjectName, facetedProject.getRuntime(), monitor);
 
-			final String earProjectName = (String) model.getProperty(IJ2EEFacetInstallDataModelProperties.EAR_PROJECT_NAME);
-			if (earProjectName != null && !earProjectName.equals("")) {
+					IProject earProject = ProjectUtilities.getProject(earProjectName);
+					IVirtualComponent earComp = ComponentCore.createComponent(earProject);
 
-				String ver = model.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
+					final IDataModel dataModel = DataModelFactory.createDataModel(new AddComponentToEnterpriseApplicationDataModelProvider() {
+						public Object getDefaultProperty(String propertyName) {
+							if (IAddComponentToEnterpriseApplicationDataModelProperties.TARGET_COMPONENTS_TO_URI_MAP.equals(propertyName)) {
+								Map map = new HashMap();
+								List components = (List) getProperty(TARGET_COMPONENT_LIST);
+								for (int i = 0; i < components.size(); i++) {
+									IVirtualComponent component = (IVirtualComponent) components.get(i);
+									String name = component.getName();
+									name += ".jar"; //$NON-NLS-1$
+									map.put(component, name);
+								}
+								return map;
+							}
+							return super.getDefaultProperty(propertyName);
+						}
 
-				String j2eeVersionText = J2EEVersionUtil.convertVersionIntToString(J2EEVersionUtil.convertAppClientVersionStringToJ2EEVersionID(ver));
-
-				installEARFacet(j2eeVersionText, earProjectName, monitor);
+						public IDataModelOperation getDefaultOperation() {
+							return new AddComponentToEnterpriseApplicationOp(model) {
+								protected Module createNewModule(IVirtualComponent wc) {
+									return ((ApplicationPackage) EPackage.Registry.INSTANCE.getEPackage(ApplicationPackage.eNS_URI)).getApplicationFactory().createJavaClientModule();
+								}
+							};
+						}
+					});
+					dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp);
+					List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+					modList.add(c);
+					dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
+					try {
+						dataModel.getDefaultOperation().execute(null, null);
+					} catch (ExecutionException e) {
+						Logger.getLogger().logError(e);
+					}
+				}
 			}
 
-			if (monitor != null) {
+			// Add main class if necessary
+			if (model.getBooleanProperty(IAppClientFacetInstallDataModelProperties.CREATE_DEFAULT_MAIN_CLASS))
+				addMainClass(monitor, model, project);
+
+			try {
+				((IDataModelOperation) model.getProperty(FacetDataModelProvider.NOTIFICATION_OPERATION)).execute(monitor, null);
+			} catch (ExecutionException e) {
+				Logger.getLogger().logError(e);
+			}
+
+			if (monitor != null)
 				monitor.worked(1);
-			}
-		}
-
-		finally {
-			if (monitor != null) {
+		} catch (Exception e) {
+			Logger.getLogger().logError(e);
+		} finally {
+			if (monitor != null)
 				monitor.done();
-			}
 		}
-
 	}
 
+	protected IVirtualComponent createFlexibleProject(IProgressMonitor monitor, IProject project, IDataModel model) throws Exception {
+		// Create the directory structure.
+		final IWorkspace ws = ResourcesPlugin.getWorkspace();
+		final IPath pjpath = project.getFullPath();
+
+		final IVirtualComponent c = ComponentCore.createComponent(project);
+		c.create(0, null);
+		c.setMetaProperty("java-output-path", "/build/classes/"); //$NON-NLS-1$ //$NON-NLS-2$
+		final IVirtualFolder root = c.getRootFolder();
+		IFolder sourceFolder = null;
+		String configFolder = null;
+		if (root.getProjectRelativePath().segmentCount() == 0) {
+			configFolder = model.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER);
+			root.createLink(new Path("/" + configFolder), 0, null); //$NON-NLS-1$
+			String configFolderName = model.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER);
+			IPath configFolderpath = pjpath.append(configFolderName);
+			sourceFolder = ws.getRoot().getFolder(configFolderpath);
+		} else
+			sourceFolder = project.getFolder(root.getProjectRelativePath());
+
+		if (!sourceFolder.getFile(J2EEConstants.APP_CLIENT_DD_URI).exists()) {
+			String ver = model.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
+			int nVer = J2EEVersionUtil.convertVersionStringToInt(ver);
+			AppClientArtifactEdit.createDeploymentDescriptor(project, nVer);
+		}
+		try {
+			createManifest(project, sourceFolder, monitor);
+		} catch (Exception e) {
+			Logger.getLogger().logError(e);
+		}
+		return c;
+	}
+
+	private void addMainClass(IProgressMonitor monitor, IDataModel model, IProject project) {
+		try {
+			IDataModel mainClassDataModel = DataModelFactory.createDataModel(NewJavaClassDataModelProvider.class);
+			mainClassDataModel.setProperty(IArtifactEditOperationDataModelProperties.PROJECT_NAME, project.getName());
+			mainClassDataModel.setProperty(INewJavaClassDataModelProperties.CLASS_NAME, "Main"); //$NON-NLS-1$
+			mainClassDataModel.setBooleanProperty(INewJavaClassDataModelProperties.MAIN_METHOD, true);
+			String projRelativeSourcePath = IPath.SEPARATOR + project.getName() + IPath.SEPARATOR + model.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER);
+			mainClassDataModel.setProperty(INewJavaClassDataModelProperties.SOURCE_FOLDER, projRelativeSourcePath);
+			IJavaProject javaProject = JemProjectUtilities.getJavaProject(project);
+			mainClassDataModel.setProperty(INewJavaClassDataModelProperties.JAVA_PACKAGE_FRAGMENT_ROOT, javaProject.getPackageFragmentRoots()[0]);
+			mainClassDataModel.getDefaultOperation().execute(monitor, null);
+			createManifestEntryForMainClass(monitor, model, project);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	protected void createManifestEntryForMainClass(IProgressMonitor monitor, IDataModel model, IProject project) throws CoreException, InvocationTargetException, InterruptedException {
+		String manifestFolder = IPath.SEPARATOR + model.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.CONFIG_FOLDER) + IPath.SEPARATOR + J2EEConstants.META_INF;
+		IContainer container = project.getFolder(manifestFolder);
+		IFile file = container.getFile(new Path(J2EEConstants.MANIFEST_SHORT_NAME));
+
+		if (model.getBooleanProperty(IAppClientFacetInstallDataModelProperties.CREATE_DEFAULT_MAIN_CLASS)) {
+			IDataModel dm = DataModelFactory.createDataModel(UpdateManifestDataModelProvider.class);
+			dm.setProperty(UpdateManifestDataModelProperties.PROJECT_NAME, project.getName());
+			dm.setBooleanProperty(UpdateManifestDataModelProperties.MERGE, false);
+			dm.setProperty(UpdateManifestDataModelProperties.MANIFEST_FILE, file);
+			dm.setProperty(UpdateManifestDataModelProperties.MAIN_CLASS, "Main"); //$NON-NLS-1$
+			try {
+				dm.getDefaultOperation().execute(monitor, null);
+			} catch (Exception e) {
+				// Ignore
+			}
+		}
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/IAppClientFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/IAppClientFacetInstallDataModelProperties.java
new file mode 100644
index 0000000..3436004
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/appclientcreation/org/eclipse/jst/j2ee/project/facet/IAppClientFacetInstallDataModelProperties.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+public interface IAppClientFacetInstallDataModelProperties extends IJ2EEModuleFacetInstallDataModelProperties {
+
+	 /**
+     * Optional, type Boolean. the default value is <code>Boolean.TRUE</code>.If this is true and CREATE_DEFAULT_FILES is true, then a default main
+     * class will be generated during component creation.
+     */
+    public static final String CREATE_DEFAULT_MAIN_CLASS = "IAppClientComponentCreationDataModelProperties.CREATE_DEFAULT_MAIN_CLASS"; //$NON-NLS-1$
+    
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProvider.java
index e20e604..13f419f 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -133,7 +133,7 @@
 				key = "14_ear_obj"; //$NON-NLS-1$
 				break;
 		}
-		return J2EEPlugin.getPlugin().getImage(key);//$NON-NLS-1$
+		return J2EEPlugin.getPlugin().getImage(key);
 	}
 
 	/**
@@ -211,4 +211,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapter.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapter.java
index af47b52..173415d 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -62,4 +62,4 @@
 		EObject refObject = (EObject) object;
 		return ApplicationProvidersResourceHandler.getString("Create_a_new_child_for_the_selected_UI_") + refObject.eClass().getName() + "."; //$NON-NLS-1$ //$NON-NLS-2$
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapterFactory.java
index 961580a..c1000c6 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -264,4 +264,4 @@
 	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
 		this.parentAdapterFactory = parentAdapterFactory;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationProvidersResourceHandler.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationProvidersResourceHandler.java
index 3a235be..2bee279 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationProvidersResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ApplicationProvidersResourceHandler.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.application.provider;
 
 
@@ -88,4 +90,4 @@
 		}
 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/EjbModuleItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/EjbModuleItemProvider.java
index 1890519..1dcc01e 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/EjbModuleItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/EjbModuleItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -105,4 +105,4 @@
 		return itemPropertyDescriptors;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/JavaClientModuleItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/JavaClientModuleItemProvider.java
index 2a7b6ed..9e14a7f 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/JavaClientModuleItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/JavaClientModuleItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -105,4 +105,4 @@
 		return itemPropertyDescriptors;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ModuleItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ModuleItemProvider.java
index 8f66c4b..c00f591 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ModuleItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/ModuleItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -176,4 +176,4 @@
 	 * moduleExtension, moduleExtension); applicationExtension.eNotify(notification); } // code ends
 	 * return; } super.notifyChanged(notifier, eventType, feature, oldValue, newValue, index); }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/WebModuleItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/WebModuleItemProvider.java
index 5eac208..7b185b6 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/WebModuleItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/application/provider/WebModuleItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -135,4 +135,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ApplicationClientItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ApplicationClientItemProvider.java
index c9b2230..2148970 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ApplicationClientItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ApplicationClientItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -270,4 +270,4 @@
 		}	
 		return myChildren;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapter.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapter.java
index b9fc62e..4253a6b 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -77,4 +77,4 @@
 		EObject refObject = (EObject) object;
 		return ApplicationProvidersResourceHandler.getString("Create_a_new_child_for_the_selected_UI_") + refObject.eClass().getName() + "."; //$NON-NLS-1$ //$NON-NLS-2$
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapterFactory.java
index fc02c98..5a5b159 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ClientItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -177,4 +177,4 @@
 	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
 		this.parentAdapterFactory = parentAdapterFactory;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/EARProjectMapItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/EARProjectMapItemProvider.java
index ec4e908..1edbb7d 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/EARProjectMapItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/EARProjectMapItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -163,4 +163,4 @@
 	public ResourceLocator getResourceLocator() {
 		return ApplicationProvidersResourceHandler.RESOURCE_LOCATOR;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/J2EEItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/J2EEItemProvider.java
index ad4a7ff..f89be2c 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/J2EEItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/J2EEItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.provider;
 
 
@@ -241,4 +243,4 @@
 		return ProjectUtilities.getProject(getParent());
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModuleMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModuleMappingItemProvider.java
index fa42997..d7c6f84 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModuleMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModuleMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -163,4 +163,4 @@
 	 * fireNotifyChanged(notifier, eventType, feature, oldValue, newValue, index); return; }
 	 * super.notifyChanged(notifier, eventType, feature, oldValue, newValue, index); }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapter.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapter.java
index 3d98723..49bc8c4 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -134,4 +134,4 @@
 		String featureKey = feature instanceof EReference ? ((EReference) feature).getName() : "Unknown"; //$NON-NLS-1$
 		return J2EEPlugin.getPlugin().getString("_UI_" + featureKey + "_feature"); //$NON-NLS-1$ //$NON-NLS-2$
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapterFactory.java
index 30eeacb..bc415ac 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/ModulemapItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -212,4 +212,4 @@
 	 * if (parentAdapterFactory != null) { parentAdapterFactory.fireNotifyChanged(object, eventType,
 	 * feature, oldValue, newValue, index); } }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/UtilityJARMappingItemProvider.java b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/UtilityJARMappingItemProvider.java
index b166a7c..6cf3c10 100644
--- a/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/UtilityJARMappingItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/applicationedit/org/eclipse/jst/j2ee/internal/provider/UtilityJARMappingItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -188,4 +188,4 @@
 	 * newValue, index); return; } super.notifyChanged(notifier, eventType, feature, oldValue,
 	 * newValue, index); }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAddWebComponentToEnterpriseApplicationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAddWebComponentToEnterpriseApplicationDataModelProperties.java
index e8b1d47..45d5e29 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAddWebComponentToEnterpriseApplicationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAddWebComponentToEnterpriseApplicationDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.datamodel.properties;
 
 import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentCreationDataModelProperties.java
index b924c42..aa78571 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentCreationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentExportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentExportDataModelProperties.java
index f39bc76..00fa5d0 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentExportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentExportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentImportDataModelProperties.java
index 0514a00..f2895dc 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IAppClientComponentImportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentExportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentExportDataModelProperties.java
index ed18140..d6e8b1a 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentExportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentExportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentImportDataModelProperties.java
index d3d64fe..c30fa4a 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEARComponentImportDataModelProperties.java
@@ -1,19 +1,20 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.datamodel.properties;
+
 /**
  * <p>
- * IEARComponentImportDataModelProperties provides properties to the IDataModel associated with the 
- * EARComponentImportDataModelProvider.
- * NOTE: The associated Provider and Operations will be created during M5
+ * IEARComponentImportDataModelProperties provides properties to the IDataModel associated with the
+ * EARComponentImportDataModelProvider. NOTE: The associated Provider and Operations will be created
+ * during M5
  * </p>
  * <p>
  * This interface is not intended to be implemented by clients.
@@ -28,35 +29,37 @@
 public interface IEARComponentImportDataModelProperties extends IJ2EEComponentImportDataModelProperties {
 
 	/**
-     * Optional, type IPath default is ear location
-     */
-    public static final String NESTED_MODULE_ROOT = "IEnterpriseApplicationImportDataModelProperties.NESTED_MODULE_ROOT"; //$NON-NLS-1$
+	 * Optional, type IPath default is ear location
+	 */
+	public static final String NESTED_MODULE_ROOT = "IEnterpriseApplicationImportDataModelProperties.NESTED_MODULE_ROOT"; //$NON-NLS-1$
 
-    /**
-     * Optional, A List containing utililty jars;
-     */
-    public static final String UTILITY_LIST = "IEnterpriseApplicationImportDataModelProperties.UTILITY_LIST"; //$NON-NLS-1$
-    /**
-     * Optional, A List containing modules to be imported list;
-     */
-    public static final String SELECTED_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.SELECTED_MODELS_LIST"; //$NON-NLS-1$
-    /**
-     * Optional, A List containing ejb client jars associated with any ejb components which are to be imported.
-     */
-    public static final String EJB_CLIENT_LIST = "IEnterpriseApplicationImportDataModelProperties.EJB_CLIENT_LIST"; //$NON-NLS-1$
+	/**
+	 * Optional, A List containing utililty jars. This list should consist of the CommonArchive
+	 * Archives of all the Utility Jars that should be extracted into projects.
+	 */
+	public static final String UTILITY_LIST = "IEnterpriseApplicationImportDataModelProperties.UTILITY_LIST"; //$NON-NLS-1$
+	/**
+	 * Optional, A List containing modules to be imported list;
+	 */
+	public static final String SELECTED_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.SELECTED_MODELS_LIST"; //$NON-NLS-1$
+	/**
+	 * Optional, A List containing ejb client jars associated with any ejb components which are to
+	 * be imported.
+	 */
+	public static final String EJB_CLIENT_LIST = "IEnterpriseApplicationImportDataModelProperties.EJB_CLIENT_LIST"; //$NON-NLS-1$
 
-    /**
-     * Optional. This is a list of data models. This list must contain all non-utilty projects in
-     * the ear to be imported
-     */
-    public static final String MODULE_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.MODULE_MODELS_LIST"; //$NON-NLS-1$
+	/**
+	 * Optional. This is a list of data models. This list must contain all non-utilty projects in
+	 * the ear to be imported
+	 */
+	public static final String MODULE_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.MODULE_MODELS_LIST"; //$NON-NLS-1$
 
-    /**
-     * Optional. This is a list of data models. This list must contain all utility jars selected to
-     * be imported
-     */
-    public static final String UTILITY_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.UTILITY_MODELS_LIST"; //$NON-NLS-1$
-	
+	/**
+	 * Optional. This is a list of data models. This list must contain all utility jars selected to
+	 * be imported
+	 */
+	public static final String UTILITY_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.UTILITY_MODELS_LIST"; //$NON-NLS-1$
+
 	/**
 	 * This is an unsettable property which will return all the project DataModels.
 	 */
@@ -71,6 +74,6 @@
 	 * This is an unsettable property which will return .
 	 */
 	public static final String HANDLED_PROJECT_MODELS_LIST = "IEnterpriseApplicationImportDataModelProperties.HANDLED_PROJECT_MODELS_LIST"; //$NON-NLS-1$
-	
-	
+
+
 }
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEarComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEarComponentCreationDataModelProperties.java
index 23917f2..11a691f 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEarComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IEarComponentCreationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentCreationDataModelProperties.java
index df5a31c..0149579 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentCreationDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.datamodel.properties;
 
 
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentExportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentExportDataModelProperties.java
index d9d5940..c5b69a6 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentExportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentExportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentImportDataModelProperties.java
index 01128cb..9cc72c4 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEComponentImportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEModuleImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEModuleImportDataModelProperties.java
index 0d1abe4..3a8f005 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEModuleImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJ2EEModuleImportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaComponentCreationDataModelProperties.java
index 35993e3..d626b33 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaComponentCreationDataModelProperties.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.datamodel.properties;
 
 import org.eclipse.jst.j2ee.project.datamodel.properties.IJ2EEProjectServerTargetDataModelProperties;
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaUtilityJarImportDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaUtilityJarImportDataModelProperties.java
index 445f4c5..425a5f9 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaUtilityJarImportDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IJavaUtilityJarImportDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IUtilityJavaComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IUtilityJavaComponentCreationDataModelProperties.java
new file mode 100644
index 0000000..36492b9
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/datamodel/properties/IUtilityJavaComponentCreationDataModelProperties.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.datamodel.properties;
+
+
+/**
+ * <p>
+ * IJavaComponentCreationDataModelProperties provides properties to the 
+ * JavaComponentCreationDataModelProvider as well as all extending interfaces extending 
+ * IJavaComponentCreationDataModelProperties specifically, but not limited to all J2EE component related
+ * creation.
+ * @see org.eclipse.jst.j2ee.internal.archive.operations.JavaComponentCreationDataModelProvider
+ * </p>
+ * <p>
+ * This interface is not intended to be implemented by clients.
+ * </p>
+ * 
+ * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider
+ * @see org.eclipse.wst.common.frameworks.datamodel.DataModelFactory
+ * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProperties
+ * 
+ * @plannedfor 1.0
+ */
+public interface IUtilityJavaComponentCreationDataModelProperties extends IJavaComponentCreationDataModelProperties {
+	/**
+	 * Optional, type String
+     * String indicating the name of the the root Java Source Folder in the component being created.
+     * The DataModelProvider will default the Java Source Folder to the Component folder.
+     * 
+	 */
+	public static final String EAR_PROJECT_NAME = "IUtilityJavaComponentCreationDataModelProperties.EAR_PROJECT_NAME";
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientArchiveOpsResourceHandler.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientArchiveOpsResourceHandler.java
index b60a939..8111e91 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientArchiveOpsResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientArchiveOpsResourceHandler.java
@@ -1,53 +1,40 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
+import org.eclipse.osgi.util.NLS;
 
+public final class AppClientArchiveOpsResourceHandler extends NLS {
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+	private static final String BUNDLE_NAME = "appclientarchiveops";//$NON-NLS-1$
 
-public class AppClientArchiveOpsResourceHandler {
-
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("appclientarchiveops");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private AppClientArchiveOpsResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String ARCHIVE_OPERATION_SaveFile;
+	public static String ARCHIVE_OPERATION_ProjectNature;
+	public static String ARCHIVE_OPERATION_SaveManifest;
+	public static String ARCHIVE_OPERATION_FileNotFound;
+	public static String ARCHIVE_OPERATION_OpeningArchive;
+	public static String ARCHIVE_OPERATION_ImportOperation;
+	public static String IMPORT_MOFRESOURCE_STRING;
+	public static String APPCLIENT_IMPORT_OPERATION_STRING;
+	public static String APPCLIENT_IMPORT_FILE_STRING;
+	public static String APPCLIENT_IMPORT_ERROR;
+	public static String ARCHIVE_OPERATION_ErrorOccured;
+	public static String Application_Client_File_UI_;
+	public static String _c__Copyright_IBM_Corporation_2001_1;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, AppClientArchiveOpsResourceHandler.class);
 	}
-
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentExportOperation.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentExportOperation.java
index 5040f33..706eeec 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentExportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentExportOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -35,12 +35,12 @@
 		} catch (SaveFailureException ex) {
 			throw ex;
 		} catch (Exception e) {
-			throw new SaveFailureException(AppClientArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_OpeningArchive"), e);//$NON-NLS-1$
+			throw new SaveFailureException(AppClientArchiveOpsResourceHandler.ARCHIVE_OPERATION_OpeningArchive, e);
 		}
 	}
 
 	protected String archiveString() {
-		return AppClientArchiveOpsResourceHandler.getString("Application_Client_File_UI_"); //$NON-NLS-1$ = "Application Client File"
+		return AppClientArchiveOpsResourceHandler.Application_Client_File_UI_; 
 	}
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentImportOperation.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentImportOperation.java
index 2d147f4..5f88a95 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentImportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/AppClientComponentImportOperation.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
 import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.SaveStrategy;
@@ -23,4 +25,4 @@
 		return saveStrat;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentLoadStrategyImpl.java
index b86bdea..681e172 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentLoadStrategyImpl.java
@@ -16,14 +16,19 @@
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipException;
+import java.util.zip.ZipFile;
 
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
@@ -32,7 +37,9 @@
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.common.util.WrappedException;
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jem.util.emf.workbench.WorkbenchResourceHelperBase;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
@@ -42,13 +49,16 @@
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.wst.common.componentcore.UnresolveableURIException;
 import org.eclipse.wst.common.componentcore.internal.ComponentResource;
+import org.eclipse.wst.common.componentcore.internal.DependencyType;
 import org.eclipse.wst.common.componentcore.internal.StructureEdit;
 import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
 import org.eclipse.wst.common.componentcore.internal.impl.PlatformURLModuleConnection;
+import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent;
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualContainer;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
 import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
 import org.eclipse.wst.common.internal.emf.utilities.ExtendedEcoreUtil;
 
@@ -56,13 +66,15 @@
 
 	protected IVirtualComponent vComponent;
 	protected boolean exportSource;
-
+	private List zipFiles = new ArrayList();
+	
 	protected class FilesHolder {
 
 		private Map urisToFiles = new HashMap();
 		private Map urisToResources = new HashMap();
 		private Map resourcesToURI = new HashMap();
 		private Map urisToDiskFiles;
+		private Map urisToZipEntry = new HashMap();
 
 		public void removeIFile(IFile file) {
 			String uri = (String) resourcesToURI.get(file);
@@ -105,9 +117,24 @@
 
 			if (urisToDiskFiles != null && urisToDiskFiles.containsKey(uri)) {
 				diskFile = (java.io.File) urisToDiskFiles.get(uri);
-			} else {
+			} else if (urisToResources != null && urisToResources.containsKey(uri)){
 				IResource resource = (IResource) urisToResources.get(uri);
 				diskFile = new java.io.File(resource.getLocation().toOSString());
+			}else{
+				Map fileURIMap = (Map)urisToZipEntry.get(uri);
+				Iterator it = fileURIMap.keySet().iterator();
+				
+				String sourceFileUri = "";  //$NON-NLS-1$
+				ZipFile zipFile = null;
+				
+				//there is only one key, pair
+				while( it.hasNext()){
+					sourceFileUri = (String)it.next();
+					zipFile = (ZipFile)fileURIMap.get( sourceFileUri );
+				}
+				ZipEntry entry = zipFile.getEntry( sourceFileUri );
+				InputStream in = zipFile.getInputStream( entry );
+ 				return in;
 			}
 			return new FileInputStream(diskFile);
 		}
@@ -119,6 +146,27 @@
 		public boolean contains(String uri) {
 			return urisToFiles.containsKey(uri);
 		}
+
+		public void addEntry(ZipEntry entry, ZipFile zipFile, IPath runtimePath) {
+			String uri = runtimePath == null ? null : runtimePath.toString();
+			String fileURI = ""; //$NON-NLS-1$
+			if( uri != null ){
+				if( ! uri.equals("/") ) //$NON-NLS-1$
+					fileURI = uri + entry.getName();
+				else
+					fileURI = entry.getName();
+			}else{
+				fileURI = entry.getName();
+			}
+
+			File file = createFile( fileURI );
+			
+			Map fileURIMap = new HashMap();
+			fileURIMap.put( entry.getName(), zipFile );
+		
+			urisToZipEntry.put(file.getURI(), fileURIMap);
+			urisToFiles.put(file.getURI(), file);
+		}
 	}
 
 	protected FilesHolder filesHolder;
@@ -144,9 +192,39 @@
 	public List getFiles() {
 		aggregateSourceFiles();
 		aggregateClassFiles();
+		addUtilities();
 		return filesHolder.getFiles();
 	}
 
+	protected  void addUtilities(){
+		IVirtualReference[] components = vComponent.getReferences();
+		for (int i = 0; i < components.length; i++) {
+			IVirtualReference reference = components[i];
+			IVirtualComponent referencedComponent = reference.getReferencedComponent();
+			
+			if(referencedComponent.isBinary() && reference.getDependencyType() == DependencyType.CONSUMES){
+				java.io.File diskFile = ((VirtualArchiveComponent) referencedComponent).getUnderlyingDiskFile();
+				ZipFile zipFile;
+				IPath path = reference.getRuntimePath();
+				try {
+					zipFile = new ZipFile(diskFile);
+					zipFiles.add(zipFile);
+					Enumeration enumeration = zipFile.entries();
+					while(enumeration.hasMoreElements()){
+						ZipEntry entry = (ZipEntry)enumeration.nextElement();
+						filesHolder.addEntry(entry, zipFile, path);
+					}
+				} catch (ZipException e) {
+					Logger.getLogger().logError(e);
+				} catch (IOException e) {
+					Logger.getLogger().logError(e);
+				}
+			}
+		}		
+	}
+	
+		
+
 	protected void aggregateSourceFiles() {
 		try {
 			IVirtualFolder rootFolder = vComponent.getRootFolder();
@@ -164,6 +242,14 @@
 			se = StructureEdit.getStructureEditForRead(vComponent.getProject());
 			for (int i = 0; i < sourceRoots.length; i++) {
 				IPath outputPath = sourceRoots[i].getRawClasspathEntry().getOutputLocation();
+				if( outputPath == null ){
+					IProject project = vComponent.getProject();
+					if ( project.hasNature(JavaCore.NATURE_ID) ){
+						IJavaProject javaProject = JavaCore.create( project );
+						outputPath = javaProject.getOutputLocation();
+					}
+				}
+				
 				if (outputPath != null) {
 					IFolder javaOutputFolder = ResourcesPlugin.getWorkspace().getRoot().getFolder(outputPath);
 					IPath runtimePath = null;
@@ -178,7 +264,7 @@
 									tmpSourcePath = tmpSourcePath.removeLastSegments(1);
 								}
 								if (tmpRuntimePath.segmentCount() != 0) {
-									runtimePath = tmpRuntimePath;
+									runtimePath = tmpRuntimePath.makeRelative();
 								}
 							}
 						}
@@ -204,6 +290,9 @@
 	protected void aggregateOutputFiles(IResource[] resources, final IPath runtimePathPrefix, int outputFolderSegmentCount) throws CoreException {
 		for (int i = 0; i < resources.length; i++) {
 			File cFile = null;
+			if(!resources[i].exists()){
+				continue;
+			}
 			if (resources[i].getType() == IResource.FILE) {
 				// We have to avoid duplicates between the source and output folders (non-java
 				// resources)
@@ -211,7 +300,7 @@
 				String uri = runtimePath == null ? null : runtimePath.toString();
 				if (uri == null)
 					continue;
-				if (!shouldInclude(uri)) //$NON-NLS-1$
+				if (!shouldInclude(uri)) 
 					continue;
 				if (filesHolder.contains(uri))
 					continue;
@@ -228,6 +317,9 @@
 	protected void aggregateFiles(IVirtualResource[] virtualResources) throws CoreException {
 		for (int i = 0; i < virtualResources.length; i++) {
 			File cFile = null;
+			if(!virtualResources[i].exists()){
+				continue;
+			}
 			if (virtualResources[i].getType() == IVirtualResource.FILE) {
 				// We have to avoid duplicates between the source and output folders (non-java
 				// resources)
@@ -235,7 +327,7 @@
 				String uri = runtimePath == null ? null : runtimePath.toString();
 				if (uri == null)
 					continue;
-				if (!shouldInclude(uri)) //$NON-NLS-1$
+				if (!shouldInclude(uri)) 
 					continue;
 				if (filesHolder.contains(uri))
 					continue;
@@ -303,7 +395,7 @@
 			java.io.File file = new java.io.File(filePath);
 			return new FileInputStream(file);
 		}
-		String eString = EARArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_FileNotFound");//$NON-NLS-1$
+		String eString = EARArchiveOpsResourceHandler.ARCHIVE_OPERATION_FileNotFound;
 		throw new FileNotFoundException(eString);
 	}
 
@@ -347,5 +439,16 @@
 	public IVirtualComponent getComponent() {
 		return vComponent;
 	}
-
+	
+	public void close() {
+		Iterator it = zipFiles.iterator();
+		while( it.hasNext() ){
+			ZipFile file = (ZipFile) it.next();
+			try {
+				file.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}	
 }
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentSaveStrategyImpl.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentSaveStrategyImpl.java
index dd11244..3f13bf5 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentSaveStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ComponentSaveStrategyImpl.java
@@ -87,13 +87,13 @@
 
 	public void save(File aFile, InputStream in) throws SaveFailureException {
 		try {
-			String displayString = EJBArchiveOpsResourceHandler.getString("IMPORT_OPERATION_STRING"); //$NON-NLS-1$
+			String displayString = EJBArchiveOpsResourceHandler.IMPORT_OPERATION_STRING; 
 			progressMonitor.subTask(displayString + aFile.getURI());
 			saveToOutputPath(getOutputPathForFile(aFile), in);
 		} catch (OverwriteHandlerException ohe) {
 			throw ohe;
 		} catch (Exception e) {
-			String errorString = EJBArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_SaveFile") + aFile.getName(); //$NON-NLS-1$
+			String errorString = EJBArchiveOpsResourceHandler.ARCHIVE_OPERATION_SaveFile + aFile.getName(); 
 			throw new SaveFailureException(errorString, e);
 		}
 	}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/DependentJarExportMerger.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/DependentJarExportMerger.java
index 10fa317..6c5e888 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/DependentJarExportMerger.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/DependentJarExportMerger.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
 import java.util.ArrayList;
@@ -124,4 +126,4 @@
 			return false;
 		return !outgoingArchive.containsFile(uri) && !ArchiveConstants.MANIFEST_URI.equals(uri);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARArchiveOpsResourceHandler.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARArchiveOpsResourceHandler.java
index 87289bf..8dc663b 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARArchiveOpsResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARArchiveOpsResourceHandler.java
@@ -1,63 +1,47 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
+import org.eclipse.osgi.util.NLS;
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+public final class EARArchiveOpsResourceHandler extends NLS {
 
-public class EARArchiveOpsResourceHandler {
+	private static final String BUNDLE_NAME = "eararchiveops";//$NON-NLS-1$
 
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("eararchiveops");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private EARArchiveOpsResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String ARCHIVE_OPERATION_SaveMofResources;
+	public static String ARCHIVE_OPERATION_SaveFile;
+	public static String ARCHIVE_OPERATION_ProjectNature;
+	public static String ARCHIVE_OPERATION_SaveManifest;
+	public static String ARCHIVE_OPERATION_FileNotFound;
+	public static String ARCHIVE_OPERATION_FileContents;
+	public static String ARCHIVE_OPERATION_ErroOccured;
+	public static String ARCHIVE_OPERATION_FilesFromProject;
+	public static String ARCHIVE_OPERATION_OpeningArchive;
+	public static String ARCHIVE_OPERATION_ImportOperation;
+	public static String IMPORT_MOFRESOURCE_STRING;
+	public static String EAR_IMPORT_FILE_STRING;
+	public static String ERROR_IMPORTING_EAR_FILE;
+	public static String ERROR_EXPORTING_EAR_FILE;
+	public static String IMPORTING_EAR_FILE_UI_;
+	public static String Updating_project_classpath_UI_;
+	public static String UNABLE_TO_LOAD_MODULE_ERROR_;
+	public static String _jar_UI_;
+	public static String Updating_manifest_Class_Path__attributes_UI_;
+	public static String _preDeploy_ERROR_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, EARArchiveOpsResourceHandler.class);
 	}
-
-	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
-	}
-
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentExportOperation.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentExportOperation.java
index 62da680..df0a87c 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentExportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentExportOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -37,7 +37,7 @@
 		} catch (SaveFailureException ex) {
 			throw ex;
 		} catch (Exception e) {
-			throw new SaveFailureException(AppClientArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_OpeningArchive"), e);//$NON-NLS-1$
+			throw new SaveFailureException(AppClientArchiveOpsResourceHandler.ARCHIVE_OPERATION_OpeningArchive, e);
 		} finally {
 			if (null != artifactEdit) {
 				artifactEdit.dispose();
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentImportOperation.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentImportOperation.java
index b6e1303..0f0a8b2 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentImportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentImportOperation.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
 import java.io.FileNotFoundException;
@@ -27,9 +29,9 @@
 import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.SaveStrategy;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
+import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit;
 import org.eclipse.jst.j2ee.datamodel.properties.IEARComponentImportDataModelProperties;
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentImportDataModelProperties;
-import org.eclipse.jst.j2ee.internal.common.XMLResource;
 import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
@@ -39,6 +41,7 @@
 
 public class EARComponentImportOperation extends J2EEArtifactImportOperation {
 
+	protected EARArtifactEdit artifactEdit = null;
 
 	public EARComponentImportOperation(IDataModel model) {
 		super(model);
@@ -63,17 +66,17 @@
 			for (int i = 0; i < allModels.size(); i++) {
 				importModel = (IDataModel) allModels.get(i);
 				if (modelsToImport.contains(importModel)) {
-					String archiveUri = ((Archive)importModel.getProperty(IEARComponentImportDataModelProperties.FILE)).getURI();
+					String archiveUri = ((Archive) importModel.getProperty(IEARComponentImportDataModelProperties.FILE)).getURI();
 					importModel.setProperty(IJ2EEComponentImportDataModelProperties.CLOSE_ARCHIVE_ON_DISPOSE, Boolean.FALSE);
 					try {
 						importModel.getDefaultOperation().execute(monitor, info);
 					} catch (ExecutionException e) {
 						Logger.getLogger().logError(e);
 					}
-					IVirtualComponent component = (IVirtualComponent)importModel.getProperty(IJ2EEComponentImportDataModelProperties.COMPONENT);
+					IVirtualComponent component = (IVirtualComponent) importModel.getProperty(IJ2EEComponentImportDataModelProperties.COMPONENT);
 					componentToAdd.add(component);
 					componentToURIMap.put(component, archiveUri);
-					
+
 				}
 			}
 			if (componentToAdd.size() > 0) {
@@ -89,7 +92,12 @@
 				Logger.getLogger().logError(e);
 			}
 		} finally {
+			if (null != artifactEdit) {
+				artifactEdit.dispose();
+				artifactEdit = null;
+			}
 			resetDisposeImportModels();
+
 			// FileSet.printState();
 		}
 	}
@@ -117,6 +125,9 @@
 			Archive archive = (Archive) importModel.getProperty(IJ2EEComponentImportDataModelProperties.FILE);
 			String[] manifestClasspath = archive.getManifest().getClassPathTokenized();
 			if (manifestClasspath.length > 0) {
+				if (null == artifactEdit) {
+					artifactEdit = EARArtifactEdit.getEARArtifactEditForRead(earComponent.getProject());
+				}
 				List extraEntries = fixupClasspath(earComponent, manifestClasspath, new ArrayList(), archive, (IVirtualComponent) importModel.getProperty(IJ2EEComponentImportDataModelProperties.COMPONENT));
 				addToClasspath(importModel, extraEntries);
 				fixModuleReference(importModel, manifestClasspath);
@@ -150,11 +161,17 @@
 						}
 					}
 				} else {
-					String compSearchName = manifestURI.substring(0, manifestURI.length() - 4);
-					IVirtualReference vRef = earComponent.getReference(compSearchName);
-					if (null != vRef && nestedComponent.getProject() != vRef.getReferencedComponent().getProject()) {
-						IProject project = vRef.getReferencedComponent().getProject();
+					IVirtualComponent comp = artifactEdit.getModuleByManifestURI(manifestURI);
+					if (null != comp) {
+						IProject project = comp.getProject();
 						extraEntries.add(JavaCore.newProjectEntry(project.getFullPath(), true));
+					} else {
+						String compSearchName = manifestURI.substring(0, manifestURI.length() - 4);
+						IVirtualReference vRef = earComponent.getReference(compSearchName);
+						if (null != vRef && nestedComponent.getProject() != vRef.getReferencedComponent().getProject()) {
+							IProject project = vRef.getReferencedComponent().getProject();
+							extraEntries.add(JavaCore.newProjectEntry(project.getFullPath(), true));
+						}
 					}
 				}
 			}
@@ -162,18 +179,6 @@
 		return extraEntries;
 	}
 
-	private void releaseDeploymentDescriptor() {
-		try {
-			if (getEarFile() != null && getEarFile().isDeploymentDescriptorSet()) {
-				XMLResource res = (XMLResource) getEarFile().getDeploymentDescriptor().eResource();
-				if (res != null)
-					res.releaseFromRead();
-			}
-		} catch (Exception suppress) {
-			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(suppress);
-		}
-	}
-
 	protected SaveStrategy createSaveStrategy(IProject project) { // NOOP
 		return null;
 	}
@@ -185,4 +190,4 @@
 	protected EARFile getEarFile() {
 		return (EARFile) model.getProperty(IEARComponentImportDataModelProperties.FILE);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentLoadStrategyImpl.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentLoadStrategyImpl.java
index 07eefe9..6ee3004 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentLoadStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentLoadStrategyImpl.java
@@ -48,34 +48,36 @@
 			for (int i = 0; i < components.length; i++) {
 				IVirtualReference reference = components[i];
 				IVirtualComponent referencedComponent = reference.getReferencedComponent();
-				if (J2EEProjectUtilities.isApplicationClientProject(referencedComponent.getProject()) || J2EEProjectUtilities.isEJBProject(referencedComponent.getProject()) || J2EEProjectUtilities.isDynamicWebProject(referencedComponent.getProject()) || J2EEProjectUtilities.isJCAProject(referencedComponent.getProject())) {
-					ArtifactEdit componentArtifactEdit = null;
-					try {
-						componentArtifactEdit = ComponentUtilities.getArtifactEditForRead(referencedComponent);
-						Archive archive = ((EnterpriseArtifactEdit) componentArtifactEdit).asArchive(exportSource);
-						archive.setURI(earArtifactEdit.getModuleURI(referencedComponent));
-						filesHolder.addFile(archive);
-					} catch (OpenFailureException oe) {
-						Logger.getLogger().logError(oe);
-					} finally {
-						if (componentArtifactEdit != null) {
-							componentArtifactEdit.dispose();
-						}
-					}
-				} else if (J2EEProjectUtilities.isUtilityProject(referencedComponent.getProject())) {
-					try {
-						if (!referencedComponent.isBinary()) {
-							String uri = referencedComponent.getName() + ".jar"; //$NON-NLS-1$
-							Archive archive = J2EEProjectUtilities.asArchive(uri, referencedComponent.getProject(), exportSource);
+				if( !referencedComponent.isBinary() ){
+					if (J2EEProjectUtilities.isApplicationClientProject(referencedComponent.getProject()) || J2EEProjectUtilities.isEJBProject(referencedComponent.getProject()) || J2EEProjectUtilities.isDynamicWebProject(referencedComponent.getProject()) || J2EEProjectUtilities.isJCAProject(referencedComponent.getProject())) {
+						ArtifactEdit componentArtifactEdit = null;
+						try {
+							componentArtifactEdit = ComponentUtilities.getArtifactEditForRead(referencedComponent);
+							Archive archive = ((EnterpriseArtifactEdit) componentArtifactEdit).asArchive(exportSource);
+							archive.setURI(earArtifactEdit.getModuleURI(referencedComponent));
 							filesHolder.addFile(archive);
-						} else {
-							java.io.File diskFile = ((VirtualArchiveComponent) referencedComponent).getUnderlyingDiskFile();
-							String uri = diskFile.getName();
-							addExternalFile(uri, diskFile);
+						} catch (OpenFailureException oe) {
+							Logger.getLogger().logError(oe);
+						} finally {
+							if (componentArtifactEdit != null) {
+								componentArtifactEdit.dispose();
+							}
 						}
-					} catch (OpenFailureException e) {
-						Logger.getLogger().logError(e);
+					} else if (J2EEProjectUtilities.isUtilityProject(referencedComponent.getProject())) {
+						try {
+							if (!referencedComponent.isBinary()) {
+								String uri = referencedComponent.getName() + ".jar"; //$NON-NLS-1$
+								Archive archive = J2EEProjectUtilities.asArchive(uri, referencedComponent.getProject(), exportSource);
+								filesHolder.addFile(archive);
+							}
+						} catch (OpenFailureException e) {
+							Logger.getLogger().logError(e);
+						}
 					}
+				}else{
+					java.io.File diskFile = ((VirtualArchiveComponent) referencedComponent).getUnderlyingDiskFile();
+					String uri = diskFile.getName();
+					addExternalFile(uri, diskFile);					
 				}
 			}
 
@@ -90,10 +92,10 @@
 		String filename = uri.replace('/', java.io.File.separatorChar);
 		java.io.File file = new java.io.File(filename);
 		if (!file.exists()) {
-			throw new FileNotFoundException(CommonArchiveResourceHandler.getString("file_not_found_EXC_", (new Object[]{uri, file.getAbsolutePath()}))); //$NON-NLS-1$ = "URI Name: {0}; File name: {1}"
+			throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
 		}
 		if (file.isDirectory()) {
-			throw new FileNotFoundException(CommonArchiveResourceHandler.getString("file_not_found_EXC_", (new Object[]{uri, file.getAbsolutePath()}))); //$NON-NLS-1$ = "URI Name: {0}; File name: {1}"
+			throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
 		}
 		return new org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.ZipFileLoadStrategyImpl(file);
 	}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentSaveStrategyImpl.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentSaveStrategyImpl.java
index c3ca4e8..ad12f62 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentSaveStrategyImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EARComponentSaveStrategyImpl.java
@@ -105,7 +105,7 @@
 		saveFiles();
 		saveManifest();
 		saveMofResources();
-		progressMonitor.subTask(EARArchiveOpsResourceHandler.getString("Updating_project_classpath_UI_")); //$NON-NLS-1$ = "Updating project classpaths..."
+		progressMonitor.subTask(EARArchiveOpsResourceHandler.Updating_project_classpath_UI_); 
 		updateComponentClasspaths();
 
 	}
@@ -158,7 +158,7 @@
 		if (overwriteHandler != null) {
 			if (overwriteHandler.isOverwriteNone())
 				return false;
-			return ((super.shouldSave(uri)) && (!overwriteHandler.isOverwriteResources()) && (!overwriteHandler.isOverwriteAll()) && (overwriteHandler.shouldOverwrite(uri)));
+			return ((super.shouldSave(uri)) && (overwriteHandler.isOverwriteAll() ||overwriteHandler.isOverwriteResources() || overwriteHandler.shouldOverwrite(uri)));
 		}
 		return true;
 	}
@@ -173,7 +173,7 @@
 	 */
 	protected void updateProjectClasspath(Archive anArchive, IVirtualComponent component) {
 
-		String message = EARArchiveOpsResourceHandler.getString("Updating_project_classpath_UI_") + component.getName(); //$NON-NLS-1$ = "Updating project classpaths..."
+		String message = EARArchiveOpsResourceHandler.Updating_project_classpath_UI_ + component.getName(); 
 		progressMonitor.subTask(message);
 		List projectCpEntries = new ArrayList();
 		Set visited = new HashSet();
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EJBArchiveOpsResourceHandler.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EJBArchiveOpsResourceHandler.java
index f7b9cf6..8f0f800 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EJBArchiveOpsResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/EJBArchiveOpsResourceHandler.java
@@ -1,53 +1,52 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
+import org.eclipse.osgi.util.NLS;
 
+public final class EJBArchiveOpsResourceHandler extends NLS {
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+	private static final String BUNDLE_NAME = "ejbarchiveops";//$NON-NLS-1$
 
-public class EJBArchiveOpsResourceHandler {
-
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("ejbarchiveops");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private EJBArchiveOpsResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String ARCHIVE_OPERATION_SaveMofResources;
+	public static String ARCHIVE_OPERATION_SaveFile;
+	public static String ARCHIVE_OPERATION_ProjectNature;
+	public static String ARCHIVE_OPERATION_SaveManifest;
+	public static String ARCHIVE_OPERATION_FileNotFound;
+	public static String ARCHIVE_OPERATION_FileContents;
+	public static String ARCHIVE_OPERATION_ErroOccured;
+	public static String ARCHIVE_OPERATION_FilesFromProject;
+	public static String ARCHIVE_OPERATION_OpeningArchive;
+	public static String ARCHIVE_OPERATION_InvalidEJBJar;
+	public static String ARCHIVE_OPERATION_InvalidImportEJBJar;
+	public static String ARCHIVE_OPERATION_ImportOperation;
+	public static String EJB_IMPORT_OPERATION_STRING;
+	public static String EJB_IMPORT_FILE_STRING;
+	public static String IMPORT_MOFRESOURCE_STRING;
+	public static String IMPORT_OPERATION_STRING;
+	public static String ERROR_COPYING_FILES_FROM_ORIGINAL_JAR;
+	public static String ERROR_IMPORTING_MODULE_FILE;
+	public static String Yes_UI;
+	public static String No_UI;
+	public static String Yes_To_All_UI;
+	public static String Cancel_UI_;
+	public static String Error_exporting__UI_;
+	public static String EJB_Jar_File_UI_;
+	public static String Copy_Dep_JARS_UI;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, EJBArchiveOpsResourceHandler.class);
 	}
-
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/IOverwriteHandler.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/IOverwriteHandler.java
index c978f2e..b47b26e 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/IOverwriteHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/IOverwriteHandler.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -23,10 +23,10 @@
  * @author: Administrator
  */
 public interface IOverwriteHandler {
-	public static final String NO = EJBArchiveOpsResourceHandler.getString("No_UI"); //$NON-NLS-1$
-	public static final String YES = EJBArchiveOpsResourceHandler.getString("Yes_UI"); //$NON-NLS-1$
-	public static final String ALL = EJBArchiveOpsResourceHandler.getString("Yes_To_All_UI"); //$NON-NLS-1$
-	public static final String NONE = EJBArchiveOpsResourceHandler.getString("Cancel_UI_"); //$NON-NLS-1$
+	public static final String NO = EJBArchiveOpsResourceHandler.No_UI; 
+	public static final String YES = EJBArchiveOpsResourceHandler.Yes_UI; 
+	public static final String ALL = EJBArchiveOpsResourceHandler.Yes_To_All_UI; 
+	public static final String NONE = EJBArchiveOpsResourceHandler.Cancel_UI_; 
 
 	/**
 	 * Insert the method's description here. Creation date: (4/16/2001 3:13:38 PM)
@@ -139,4 +139,4 @@
 	 * @return boolean
 	 */
 	boolean shouldOverwriteWLProject(IProject fProject, java.lang.String uri);
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ImportOption.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ImportOption.java
index 2e23309..d2a63eb 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ImportOption.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/ImportOption.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -87,4 +87,4 @@
 		this.projectType = projectType;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactExportOperation.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactExportOperation.java
index 4bde1e9..68493d1 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactExportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactExportOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -70,7 +70,7 @@
 			}
 			export();
 		} catch (Exception e) {
-			throw new ExecutionException(EJBArchiveOpsResourceHandler.getString("Error_exporting__UI_") + archiveString(), e);
+			throw new ExecutionException(EJBArchiveOpsResourceHandler.Error_exporting__UI_ + archiveString(), e);
 		}
 		return OK_STATUS;
 	}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactImportOperation.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactImportOperation.java
index 52b231d..bd71ed0 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactImportOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/J2EEArtifactImportOperation.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
 import java.lang.reflect.InvocationTargetException;
@@ -104,7 +106,7 @@
 		} catch (OverwriteHandlerException oe) {
 			throw new InterruptedException();
 		} catch (Exception ex) {
-			throw new WFTWrappedException(ex, EJBArchiveOpsResourceHandler.getString("ERROR_IMPORTING_MODULE_FILE")); //$NON-NLS-1$
+			throw new WFTWrappedException(ex, EJBArchiveOpsResourceHandler.ERROR_IMPORTING_MODULE_FILE); 
 		}
 	}
 
@@ -183,4 +185,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/JavaComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/JavaComponentCreationDataModelProvider.java
index 2e79c26..1ed412e 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/JavaComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/JavaComponentCreationDataModelProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.archive.operations;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/OverwriteHandlerException.java b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/OverwriteHandlerException.java
index 5d32ca5..9ab5d92 100644
--- a/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/OverwriteHandlerException.java
+++ b/plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/operations/OverwriteHandlerException.java
@@ -18,6 +18,11 @@
  * @author: Administrator
  */
 public class OverwriteHandlerException extends RuntimeException {
+    /**
+     * Warning clean-up 12/05/2005
+     */   
+	private static final long serialVersionUID = 1651836694391641930L;
+
 	/**
 	 * OverwriteHandlerException constructor comment.
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee/build.properties b/plugins/org.eclipse.jst.j2ee/build.properties
index 9290f8d..72330db 100644
--- a/plugins/org.eclipse.jst.j2ee/build.properties
+++ b/plugins/org.eclipse.jst.j2ee/build.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -18,14 +18,15 @@
                META-INF/,\
                about.html
 source.. = j2eeplugin/,\
-                                common/,\
-                                commonedit/,\
-                                earproject/,\
-                                j2eecreation/,\
-                                archiveops/,\
-                                applicationedit/,\
-                                appclientcreation/,\
-                                property_files/
+           common/,\
+           commonedit/,\
+           earproject/,\
+           j2eecreation/,\
+           archiveops/,\
+           applicationedit/,\
+           appclientcreation/,\
+           property_files/,\
+           refactor/
 jars.compile.order = .
 src.includes = rose/,\
                schema,\
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CMPJavaChangeSynchronizationAdapter.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CMPJavaChangeSynchronizationAdapter.java
index 51e5f40..4e3fa5e 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CMPJavaChangeSynchronizationAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CMPJavaChangeSynchronizationAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -358,4 +358,4 @@
 		}
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModel.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModel.java
index 5269d2b..f58685d 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModel.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModel.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common;
 
 
@@ -290,8 +292,12 @@
 	 */
 	public void setSelection(ClasspathElement element, boolean selected) {
 		element.setSelected(selected);
-		if (!isWLPModel())
+		if (!isWLPModel()) {
 			updateManifestClasspath();
+		} else {
+			// at least fire the change event
+			fireNotification(new ClasspathModelEvent(ClasspathModelEvent.CLASS_PATH_CHANGED));
+		}
 	}
 
 	/**
@@ -344,6 +350,15 @@
 		archive.getManifest().setMainClass(mainClass);
 		fireNotification(new ClasspathModelEvent(ClasspathModelEvent.MAIN_CLASS_CHANGED));
 	}
+	
+	/**
+	 * Updates the manifest Main-Class:, and sends out a notification of type
+	 * {@link ClasspathModelEvent#MAIN_CLASS_CHANGED}
+	 */
+	public void updateImplVersion(String implVersion) {
+		archive.getManifest().setImplemenationVersion(implVersion);
+		fireNotification(new ClasspathModelEvent(ClasspathModelEvent.IMPL_VERSION_CHANGED));
+	}
 
 	public void fireSavedEvent() {
 		fireNotification(new ClasspathModelEvent(ClasspathModelEvent.MODEL_SAVED));
@@ -690,4 +705,4 @@
 		this.isWLPModel = isWLPModel;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModelEvent.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModelEvent.java
index 0ca2fa0..388409f 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModelEvent.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/ClasspathModelEvent.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common;
 
 
@@ -17,6 +19,7 @@
 	public static final int CLASS_PATH_RESET = 4;
 	public static final int MAIN_CLASS_CHANGED = 5;
 	public static final int MODEL_SAVED = 6;
+	public static final int IMPL_VERSION_CHANGED = 7;
 
 	/**
 	 * Constructor for ClasspathModelEvent.
@@ -36,4 +39,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CreationConstants.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CreationConstants.java
index 4a6bb93..8f6cf92 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CreationConstants.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/CreationConstants.java
@@ -1,9 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common;
 
 public interface CreationConstants {
 
-	String DEFAULT_WEB_SOURCE_FOLDER =	"JavaSource"; //$NON-NLS-1$ 
+	String DEFAULT_WEB_SOURCE_FOLDER =	"src"; //$NON-NLS-1$ 
 	String DEFAULT_EJB_SOURCE_FOLDER = "ejbModule";//$NON-NLS-1$
 	String DEFAULT_CONNECTOR_SOURCE_FOLDER = "connectorModule";//$NON-NLS-1$
-	String DEFAULT_APPCLIENT_SOURCE_FOLDER = "appClientModule";//$NON-NLS-1$ 	
+	String DEFAULT_APPCLIENT_SOURCE_FOLDER = "appClientModule";//$NON-NLS-1$ 
+	String EJB_CLIENT_NAME ="ClientProject";//$NON-NLS-1$ 
+	String CLIENT_JAR_URI="ClientJARURI";//$NON-NLS-1$ 
 }
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EECommonMessages.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EECommonMessages.java
index 544103a..bf57027 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EECommonMessages.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EECommonMessages.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -16,10 +16,7 @@
  */
 package org.eclipse.jst.j2ee.internal.common;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.wst.common.frameworks.internal.Messages;
+import org.eclipse.osgi.util.NLS;
 
 
 /**
@@ -28,62 +25,48 @@
  * To change the template for this generated type comment go to Window>Preferences>Java>Code
  * Generation>Code and Comments
  */
-public class J2EECommonMessages extends Messages {
-	public static final String ERR_SECURITY_ROLE_EMPTY = "ERR_SECURITY_ROLE_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_SECURITY_ROLE_EXIST = "ERR_SECURITY_ROLE_EXIST"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_NAME_EMPTY = "ERR_JAVA_CLASS_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_NAME_EXIST = "ERR_JAVA_CLASS_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FILE_NAME_EXIST = "ERR_JAVA_CLASS_FILE_NAME_EXIST"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FOLDER_NAME_EMPTY = "ERR_JAVA_CLASS_FOLDER_NAME_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FOLDER_PROJECT_NOT_OPEN = "ERR_JAVA_CLASS_FOLDER_PROJECT_NOT_OPEN"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FOLDER_NOT_EXIST = "ERR_JAVA_CLASS_FOLDER_NOT_EXIST"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_NOT_JAVA_PROJECT = "ERR_JAVA_CLASS_NOT_JAVA_PROJECT"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FOLDER_STATIC_PROJECT = "ERR_JAVA_CLASS_FOLDER_STATIC_PROJECT"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FOLDER_NOT_SOURCE = "ERR_JAVA_CLASS_FOLDER_NOT_SOURCE"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_FOLDER_NOT_ABSOLUTE = "ERR_JAVA_CLASS_FOLDER_NOT_ABSOLUTE"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_NAME_QUALIFIED = "ERR_JAVA_CLASS_NAME_QUALIFIED"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_NAME_INVALID = "ERR_JAVA_CLASS_NAME_INVALID"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_NAME_WARNING = "ERR_JAVA_CLASS_NAME_WARNING"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_SUPERCLASS_NOT_EXIST = "ERR_JAVA_CLASS_SUPERCLASS_NOT_EXIST"; //$NON-NLS-1$
-	public static final String ERR_JAVA_CLASS_SUPERCLASS_FINAL = "ERR_JAVA_CLASS_SUPERCLASS_FINAL"; //$NON-NLS-1$
-	public static final String ERR_JAVA_PACAKGE_NAME_INVALID = "ERR_JAVA_PACAKGE_NAME_INVALID"; //$NON-NLS-1$
-	public static final String ERR_JAVA_PACKAGE_NAME_WARNING = "ERR_JAVA_PACKAGE_NAME_WARNING"; //$NON-NLS-1$
-	public static final String ERR_BOTH_FINAL_AND_ABSTRACT = "ERR_BOTH_FINAL_AND_ABSTRACT"; //$NON-NLS-1$
-	public static final String ERR_SECURITY_ROLE_LIST_EMPTY = "ERR_SECURITY_ROLE_LIST_EMPTY"; //$NON-NLS-1$
-	public static final String ERR_EMPTY_MODULE_NAME = "ERR_EMPTY_MODULE_NAME"; //$NON-NLS-1$
-	public static final String ERR_EMPTY_PROJECT_NAME = "ERR_EMPTY_PROJECT_NAME"; //$NON-NLS-1$
+public class J2EECommonMessages extends NLS {
+	private static final String BUNDLE_NAME = "j2ee_common";//$NON-NLS-1$
 
-	public static final String ERR_PROJECT_NAME_EXISTS = "ERR_PROJECT_NAME_EXISTS"; //$NON-NLS-1$
-	public static final String ERR_VERSION_NOT_SUPPORTED ="ERR_VERSION_NOT_SUPPORTED";//$NON-NLS-1$
-	public static final String ERR_NOT_SUPPORTED="ERR_NOT_SUPPORTED";//$NON-NLS-1$	
-		
+	private J2EECommonMessages() {
+		// Do not instantiate
+	}
 
-	private static final J2EECommonMessages INSTANCE = new J2EECommonMessages();
+	public static String ERR_SECURITY_ROLE_EMPTY;
+	public static String ERR_SECURITY_ROLE_EXIST;
+	public static String ERR_JAVA_CLASS_NAME_EMPTY;
+	public static String ERR_JAVA_CLASS_NAME_EXIST;
+	public static String ERR_JAVA_CLASS_FILE_NAME_EXIST;
+	public static String ERR_JAVA_CLASS_FOLDER_NAME_EMPTY;
+	public static String ERR_JAVA_CLASS_FOLDER_PROJECT_NOT_OPEN;
+	public static String ERR_JAVA_CLASS_NOT_JAVA_PROJECT;
+	public static String ERR_JAVA_CLASS_FOLDER_STATIC_PROJECT;
+	public static String ERR_JAVA_CLASS_FOLDER_NOT_SOURCE;
+	public static String ERR_JAVA_CLASS_NAME_QUALIFIED;
+	public static String ERR_JAVA_CLASS_NAME_INVALID;
+	public static String ERR_JAVA_CLASS_NAME_WARNING;
+	public static String ERR_JAVA_CLASS_SUPERCLASS_NOT_EXIST;
+	public static String ERR_JAVA_CLASS_SUPERCLASS_FINAL;
+	public static String ERR_JAVA_PACAKGE_NAME_INVALID;
+	public static String ERR_JAVA_PACKAGE_NAME_WARNING;
+	public static String ERR_BOTH_FINAL_AND_ABSTRACT;
+	public static String WebServiceClientGenerator_UI_0;
+	public static String ERR_SECURITY_ROLE_LIST_EMPTY;
 
-	/**
-	 * Returns the string from the resource bundle, or 'key' if not found.
-	 */
-	public static String getResourceString(String key) {
-		return INSTANCE.doGetResourceString(key);
+	public static String ERR_JAVA_CLASS_FOLDER_NOT_EXIST;
+
+	public static String ERR_EMPTY_MODULE_NAME;
+	public static String ERR_EMPTY_PROJECT_NAME;
+	public static String ERR_PROJECT_NAME_EXISTS;
+	public static String ERR_VERSION_NOT_SUPPORTED;
+	public static String ERR_NOT_SUPPORTED;
+	public static String ERR_JAVA_CLASS_FOLDER_NOT_ABSOLUTE;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, J2EECommonMessages.class);
 	}
 
 	public static String getResourceString(String key, Object[] args) {
-		return INSTANCE.doGetResourceString(key, args);
+		return NLS.bind(key, args);
 	}
-
-	protected J2EECommonMessages() {
-		super();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.common.frameworks.internal.Messages#initializeBundle()
-	 */
-	protected void initializeBundle() {
-		try {
-			resourceBundle = ResourceBundle.getBundle("j2ee_common"); //$NON-NLS-1$
-		} catch (MissingResourceException x) {
-		}
-	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EEVersionUtil.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EEVersionUtil.java
index 5f0ec3a..f51d2e5 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EEVersionUtil.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/J2EEVersionUtil.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Mar 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/UpdateProjectClasspath.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/UpdateProjectClasspath.java
index 91958ca..9c95a7f 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/UpdateProjectClasspath.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/UpdateProjectClasspath.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -66,9 +66,11 @@
             List oldEntriesList,classpathList;
 			IClasspathEntry[] newEntries = getClasspathEntries(sourceFolder, componentName, 
 					jProject);
-			
-			int oldSize = oldEntries.length;
-			int newSize = newEntries.length;
+	         /**
+	          * Warning clean-up 12/05/2005
+	          */   
+			//int oldSize = oldEntries.length;
+			//int newSize = newEntries.length;
 			
 			classpathList = new ArrayList();
 			oldEntriesList = Arrays.asList(oldEntries);
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/VirtualArchiveComponentAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/VirtualArchiveComponentAdapterFactory.java
index 523cf94..a7b6a33 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/VirtualArchiveComponentAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/VirtualArchiveComponentAdapterFactory.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common;
 
 import org.eclipse.core.runtime.IAdapterFactory;
@@ -10,8 +20,7 @@
 	public Object getAdapter(Object adaptableObject, Class adapterType) {
 		if (adapterType == VirtualArchiveComponent.ADAPTER_TYPE ) {
 			VirtualArchiveComponent component = (VirtualArchiveComponent) adaptableObject;
-
-			IPath path = J2EEProjectUtilities.getResolvedPathForArchiveComponent(component.getProject().getName());
+			IPath path = J2EEProjectUtilities.getResolvedPathForArchiveComponent(component.getName());
 			return path;
 		}
 		return null;
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/INewJavaClassDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/INewJavaClassDataModelProperties.java
index 52d3acd..1d23d6c 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/INewJavaClassDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/INewJavaClassDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common.operations;
 
 import org.eclipse.wst.common.componentcore.internal.operation.IArtifactEditOperationDataModelProperties;
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/J2EEModifierHelperCreator.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/J2EEModifierHelperCreator.java
index 978e9a8..16fa74f 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/J2EEModifierHelperCreator.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/J2EEModifierHelperCreator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -192,4 +192,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProperties.java
index bc8bd37..dcd09de 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common.operations;
 
 import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProperties;
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProvider.java
index 3891e82..17113d9 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -24,6 +24,7 @@
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 
 
 /**
@@ -75,4 +76,7 @@
 		return ProjectUtilities.getProject(getStringProperty(OPPOSITE_PROJECT_NAME));
 	}
 
-}
\ No newline at end of file
+	public IDataModelOperation getDefaultOperation() {
+		return new JARDependencyOperation(model);
+	}	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyOperation.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyOperation.java
index b00b50c..a469cbc 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JARDependencyOperation.java
@@ -1,17 +1,21 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Sep 2, 2003
  *  
  */
 package org.eclipse.jst.j2ee.internal.common.operations;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 
 import org.eclipse.core.commands.ExecutionException;
@@ -145,13 +149,11 @@
 		try {
 			int jarManipulationType = model.getIntProperty(JARDependencyDataModelProperties.JAR_MANIPULATION_TYPE);
 			switch (jarManipulationType) {
-				case JARDependencyDataModelProperties.JAR_MANIPULATION_ADD : {
-					updateProjectDependency(proj, refproj);
-				}
-				
-				break;
+				case JARDependencyDataModelProperties.JAR_MANIPULATION_ADD :
+					updateProjectDependency(proj, refproj, true);
+					break;
 				case JARDependencyDataModelProperties.JAR_MANIPULATION_REMOVE : 
-
+					updateProjectDependency(proj, refproj, false);
 					break;
 				case JARDependencyDataModelProperties.JAR_MANIPULATION_INVERT :
 
@@ -169,31 +171,36 @@
 			return new IClasspathEntry[]{projectEntry};	
 	}	
 	
-	private void updateProjectDependency(IProject ejbProj, IProject clientProj){
+	private void updateProjectDependency(final IProject ejbProj, final IProject clientProj, final boolean add){
 		
-		IJavaProject javaProject = JavaCore.create( ejbProj );
+		final IJavaProject javaProject = JavaCore.create( ejbProj );
 		try {
-	
-			IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
-			IClasspathEntry[] newEntries = getProjectDependency( clientProj );
-			
-			int oldSize = oldEntries.length;
-			int newSize = newEntries.length;
-			
-			IClasspathEntry[] classpathEnties = new IClasspathEntry[oldSize + newSize];
-			int k = 0;
+			final IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
+			final IClasspathEntry[] entriesToChange = getProjectDependency( clientProj );
+			final List classpathEntries = new ArrayList();
 			for (int i = 0; i < oldEntries.length; i++) {
-				classpathEnties[i] = oldEntries[i];
-				k++;
+				if (!entryToChange(oldEntries[i], entriesToChange)) {
+					classpathEntries.add(oldEntries[i]);
+				}
 			}
-			for( int j=0; j< newEntries.length; j++){
-				classpathEnties[k] = newEntries[j];
-				k++;
+			if (add) {
+				for( int j=0; j< entriesToChange.length; j++){
+					classpathEntries.add(entriesToChange[j]);
+				}
 			}
-			javaProject.setRawClasspath(classpathEnties, null);
+			javaProject.setRawClasspath((IClasspathEntry[])classpathEntries.toArray(new IClasspathEntry[classpathEntries.size()]), null);
 		}
 		catch (JavaModelException e) {
 			Logger.getLogger().logError(e);
 		}		
 	}
-}
\ No newline at end of file
+	
+	private boolean entryToChange(final IClasspathEntry entry, final IClasspathEntry[] entriesToChange) {
+		for (int i = 0; i < entriesToChange.length; i++) {
+			if (entriesToChange[i].equals(entry)) {
+				return true;
+			}
+		}
+		return false;
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JavaModelUtil.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JavaModelUtil.java
index e28cdfc..da2e94a 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JavaModelUtil.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/JavaModelUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -770,4 +770,4 @@
 
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassDataModelProvider.java
index 987c5aa..cd2cf31 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -73,29 +73,29 @@
 	protected IStatus validateJavaSourceFolder(String folderFullPath) {
 		// Ensure that the source folder path is not empty
 		if (folderFullPath == null || folderFullPath.length() == 0) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NAME_EMPTY);
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NAME_EMPTY;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		// Ensure that the source folder path is absolute
 		else if (!new Path(folderFullPath).isAbsolute()) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_ABSOLUTE);
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_ABSOLUTE;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		IProject project = getTargetProject();
 		// Ensure project is not closed
 		if (project == null) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_EXIST);
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_EXIST;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		// Ensure project is accessible.
 		if (!project.isAccessible()) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_EXIST);
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_FOLDER_NOT_EXIST;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		// Ensure the project is a java project.
 		try {
 			if (!project.hasNature(JavaCore.NATURE_ID)) {
-				String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_NOT_JAVA_PROJECT);
+				String msg = J2EECommonMessages.ERR_JAVA_CLASS_NOT_JAVA_PROJECT;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 		} catch (CoreException e) {
@@ -282,10 +282,10 @@
 			// Use standard java conventions to validate the package name
 			IStatus javaStatus = JavaConventions.validatePackageName(packName);
 			if (javaStatus.getSeverity() == IStatus.ERROR) {
-				String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_PACAKGE_NAME_INVALID) + javaStatus.getMessage();
+				String msg = J2EECommonMessages.ERR_JAVA_PACAKGE_NAME_INVALID + javaStatus.getMessage();
 				return WTPCommonPlugin.createErrorStatus(msg);
 			} else if (javaStatus.getSeverity() == IStatus.WARNING) {
-				String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_PACKAGE_NAME_WARNING) + javaStatus.getMessage();
+				String msg = J2EECommonMessages.ERR_JAVA_PACKAGE_NAME_WARNING + javaStatus.getMessage();
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 		}
@@ -306,16 +306,16 @@
 	protected IStatus validateJavaClassName(String className) {
 		// Do not allow qualified name
 		if (className.lastIndexOf('.') != -1) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_NAME_QUALIFIED);
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_QUALIFIED;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		// Check Java class name by standard java conventions
 		IStatus javaStatus = JavaConventions.validateJavaTypeName(className);
 		if (javaStatus.getSeverity() == IStatus.ERROR) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_NAME_INVALID) + javaStatus.getMessage();
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_INVALID + javaStatus.getMessage();
 			return WTPCommonPlugin.createErrorStatus(msg);
 		} else if (javaStatus.getSeverity() == IStatus.WARNING) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_NAME_WARNING) + javaStatus.getMessage();
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_WARNING + javaStatus.getMessage();
 			return WTPCommonPlugin.createWarningStatus(msg);
 		}
 		return WTPCommonPlugin.OK_STATUS;
@@ -334,7 +334,7 @@
 	private IStatus validateSuperclass(String superclassName) {
 		// Ensure the superclass name is not empty
 		if (superclassName == null || superclassName.trim().length() == 0) {
-			String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_NAME_EMPTY);
+			String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_EMPTY;
 			return WTPCommonPlugin.createErrorStatus(msg);
 		}
 		// In default case of Object, return OK right away
@@ -358,7 +358,7 @@
 				// Just throw error below
 			}
 			if (supertype == null) {
-				String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_SUPERCLASS_NOT_EXIST);
+				String msg = J2EECommonMessages.ERR_JAVA_CLASS_SUPERCLASS_NOT_EXIST;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 			// Ensure the superclass is not final
@@ -366,7 +366,7 @@
 			try {
 				flags = supertype.getFlags();
 				if (Modifier.isFinal(flags)) {
-					String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_SUPERCLASS_FINAL);
+					String msg = J2EECommonMessages.ERR_JAVA_CLASS_SUPERCLASS_FINAL;
 					return WTPCommonPlugin.createErrorStatus(msg);
 				}
 			} catch (Exception e) {
@@ -392,12 +392,12 @@
 		if (prop) {
 			// Ensure final is not also checked
 			if (propertyName.equals(MODIFIER_ABSTRACT) && getBooleanProperty(MODIFIER_FINAL)) {
-				String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_BOTH_FINAL_AND_ABSTRACT);
+				String msg = J2EECommonMessages.ERR_BOTH_FINAL_AND_ABSTRACT;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 			// Ensure abstract is not also checked
 			if (propertyName.equals(MODIFIER_FINAL) && getBooleanProperty(MODIFIER_ABSTRACT)) {
-				String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_BOTH_FINAL_AND_ABSTRACT);
+				String msg = J2EECommonMessages.ERR_BOTH_FINAL_AND_ABSTRACT;
 				return WTPCommonPlugin.createErrorStatus(msg);
 			}
 		}
@@ -426,7 +426,7 @@
 				ICompilationUnit cu = pack.getCompilationUnit(className + ".java"); //$NON-NLS-1$
 				IResource resource = cu.getResource();
 				if (resource.exists()) {
-					String msg = J2EECommonMessages.getResourceString(J2EECommonMessages.ERR_JAVA_CLASS_NAME_EXIST);
+					String msg = J2EECommonMessages.ERR_JAVA_CLASS_NAME_EXIST;
 					return WTPCommonPlugin.createErrorStatus(msg);
 				}
 			}
@@ -502,4 +502,4 @@
 		}
 		return result;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassOperation.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassOperation.java
index 92fdd2a..d896714 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/NewJavaClassOperation.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.common.operations;
 
 import java.io.ByteArrayInputStream;
@@ -173,7 +175,7 @@
 		// Retrieve the package name from the java class data model
 		String packageName = model.getStringProperty(INewJavaClassDataModelProperties.JAVA_PACKAGE);
 		IPackageFragmentRoot packRoot = (IPackageFragmentRoot) model.getProperty(INewJavaClassDataModelProperties.JAVA_PACKAGE_FRAGMENT_ROOT);
-		IPackageFragment pack = packRoot.getPackageFragment(packageName);
+		IPackageFragment pack =	packRoot.getPackageFragment(packageName);
 		// Handle default package
 		if (pack == null) {
 			pack = packRoot.getPackageFragment(""); //$NON-NLS-1$
@@ -816,4 +818,4 @@
 	protected boolean implementImplementedMethod(IMethod method) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/UpdateJavaBuildPathOperation.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/UpdateJavaBuildPathOperation.java
index 908e95f..f1cdc00 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/UpdateJavaBuildPathOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/common/operations/UpdateJavaBuildPathOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -256,4 +256,4 @@
 		projDesc.setReferencedProjects((IProject[]) newRefs.toArray(new IProject[newRefs.size()]));
 		proj.setDescription(projDesc, monitor);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/DefaultWSDLServiceHelper.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/DefaultWSDLServiceHelper.java
index 842bc61..6e449ca 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/DefaultWSDLServiceHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/DefaultWSDLServiceHelper.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtManager.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtManager.java
index b751bea..369c7b9 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtManager.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtManager.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.webservices;
 
 public class WSDLServiceExtManager {
@@ -27,4 +29,4 @@
 		super();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtensionRegistry.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtensionRegistry.java
index 1ee72f3..c006c96 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtensionRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceExtensionRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -68,4 +68,4 @@
 		WSDLServiceExtManager.registerWSDLServiceHelper(ext);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceHelper.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceHelper.java
index c15d1ed..be95217 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WSDLServiceHelper.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Feb 21, 2005
  *
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServiceClientGenerator.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServiceClientGenerator.java
index 5d0d07f..5797b89 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServiceClientGenerator.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServiceClientGenerator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -25,7 +25,7 @@
  */
 public abstract class WebServiceClientGenerator {
 
-	public static final String GENERIC_J2EE_CONTAINER = J2EECommonMessages.getResourceString("WebServiceClientGenerator_UI_0"); //$NON-NLS-1$
+	public static final String GENERIC_J2EE_CONTAINER = J2EECommonMessages.WebServiceClientGenerator_UI_0;
 
 	private List runtime = null;
 
@@ -53,4 +53,4 @@
 		return getServerTargets().contains(serverTargetID);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataHelper.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataHelper.java
index 23162f4..909295e 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -75,4 +75,4 @@
 	 * Set whether descriptors were generated
 	 */
 	public void setDidGenDescriptors(boolean b);
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataRegistry.java b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataRegistry.java
index 8093842..67160f6 100644
--- a/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee/common/org/eclipse/jst/j2ee/internal/webservices/WebServicesClientDataRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -83,4 +83,4 @@
 			wsClientDataExtensions = new ArrayList();
 		return wsClientDataExtensions;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapter.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapter.java
index da8d268..1b321b0 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapter.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -113,4 +113,4 @@
 		}
 		return CommonEditResourceHandler.getString("16concat_UI_", (new Object[]{((EReference) localChildrenReferences.iterator().next()).getEType().getName(), refObject.eClass().getName()})); //$NON-NLS-1$ = "Create a child of type {0} for the selected {1}."
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapterFactory.java
index b989d2e..27a6a5e 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CommonItemProviderAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -559,4 +559,4 @@
 	public void setParentAdapterFactory(ComposedAdapterFactory parentAdapterFactory) {
 		this.parentAdapterFactory = parentAdapterFactory;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CompatibilityDescriptionGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CompatibilityDescriptionGroupItemProvider.java
index f48eb34..9158a3a 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CompatibilityDescriptionGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/CompatibilityDescriptionGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -170,4 +170,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionGroupItemProvider.java
index 2169a0b..b4d292f 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -156,4 +156,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionItemProvider.java
index 6883fae..03f2ee4 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DescriptionItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -144,4 +144,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DisplayNameItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DisplayNameItemProvider.java
index ac5c56b..c1bd1e6 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DisplayNameItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/DisplayNameItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -143,4 +143,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EJBLocalRefItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EJBLocalRefItemProvider.java
index 765ba76..620d824 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EJBLocalRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EJBLocalRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -140,4 +140,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EjbRefItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EjbRefItemProvider.java
index 7e8c00b..05365e7 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EjbRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EjbRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -53,7 +53,7 @@
 	 */
 	public Object getImage(Object object) {
 		String key = ((EjbRef) object).isLocal() ? "ejb_local_ref_obj" : "ejb_reference"; //$NON-NLS-1$ //$NON-NLS-2$
-		return J2EEPlugin.getPlugin().getImage(key); //$NON-NLS-1$
+		return J2EEPlugin.getPlugin().getImage(key); 
 	}
 
 	/**
@@ -293,4 +293,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EnvEntryItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EnvEntryItemProvider.java
index 4a810d1..4331c43 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EnvEntryItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/EnvEntryItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -241,4 +241,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IconTypeItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IconTypeItemProvider.java
index 3f3e81d..18a8cd2 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IconTypeItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IconTypeItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -160,4 +160,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IdentityItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IdentityItemProvider.java
index ad1221f..a9e139b 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IdentityItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/IdentityItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -173,4 +173,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/JNDIEnvRefsGroupItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/JNDIEnvRefsGroupItemProvider.java
index 90956fb..9ac243d 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/JNDIEnvRefsGroupItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/JNDIEnvRefsGroupItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -187,4 +187,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ListenerItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ListenerItemProvider.java
index bb4d97a..86c3d02 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ListenerItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ListenerItemProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.common.internal.provider;
 
 import java.util.Collection;
@@ -117,4 +119,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationItemProvider.java
index d774c4e..c253268 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -130,4 +130,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationRefItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationRefItemProvider.java
index 14c32e5..76513c5 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/MessageDestinationRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -194,4 +194,4 @@
 	public boolean hasChildren(Object arg0) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ParamValueItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ParamValueItemProvider.java
index 4687a1c..fea85b4 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ParamValueItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ParamValueItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -184,4 +184,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/QNameItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/QNameItemProvider.java
index 8f0659c..8c7ec49 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/QNameItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/QNameItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -173,4 +173,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceEnvRefItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceEnvRefItemProvider.java
index 062ac87..b7680b5 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceEnvRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceEnvRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -199,4 +199,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceRefItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceRefItemProvider.java
index b5abbf6..9d56418 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/ResourceRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -278,4 +278,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/RunAsSpecifiedIdentityItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/RunAsSpecifiedIdentityItemProvider.java
index f691951..aac1e6f 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/RunAsSpecifiedIdentityItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/RunAsSpecifiedIdentityItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -133,4 +133,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityIdentityItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityIdentityItemProvider.java
index 7e4cd58..05363da 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityIdentityItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityIdentityItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -157,4 +157,4 @@
 	public ResourceLocator getResourceLocator() {
 		return J2EEPlugin.getDefault();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleItemProvider.java
index e0f456e..c510a5e 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -200,4 +200,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleRefItemProvider.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleRefItemProvider.java
index 0541fff..0d63afa 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleRefItemProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/common/internal/provider/SecurityRoleRefItemProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -198,4 +198,4 @@
 	public boolean hasChildren(Object object) {
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/IStructuredTextEditingDomain.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/IStructuredTextEditingDomain.java
index 122c1a9..b2f9882 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/IStructuredTextEditingDomain.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/IStructuredTextEditingDomain.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -40,4 +40,4 @@
 	public IStructuredTextUndoManager getUndoManager();
 
 	public void setUndoManager(IStructuredTextUndoManager newUndoManager);
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/StructuredTextEditingDomain.java b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/StructuredTextEditingDomain.java
index 471f246..ff54dbe 100644
--- a/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/StructuredTextEditingDomain.java
+++ b/plugins/org.eclipse.jst.j2ee/commonedit/org/eclipse/jst/j2ee/internal/common/StructuredTextEditingDomain.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -85,4 +85,4 @@
 		undoManager = newUndoManager;
 		undoManager.setCommandStack(commandStack);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationDataModelProvider.java
index 7a666e3..a1d2e1c 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationDataModelProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 import java.util.HashMap;
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationOp.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationOp.java
index ce7ab25..4358e13 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationOp.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddComponentToEnterpriseApplicationOp.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 import java.util.List;
@@ -45,7 +55,9 @@
 		StructureEdit se = null;
 		try {
 			IVirtualComponent sourceComp = (IVirtualComponent) model.getProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT);
-			earEdit = EARArtifactEdit.getEARArtifactEditForWrite(sourceComp.getProject());
+			//TEMP workaround for use during ear creation before facet is added, this should be reverted when 115924 is fixed.
+			earEdit = new EARArtifactEdit(sourceComp.getProject(), false, true);
+			//earEdit = EARArtifactEdit.getEARArtifactEditForWrite(sourceComp.getProject());
 			se = StructureEdit.getStructureEditForWrite(sourceComp.getProject());
 			if (earEdit != null) {
 				Application application = earEdit.getApplication();
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddWebComponentToEARDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddWebComponentToEARDataModelProvider.java
index 6b13f3e..f81af61 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddWebComponentToEARDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AddWebComponentToEARDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -83,7 +83,7 @@
 	 */
 	public IStatus validateContextRoot(String contextRoot) {
 		if (contextRoot.equals("") || contextRoot == null) { //$NON-NLS-1$
-			return J2EEPlugin.newErrorStatus(ProjectSupportResourceHandler.getString("Context_Root_cannot_be_empty_2", new Object[]{contextRoot}), null); //$NON-NLS-1$
+			return J2EEPlugin.newErrorStatus(ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Context_Root_cannot_be_empty_2, new Object[]{contextRoot}), null); 
 		} else if (contextRoot.trim().equals(contextRoot)) {
 			StringTokenizer stok = new StringTokenizer(contextRoot, "."); //$NON-NLS-1$
 			while (stok.hasMoreTokens()) {
@@ -91,13 +91,13 @@
 				for (int i = 0; i < token.length(); i++) {
 					if (!(token.charAt(i) == '_') && !(token.charAt(i) == '-') && !(token.charAt(i) == '/') && Character.isLetterOrDigit(token.charAt(i)) == false) {
 						Object[] invalidChar = new Object[]{(new Character(token.charAt(i))).toString()};
-						String errorStatus = ProjectSupportResourceHandler.getString("The_character_is_invalid_in_a_context_root", invalidChar); //$NON-NLS-1$
+						String errorStatus = ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.The_character_is_invalid_in_a_context_root, invalidChar); 
 						return J2EEPlugin.newErrorStatus(errorStatus, null);
 					}
 				}
 			}
 		} else
-			return J2EEPlugin.newErrorStatus(ProjectSupportResourceHandler.getString("Names_cannot_begin_or_end_with_whitespace_5", new Object[]{contextRoot}), null); //$NON-NLS-1$
+			return J2EEPlugin.newErrorStatus(ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Names_cannot_begin_or_end_with_whitespace_5, new Object[]{contextRoot}), null); 
 		return OK_STATUS;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AppClientComponentExportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AppClientComponentExportDataModelProvider.java
index 560587f..8b23858 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AppClientComponentExportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/AppClientComponentExportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClassPathSelection.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClassPathSelection.java
index 699df87..b3f949e 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClassPathSelection.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClassPathSelection.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 
@@ -20,8 +22,10 @@
 import java.util.List;
 import java.util.Map;
 
+import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jem.util.logger.proxy.Logger;
@@ -46,6 +50,7 @@
 import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
 
 
+
 public class ClassPathSelection {
 	protected Archive archive;
 	protected IProject earProject;
@@ -114,6 +119,15 @@
 		element.setText(uriString);
 		element.setTargetArchive(referencedArchive);
 		element.setEarProject(earProject);
+		if( earComponent != null ){
+			IContainer earConentFolder = earComponent.getRootFolder().getUnderlyingFolder();
+			if( earConentFolder.getType() == IResource.FOLDER ){
+				element.setEarContentFolder( earConentFolder.getName());
+			}else {
+				element.setEarContentFolder( "" );
+			}
+		}
+	
 		setProjectValues(element, referencedArchive);
 		if (cpEntry != null)
 			element.setValuesSelected(cpEntry);
@@ -352,7 +366,10 @@
 				IVirtualComponent referencedComponent = ref.getReferencedComponent();
 				boolean isBinary = referencedComponent.isBinary();
 				if( isBinary ){
-					String uri = J2EEProjectUtilities.getResolvedPathForArchiveComponent(referencedComponent.getName()).toString();
+			         /**
+			          * Warning clean-up 12/05/2005
+			          */   
+					//String uri = J2EEProjectUtilities.getResolvedPathForArchiveComponent(referencedComponent.getName()).toString();
 					String unresolvedURI = "";
 					try {
 						unresolvedURI = ModuleURIUtil.getArchiveName(URI.createURI(ModuleURIUtil.getHandleString(referencedComponent)));
@@ -398,7 +415,10 @@
 	}
 		
 	protected List loadClassPathArchives(){
-		LoadStrategy loadStrat = archive.getLoadStrategy();
+        /**
+         * Warning clean-up 12/05/2005
+         */   
+		//LoadStrategy loadStrat = archive.getLoadStrategy();
 		
 		List archives = new ArrayList();
 		
@@ -458,7 +478,10 @@
 			
 			String archiveURIString = anArchive.getURI();
 			URI archiveURI = URI.createURI(archiveURIString);
-			boolean hasAbsolutePath = archiveURI.hasAbsolutePath();
+	         /**
+	          * Warning clean-up 12/05/2005
+	          */   
+			//boolean hasAbsolutePath = archiveURI.hasAbsolutePath();
 			if( archiveURI.lastSegment().equals(uri) ){
 				return true;
 			}
@@ -470,10 +493,10 @@
 		String filename = uri.replace('/', java.io.File.separatorChar);
 		java.io.File file = new java.io.File(filename);
 		if (!file.exists()) {
-			throw new FileNotFoundException(CommonArchiveResourceHandler.getString("file_not_found_EXC_", (new Object[]{uri, file.getAbsolutePath()}))); //$NON-NLS-1$ = "URI Name: {0}; File name: {1}"
+			throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
 		}
 		if (file.isDirectory()) {
-			throw new FileNotFoundException(CommonArchiveResourceHandler.getString("file_not_found_EXC_", (new Object[]{uri, file.getAbsolutePath()}))); //$NON-NLS-1$ = "URI Name: {0}; File name: {1}"
+			throw new FileNotFoundException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.file_not_found_EXC_, (new Object[]{uri, file.getAbsolutePath()}))); // = "URI Name: {0}; File name: {1}"
 		}
 		return new org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.ZipFileLoadStrategyImpl(file);
 	}
@@ -823,4 +846,4 @@
 		return urisToElements;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClasspathElement.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClasspathElement.java
index c346a3c..e4e0e83 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClasspathElement.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ClasspathElement.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 
@@ -65,6 +67,7 @@
 	protected IProject earProject;
 	protected ClassPathSelection parentSelection;
 	protected URI archiveURI;
+	protected String earContentFolder;
 
 	public ClasspathElement(Archive anArchive) {
 		super();
@@ -236,7 +239,7 @@
 	}
 
 	protected IClasspathEntry newClasspathEntryFromEARProj() {
-        IPath path = earProject.getFullPath().append(earProject.getFile(getText()).getFullPath());
+		IPath path = earProject.getFullPath().append( getEarContentFolder() + IPath.SEPARATOR + earProject.getFile(getText()).getProjectRelativePath());
 		return JavaCore.newLibraryEntry(path, path, null, true);
 	}
 
@@ -436,4 +439,12 @@
 		return archiveURI;
 	}
 
-}
\ No newline at end of file
+	public String getEarContentFolder() {
+		return earContentFolder;
+	}
+
+	public void setEarContentFolder(String earContentFolder) {
+		this.earContentFolder = earContentFolder;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/DefaultJ2EEComponentCreationOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/DefaultJ2EEComponentCreationOperation.java
index d515436..4897a96 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/DefaultJ2EEComponentCreationOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/DefaultJ2EEComponentCreationOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,7 +18,6 @@
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jem.util.logger.proxy.Logger;
-import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.earcreation.IDefaultJ2EEComponentCreationDataModelProperties;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
@@ -38,34 +37,21 @@
 
     public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
         try {
-            IDataModel model = getDataModel();
             if (model.getBooleanProperty(CREATE_EJB)) {
-                IDataModel ejbModel = model.getNestedModel(NESTED_MODEL_EJB);
-                ejbModel.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_NAME, model.getStringProperty(EJB_COMPONENT_NAME));
-                ejbModel.setProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME, model.getStringProperty(EJB_COMPONENT_NAME));
-                ejbModel.setProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, Boolean.FALSE);
-                createEJBComponent(ejbModel, monitor);
+                IDataModel projectModel = model.getNestedModel(NESTED_MODEL_EJB);
+                createEJBComponent(projectModel, monitor);
             }
             if (model.getBooleanProperty(CREATE_WEB)) {
-                IDataModel webModel = model.getNestedModel(NESTED_MODEL_WEB);
-                webModel.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_NAME, model.getStringProperty(WEB_COMPONENT_NAME));
-                webModel.setProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME, model.getStringProperty(WEB_COMPONENT_NAME));
-                webModel.setProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, Boolean.FALSE);
-                createWebJ2EEComponent(webModel, monitor);
+                IDataModel projectModel = model.getNestedModel(NESTED_MODEL_WEB);
+                createWebJ2EEComponent(projectModel, monitor);
             }
             if (model.getBooleanProperty(CREATE_CONNECTOR)) {
-                IDataModel conModel = model.getNestedModel(NESTED_MODEL_JCA);
-                conModel.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_NAME, model.getStringProperty(CONNECTOR_COMPONENT_NAME));
-                conModel.setProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME, model.getStringProperty(CONNECTOR_COMPONENT_NAME));
-                conModel.setProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, Boolean.FALSE);
-                createRarJ2EEComponent(conModel, monitor);
+                IDataModel projectModel = model.getNestedModel(NESTED_MODEL_JCA);
+                createRarJ2EEComponent(projectModel, monitor);
             }
             if (model.getBooleanProperty(CREATE_APPCLIENT)) {
-                IDataModel clientModel = model.getNestedModel(NESTED_MODEL_CLIENT);
-                clientModel.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_NAME, model.getStringProperty(APPCLIENT_COMPONENT_NAME));
-                clientModel.setProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME, model.getStringProperty(APPCLIENT_COMPONENT_NAME));
-                clientModel.setProperty(IJ2EEComponentCreationDataModelProperties.ADD_TO_EAR, Boolean.FALSE);
-                createAppClientComponent(clientModel, monitor);
+                IDataModel projectModel = model.getNestedModel(NESTED_MODEL_CLIENT);
+                createAppClientComponent(projectModel, monitor);
             }
         } catch (Exception e) {
             Logger.getLogger().log(e.getMessage());
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentExportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentExportDataModelProvider.java
index 994259a..52037bf 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentExportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentExportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentImportDataModelProvider.java
index e18a462..53b9f35 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/EARComponentImportDataModelProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 import java.util.ArrayList;
@@ -15,7 +17,6 @@
 import java.util.List;
 import java.util.Set;
 
-import org.eclipse.core.internal.localstore.CoreFileSystemLibrary;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IPath;
@@ -55,6 +56,7 @@
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelListener;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+import org.eclipse.wst.common.frameworks.internal.WTPPlugin;
 import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
 import org.eclipse.wst.server.core.IRuntime;
 import org.eclipse.wst.server.core.ServerCore;
@@ -206,17 +208,6 @@
 		return doSet;
 	}
 
-	private List getUtilitiesForMetaDataImport(EARFile earFile) {
-		List list = getAllUtilitiesExceptEJBClients(earFile);
-		for (int i = list.size() - 1; i > -1; i--) {
-			Archive archive = (Archive) list.get(i);
-			if (!archive.containsFile(".project")) { //$NON-NLS-1$
-				list.remove(archive);
-			}
-		}
-		return list;
-	}
-
 	public List getAllUtilitiesExceptEJBClients(EARFile earFile) {
 		List clientList = (List) getProperty(EJB_CLIENT_LIST);
 		List list = getAllUtilities(earFile);
@@ -290,14 +281,14 @@
 				}
 				if (tempProjectName.equals(earProjectName)) {
 					return WTPCommonPlugin.createErrorStatus(EARCreationResourceHandler.getString("EARImportDataModel_UI_1", new Object[]{tempProjectName, tempArchive.getURI()})); //$NON-NLS-1$
-				} else if (!CoreFileSystemLibrary.isCaseSensitive()) {
+				} else if (!WTPPlugin.isPlatformCaseSensitive()) {
 					if (tempProjectName.toLowerCase().equals(earProjectName.toLowerCase())) {
 						return WTPCommonPlugin.createErrorStatus(EARCreationResourceHandler.getString("EARImportDataModel_UI_1", new Object[]{tempProjectName, tempArchive.getURI()})); //$NON-NLS-1$
 					}
 				}
 				if (projects.containsKey(tempProjectName)) {
 					return WTPCommonPlugin.createErrorStatus(EARCreationResourceHandler.getString("EARImportDataModel_UI_2", new Object[]{tempProjectName, tempArchive.getURI(), ((Archive) projects.get(tempProjectName)).getURI()})); //$NON-NLS-1$
-				} else if (!CoreFileSystemLibrary.isCaseSensitive()) {
+				} else if (!WTPPlugin.isPlatformCaseSensitive()) {
 					String lowerCaseProjectName = tempProjectName.toLowerCase();
 					String currentKey = null;
 					Enumeration keys = projects.keys();
@@ -677,4 +668,4 @@
 		return new EARComponentImportOperation(model);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportFactory.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportFactory.java
index 2d177ee..282d15a 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -33,4 +33,4 @@
 	public void importModuleFile(IDataModel model, IProgressMonitor monitor) throws InvocationTargetException, InterruptedException;
 
 	public int getSpecVersion(Archive archive);
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportRegistry.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportRegistry.java
index bd18c95..fdfc974 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/ExtendedImportRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -92,4 +92,4 @@
 		}
 		return false;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationDataModelProvider.java
index b539a51..d65d733 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationOperation.java
index d76d09c..e3b220d 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/FlexibleJavaProjectCreationOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/IAnnotationsDataModel.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/IAnnotationsDataModel.java
index d636f87..8b8a477 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/IAnnotationsDataModel.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/IAnnotationsDataModel.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -32,4 +32,4 @@
 	 */
 	public static final String USE_ANNOTATIONS = "IAnnotationsDataModel.useAnnotations"; //$NON-NLS-1$
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactExportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactExportDataModelProvider.java
index 32f6af2..da59893 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactExportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactExportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -149,9 +149,9 @@
 		if (ARCHIVE_DESTINATION.equals(propertyName)) {
 			String archiveLocation = (String) model.getProperty(ARCHIVE_DESTINATION);
 			if (!model.isPropertySet(ARCHIVE_DESTINATION) || archiveLocation.equals("")) { //$NON-NLS-1$
-				return WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.DESTINATION_INVALID)); //$NON-NLS-1$);
+				return WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.DESTINATION_INVALID)); //);
 			} else if (model.isPropertySet(ARCHIVE_DESTINATION) && !validateModuleType(archiveLocation)) {
-				return WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.DESTINATION_ARCHIVE_SHOULD_END_WITH, new Object[]{getModuleExtension()})); //$NON-NLS-1$);
+				return WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.DESTINATION_ARCHIVE_SHOULD_END_WITH, new Object[]{getModuleExtension()})); //);
 			} else if (model.isPropertySet(ARCHIVE_DESTINATION)) {
 				IStatus tempStatus = validateLocation(archiveLocation);
 				if (tempStatus != OK_STATUS)
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactImportDataModelProvider.java
index 01b0760..4b26ef7 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEArtifactImportDataModelProvider.java
@@ -1,13 +1,17 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 
 import org.eclipse.core.runtime.IStatus;
@@ -48,6 +52,7 @@
 		propertyNames.add(OVERWRITE_HANDLER);
 		propertyNames.add(CLOSE_ARCHIVE_ON_DISPOSE);
 		propertyNames.add(USE_DEFAULT_COMPONENT_NAME);
+		propertyNames.add(COMPONENT_NAME);
 		return propertyNames;
 	}
 
@@ -86,6 +91,16 @@
 			} catch (OpenFailureException oe) {
 				cachedOpenFailureException = oe;
 			}
+		} else if (COMPONENT_NAME.equals(propertyName)) {
+			List nestedModels = new ArrayList(model.getNestedModels());
+			IDataModel nestedModel = null;
+			for (int i = 0; i < nestedModels.size(); i++) {
+				nestedModel = (IDataModel) nestedModels.get(i);
+				try {
+					nestedModel.setProperty(IJ2EEComponentImportDataModelProperties.COMPONENT_NAME, propertyValue);
+				} catch (Exception e) {}
+			}
+			setProperty(PROJECT_NAME,propertyValue);
 		}
 		return true;
 	}
@@ -213,4 +228,4 @@
 			setBooleanProperty(USE_DEFAULT_COMPONENT_NAME, false);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentCreationDataModelProvider.java
index d448de5..881bc4f 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentCreationDataModelProvider.java
@@ -1,15 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
 import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
-import org.eclipse.jst.j2ee.datamodel.properties.IEarComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
 import org.eclipse.jst.j2ee.internal.archive.operations.JavaComponentCreationDataModelProvider;
@@ -18,13 +25,11 @@
 import org.eclipse.jst.j2ee.internal.earcreation.EarComponentCreationDataModelProvider;
 import org.eclipse.jst.j2ee.internal.project.J2EECreationResourceHandler;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
-import org.eclipse.jst.j2ee.internal.servertarget.ServerTargetHelper;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.ModuleCoreNature;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
 import org.eclipse.wst.common.componentcore.internal.StructureEdit;
 import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
-import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelEvent;
@@ -41,9 +46,9 @@
 public abstract class J2EEComponentCreationDataModelProvider extends JavaComponentCreationDataModelProvider implements IJ2EEComponentCreationDataModelProperties, IAnnotationsDataModel {
 
 	private IDataModel earCreationDM = null;
-	private static String MODULE_NOT_SUPPORTED = "MODULE_NOT_SUPPORTED";
-	private static String MODULEVERSION_NOT_SUPPORTED = "VERSION_NOT_SUPPORTED";
-	private static String OK = "OK";
+	private static String MODULE_NOT_SUPPORTED = "MODULE_NOT_SUPPORTED"; //$NON-NLS-1$
+	private static String MODULEVERSION_NOT_SUPPORTED = "VERSION_NOT_SUPPORTED"; //$NON-NLS-1$
+	private static String OK = "OK"; //$NON-NLS-1$
 
 	public void init() {
 		super.init();
@@ -84,7 +89,7 @@
 		} else if (propertyName.equals(UI_SHOW_EAR_SECTION)) {
 			return Boolean.TRUE;
 		} else if (propertyName.equals(EAR_COMPONENT_NAME)) {
-			return getDataModel().getStringProperty(COMPONENT_NAME) + "EAR";
+			return getDataModel().getStringProperty(COMPONENT_NAME) + "EAR"; //$NON-NLS-1$
 		} else if (propertyName.equals(COMPONENT_VERSION)) {
 			return getDefaultComponentVersion();
 		} else if (propertyName.equals(NESTED_EAR_COMPONENT_CREATION_DM))
@@ -165,12 +170,11 @@
 	protected IProject getEARProject() {
 		String earProjname = (String) model.getProperty(EAR_COMPONENT_NAME);
 		IDataModel earDM = (IDataModel) model.getProperty(NESTED_EAR_COMPONENT_CREATION_DM);
-		earDM.setProperty(IEarComponentCreationDataModelProperties.PROJECT_NAME, earProjname);
+		earDM.setProperty(IComponentCreationDataModelProperties.PROJECT_NAME, earProjname);
 
-		if (earProjname != null && !earProjname.equals("") && validate(EAR_COMPONENT_NAME).isOK())
+		if (earProjname != null && !earProjname.equals("") && validate(EAR_COMPONENT_NAME).isOK()) //$NON-NLS-1$
 			return ProjectUtilities.getProject(earProjname);
-		else
-			return null;
+		return null;
 	}
 
 
@@ -203,7 +207,7 @@
 		String serverID = model.getStringProperty(RUNTIME_TARGET_ID);
 		IRuntime runtime = getServerTargetByID(serverID);
 
-		if (serverID.equals("") || runtime == null) {
+		if (serverID.equals("") || runtime == null) { //$NON-NLS-1$
 			return MODULEVERSION_NOT_SUPPORTED;
 		}
 		Integer version = (Integer) model.getProperty(COMPONENT_VERSION);
@@ -225,11 +229,10 @@
 		DataModelPropertyDescriptor[] desc = projectdm.getValidPropertyDescriptors(RUNTIME_TARGET_ID);
 		for (int i = 0; i < desc.length; i++) {
 			DataModelPropertyDescriptor descriptor = desc[i];
-			String name = descriptor.getPropertyDescription();
 			String runtimeid = (String) descriptor.getPropertyValue();
 			IRuntime runtime = getServerTargetByID(runtimeid);
 			String ok = isTypeSupported(runtime.getRuntimeType(), getJ2EEProjectType(), j2eeVersionText);
-			if (ok.equals("OK"))
+			if (ok.equals(OK))
 				validServers.add(descriptor);
 		}
 
@@ -245,7 +248,7 @@
 	}
 
 	protected IRuntime getServerTargetByID(String id) {
-		IRuntime[] targets = ServerUtil.getRuntimes("", "");
+		IRuntime[] targets = ServerUtil.getRuntimes("", ""); //$NON-NLS-1$ //$NON-NLS-2$
 		for (int i = 0; i < targets.length; i++) {
 			IRuntime target = targets[i];
 			if (id.equals(target.getId()))
@@ -254,15 +257,15 @@
 		return null;
 	}
 
-	private List getValidServerTargets() {
-		List validServerTargets = null;
-		validServerTargets = ServerTargetHelper.getServerTargets("", ""); //$NON-NLS-1$  //$NON-NLS-2$
-		if (validServerTargets != null && validServerTargets.isEmpty())
-			validServerTargets = null;
-		if (validServerTargets == null)
-			return Collections.EMPTY_LIST;
-		return validServerTargets;
-	}
+//	private List getValidServerTargets() {
+//		List validServerTargets = null;
+//		validServerTargets = ServerTargetHelper.getServerTargets("", ""); //$NON-NLS-1$  //$NON-NLS-2$
+//		if (validServerTargets != null && validServerTargets.isEmpty())
+//			validServerTargets = null;
+//		if (validServerTargets == null)
+//			return Collections.EMPTY_LIST;
+//		return validServerTargets;
+//	}
 
 
 	protected String isTypeSupported(IRuntimeType type, String moduleID, String j2eeVersion) {
@@ -280,24 +283,20 @@
 				if (matches(moduleType.getId(), moduleID)) {
 					moduleFound = true;
 					String version = moduleType.getVersion();
-					if (version.equals(j2eeVersion) || version.equals("*")) {
+					if (version.equals(j2eeVersion) || version.equals("*")) { //$NON-NLS-1$
 						moduleVersionFound = true;
 						return OK;
-					} else {
-						if (i < size)
-							continue;
-					}
+					} 
+					if (i < size)
+						continue;
 				}
 			}
 		}
-		if (!moduleFound) {
+		if (!moduleFound)
 			return MODULE_NOT_SUPPORTED;
-		} else {
-			if (!moduleVersionFound)
-				return MODULEVERSION_NOT_SUPPORTED;
-		}
-
-		return "";
+		if (!moduleVersionFound)
+			return MODULEVERSION_NOT_SUPPORTED;
+		return ""; //$NON-NLS-1$
 	}
 
 
@@ -326,27 +325,24 @@
 
 	protected static boolean matches(String serverTypeID, String j2eeModuleID) {
 
-		if (serverTypeID.equals("jst")) { //$NON-NLS-1$
-			if (j2eeModuleID.equals(J2EEProjectUtilities.DYNAMIC_WEB) || j2eeModuleID.equals(J2EEProjectUtilities.EJB) || j2eeModuleID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION) || j2eeModuleID.equals(J2EEProjectUtilities.APPLICATION_CLIENT) || j2eeModuleID.equals(J2EEProjectUtilities.JCA)) {
-				return true;
-			}
-		} else if (serverTypeID.equals("jst.*")) { //$NON-NLS-1$
-			if (j2eeModuleID.equals(J2EEProjectUtilities.DYNAMIC_WEB) || j2eeModuleID.equals(J2EEProjectUtilities.EJB) || j2eeModuleID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION) || j2eeModuleID.equals(J2EEProjectUtilities.APPLICATION_CLIENT) || j2eeModuleID.equals(J2EEProjectUtilities.JCA)) {
-				return true;
-			}
-		} else if (serverTypeID.equals(J2EEProjectUtilities.DYNAMIC_WEB)) {//$NON-NLS-1$
-			if (j2eeModuleID.equals(J2EEProjectUtilities.DYNAMIC_WEB)) {
-				return true;
-			}
-		} else if (serverTypeID.equals(J2EEProjectUtilities.EJB)) {//$NON-NLS-1$
-			if (j2eeModuleID.equals(J2EEProjectUtilities.EJB)) {
-				return true;
-			}
-		} else if (serverTypeID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION)) {//$NON-NLS-1$
-			if (j2eeModuleID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION) || j2eeModuleID.equals(J2EEProjectUtilities.APPLICATION_CLIENT) || j2eeModuleID.equals(J2EEProjectUtilities.JCA)) {
-				return true;
-			}
-		}
+		if (serverTypeID.equals("jst") || serverTypeID.equals("jst.*")) //$NON-NLS-1$ //$NON-NLS-2$
+			return j2eeModuleID.equals(J2EEProjectUtilities.DYNAMIC_WEB) || j2eeModuleID.equals(J2EEProjectUtilities.EJB) || j2eeModuleID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION) || j2eeModuleID.equals(J2EEProjectUtilities.APPLICATION_CLIENT) || j2eeModuleID.equals(J2EEProjectUtilities.JCA);
+		
+		else if (serverTypeID.equals(J2EEProjectUtilities.DYNAMIC_WEB))
+			return j2eeModuleID.equals(J2EEProjectUtilities.DYNAMIC_WEB);
+		
+		else if (serverTypeID.equals(J2EEProjectUtilities.EJB))
+			return j2eeModuleID.equals(J2EEProjectUtilities.EJB);
+		
+		else if (serverTypeID.equals(J2EEProjectUtilities.JCA))
+			return j2eeModuleID.equals(J2EEProjectUtilities.JCA);
+		
+		else if (serverTypeID.equals(J2EEProjectUtilities.APPLICATION_CLIENT))
+			return j2eeModuleID.equals(J2EEProjectUtilities.APPLICATION_CLIENT);
+		
+		else if (serverTypeID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION)) 
+			return j2eeModuleID.equals(J2EEProjectUtilities.ENTERPRISE_APPLICATION) || j2eeModuleID.equals(J2EEProjectUtilities.APPLICATION_CLIENT) || j2eeModuleID.equals(J2EEProjectUtilities.JCA);
+			
 		return false;
 	}
 
@@ -364,15 +360,13 @@
 				if (flexProject != null) {
 					if (ModuleCoreNature.isFlexibleProject(flexProject)) {
 						IVirtualComponent comp = ComponentCore.createComponent(flexProject);
-						int earVersion = 0;
-						
-							if (J2EEProjectUtilities.isEARProject(comp.getProject())) {
-								String sVer = J2EEProjectUtilities.getJ2EEProjectVersion(comp.getProject());
-								int ver = J2EEVersionUtil.convertVersionStringToInt(sVer);
-								if (j2eeVersion <= ver) {
-									DataModelPropertyDescriptor desc = new DataModelPropertyDescriptor(comp.getProject().getName());
-									earDescriptorList.add(desc);
-								}
+						if (J2EEProjectUtilities.isEARProject(comp.getProject())) {
+							String sVer = J2EEProjectUtilities.getJ2EEProjectVersion(comp.getProject());
+							int ver = J2EEVersionUtil.convertVersionStringToInt(sVer);
+							if (j2eeVersion <= ver) {
+								DataModelPropertyDescriptor desc = new DataModelPropertyDescriptor(comp.getProject().getName());
+								earDescriptorList.add(desc);
+							}
 						}
 					}
 				}
@@ -466,8 +460,8 @@
 			if (val) {
 				String serverID = model.getStringProperty(RUNTIME_TARGET_ID);
 				IRuntime runtime = getServerTargetByID(serverID);
-				if (serverID.equals("") || runtime == null) {
-					String msg = EARCreationResourceHandler.getString(EARCreationResourceHandler.SERVER_TARGET_NOT_SUPPORT_EAR);
+				if (serverID.equals("") || runtime == null) { //$NON-NLS-1$
+					String msg = EARCreationResourceHandler.SERVER_TARGET_NOT_SUPPORT_EAR;
 					return WTPCommonPlugin.createErrorStatus(msg);
 				}
 				Integer version = (Integer) model.getProperty(COMPONENT_VERSION);
@@ -475,13 +469,12 @@
 				String j2eeVer = J2EEVersionUtil.getJ2EETextVersion(nj2eeVer);
 				String msg = isTypeSupported(runtime.getRuntimeType(), J2EEProjectUtilities.ENTERPRISE_APPLICATION, j2eeVer);
 				if (!msg.equals(OK)) {
-					msg = EARCreationResourceHandler.getString(EARCreationResourceHandler.SERVER_TARGET_NOT_SUPPORT_EAR);
+					msg = EARCreationResourceHandler.SERVER_TARGET_NOT_SUPPORT_EAR;
 					return WTPCommonPlugin.createErrorStatus(msg);
-				} else {
-					if (validateComponentAlreadyInEar()) {
-						msg = J2EECreationResourceHandler.getString("COMPONENT_ALREADYINEAR"); //$NON-NLS-1$
+				} 
+				if (validateComponentAlreadyInEar()) {
+						msg = J2EECreationResourceHandler.COMPONENT_ALREADYINEAR; 
 						return WTPCommonPlugin.createErrorStatus(msg);
-					}
 				}
 			}
 		} else if (propertyName.equals(PROJECT_NAME)) {
@@ -492,7 +485,7 @@
 				if (earProj != null) {
 					String earProjName = earProj.getName();
 					if (earProjName.equalsIgnoreCase(projName)) {
-						String msg = msg = EARCreationResourceHandler.getString(EARCreationResourceHandler.EAR_PROJECTNAME_SAMEAS_MODULE);
+						String msg = msg = EARCreationResourceHandler.EAR_PROJECTNAME_SAMEAS_MODULE;
 						return WTPCommonPlugin.createErrorStatus(msg);
 					}
 				}
@@ -522,8 +515,8 @@
 		IStatus status = OK_STATUS;
 		String earName = getStringProperty(EAR_COMPONENT_NAME);
 		if (status.isOK()) {
-			if (earName.indexOf("#") != -1 || earName.indexOf("/") != -1) { //$NON-NLS-1$
-				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_INVALID_CHARS); //$NON-NLS-1$
+			if (earName.indexOf("#") != -1 || earName.indexOf("/") != -1) { //$NON-NLS-1$ //$NON-NLS-2$
+				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_INVALID_CHARS); 
 				return WTPCommonPlugin.createErrorStatus(errorMessage);
 			} else if (earName == null || earName.equals("")) { //$NON-NLS-1$
 				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_EMPTY_MODULE_NAME);
@@ -661,68 +654,68 @@
 	protected abstract DataModelPropertyDescriptor[] getValidComponentVersionDescriptors();
 
 
-	private DataModelPropertyDescriptor[] validExistingProjectsDescriptors() {
-
-		IProject[] workspaceProjects = ProjectUtilities.getAllProjects();
-		List items = new ArrayList();
-		for (int i = 0; i < workspaceProjects.length; i++) {
-			IProject project = workspaceProjects[i];
-			try {
-				if (project.hasNature(IModuleConstants.MODULE_NATURE_ID)) {
-					items.add(project.getName());
-				}
-			} catch (CoreException ce) {
-				// Ignore
-			}
-		}
-
-		DataModelPropertyDescriptor[] descriptors = new DataModelPropertyDescriptor[items.size()];
-		for (int i = 0; i < descriptors.length; i++) {
-			descriptors[i] = new DataModelPropertyDescriptor(items.get(i));
-		}
-		return descriptors;
-
-
-		// StructureEdit mc = null;
-		// ArrayList earDescriptorList = new ArrayList();
-		//
-		// IProject[] projs = ProjectUtilities.getAllProjects();
-		//
-		// for (int index = 0; index < projs.length; index++) {
-		// IProject flexProject = projs[index];
-		// try {
-		// if (flexProject != null) {
-		// IFlexibleProject fProject = ComponentCore.createFlexibleProject(flexProject);
-		// if ( fProject.isFlexible()){
-		// IVirtualComponent[] comps = fProject.getComponents();
-		// int earVersion = 0;
-		// for( int i=0; i< comps.length; i++ ){
-		// if( comps[i].getComponentTypeId().equals(IModuleConstants.JST_EAR_MODULE)){
-		// String sVer = comps[i].getVersion();
-		// int ver = J2EEVersionUtil.convertVersionStringToInt(sVer);
-		// if (j2eeVersion <= ver) {
-		// DataModelPropertyDescriptor desc = new
-		// DataModelPropertyDescriptor(comps[i].getComponentHandle(), comps[i].getName());
-		// earDescriptorList.add(desc);
-		// }
-		// }
-		// }
-		// }
-		// }
-		// } finally {
-		// if (mc != null)
-		// mc.dispose();
-		// }
-		// }
-		// DataModelPropertyDescriptor[] descriptors = new
-		// DataModelPropertyDescriptor[earDescriptorList.size()];
-		// for (int i = 0; i < descriptors.length; i++) {
-		// DataModelPropertyDescriptor desc = (DataModelPropertyDescriptor)earDescriptorList.get(i);
-		// descriptors[i] = new DataModelPropertyDescriptor(desc.getPropertyDescription(),
-		// desc.getPropertyDescription());
-		// }
-		// return descriptors;
-
-
-	}
+//	private DataModelPropertyDescriptor[] validExistingProjectsDescriptors() {
+//
+//		IProject[] workspaceProjects = ProjectUtilities.getAllProjects();
+//		List items = new ArrayList();
+//		for (int i = 0; i < workspaceProjects.length; i++) {
+//			IProject project = workspaceProjects[i];
+//			try {
+//				if (project.hasNature(IModuleConstants.MODULE_NATURE_ID)) {
+//					items.add(project.getName());
+//				}
+//			} catch (CoreException ce) {
+//				// Ignore
+//			}
+//		}
+//
+//		DataModelPropertyDescriptor[] descriptors = new DataModelPropertyDescriptor[items.size()];
+//		for (int i = 0; i < descriptors.length; i++) {
+//			descriptors[i] = new DataModelPropertyDescriptor(items.get(i));
+//		}
+//		return descriptors;
+//
+//
+//		// StructureEdit mc = null;
+//		// ArrayList earDescriptorList = new ArrayList();
+//		//
+//		// IProject[] projs = ProjectUtilities.getAllProjects();
+//		//
+//		// for (int index = 0; index < projs.length; index++) {
+//		// IProject flexProject = projs[index];
+//		// try {
+//		// if (flexProject != null) {
+//		// IFlexibleProject fProject = ComponentCore.createFlexibleProject(flexProject);
+//		// if ( fProject.isFlexible()){
+//		// IVirtualComponent[] comps = fProject.getComponents();
+//		// int earVersion = 0;
+//		// for( int i=0; i< comps.length; i++ ){
+//		// if( comps[i].getComponentTypeId().equals(IModuleConstants.JST_EAR_MODULE)){
+//		// String sVer = comps[i].getVersion();
+//		// int ver = J2EEVersionUtil.convertVersionStringToInt(sVer);
+//		// if (j2eeVersion <= ver) {
+//		// DataModelPropertyDescriptor desc = new
+//		// DataModelPropertyDescriptor(comps[i].getComponentHandle(), comps[i].getName());
+//		// earDescriptorList.add(desc);
+//		// }
+//		// }
+//		// }
+//		// }
+//		// }
+//		// } finally {
+//		// if (mc != null)
+//		// mc.dispose();
+//		// }
+//		// }
+//		// DataModelPropertyDescriptor[] descriptors = new
+//		// DataModelPropertyDescriptor[earDescriptorList.size()];
+//		// for (int i = 0; i < descriptors.length; i++) {
+//		// DataModelPropertyDescriptor desc = (DataModelPropertyDescriptor)earDescriptorList.get(i);
+//		// descriptors[i] = new DataModelPropertyDescriptor(desc.getPropertyDescription(),
+//		// desc.getPropertyDescription());
+//		// }
+//		// return descriptors;
+//
+//
+//	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentExportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentExportDataModelProvider.java
index 40368e9..b302081 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentExportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentExportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentImportDataModelProvider.java
index 5d79ef2..2451b31 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEComponentImportDataModelProvider.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 import java.util.Set;
@@ -56,4 +58,4 @@
 	protected ModuleFile getModuleFile() {
 		return (ModuleFile) getArchiveFile();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportDataModelProvider.java
index cb26d83..16e4ff0 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -57,4 +57,4 @@
 
 		return J2EE_UTILITY_JAR_IMPORT_DMP_ID;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportOperationNew.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportOperationNew.java
index dafb44c..af38893 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportOperationNew.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarImportOperationNew.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -29,9 +29,15 @@
 import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.SaveFailureException;
 import org.eclipse.jst.j2ee.datamodel.properties.IJavaUtilityJarImportDataModelProperties;
 import org.eclipse.jst.j2ee.internal.archive.operations.J2EEJavaComponentSaveStrategyImpl;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.UtilityProjectCreationDataModelProvider;
 import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
 /**
@@ -47,18 +53,16 @@
 	}
 
 	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
-		IDataModel nestedComonentCreationDM = model.getNestedModel(IJavaUtilityJarImportDataModelProperties.NESTED_MODEL_J2EE_COMPONENT_CREATION);
-		String componentName = (String)model.getProperty(IJavaUtilityJarImportDataModelProperties.COMPONENT_NAME);
-
-		IVirtualComponent component = (IVirtualComponent) model.getProperty(IJavaUtilityJarImportDataModelProperties.COMPONENT);
-
-		if ( component == null || !component.exists()) {
-			model.getNestedModel(IJavaUtilityJarImportDataModelProperties.NESTED_MODEL_J2EE_COMPONENT_CREATION).getDefaultOperation().execute(monitor, info);
-			IProject javaProject = ProjectUtilities.getProject(componentName);
-			component = ComponentCore.createComponent(javaProject);			
-		}
-		IProject javaProject = component.getProject();
+		IDataModel utilityCreationDataModel = DataModelFactory.createDataModel(new UtilityProjectCreationDataModelProvider());
+		String projectName = model.getStringProperty(IJavaUtilityJarImportDataModelProperties.PROJECT_NAME);
+		utilityCreationDataModel.setStringProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, projectName);
+		FacetDataModelMap map = (FacetDataModelMap)utilityCreationDataModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+		map.getFacetDataModel(J2EEProjectUtilities.UTILITY).setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR, false);
 		
+		utilityCreationDataModel.getDefaultOperation().execute(monitor, info);
+
+		IProject javaProject = ProjectUtilities.getProject(projectName);
+		IVirtualComponent component = ComponentCore.createComponent(javaProject);
 
 		Archive jarFile = (Archive) model.getProperty(IJavaUtilityJarImportDataModelProperties.FILE);
 
@@ -68,7 +72,8 @@
 		try {
 			jarFile.save(strat);
 			// To fix the defect that throws dup classpath exception.
-			// Because JemProjectUtilities.appendJavaClassPath() does not check dups, we have to check it here.
+			// Because JemProjectUtilities.appendJavaClassPath() does not check dups, we have to
+			// check it here.
 			// check if JRE_CONTAINER is in the classpath. if not add it
 			IJavaProject javaProj = JemProjectUtilities.getJavaProject(javaProject);
 			IClasspathEntry[] classpath = javaProj.getRawClasspath();
@@ -87,7 +92,10 @@
 				}
 			}
 			if (!exists) {
-				IClasspathEntry newEntry = JavaCore.newContainerEntry(new Path(jrePathName));
+		         /**
+		          * Warning clean-up 12/05/2005
+		          */   
+				//IClasspathEntry newEntry = JavaCore.newContainerEntry(new Path(jrePathName));
 				JemProjectUtilities.appendJavaClassPath(javaProject, JavaCore.newContainerEntry(new Path("org.eclipse.jdt.launching.JRE_CONTAINER"))); //$NON-NLS-1$)
 				JemProjectUtilities.forceClasspathReload(javaProject);
 			}
@@ -109,4 +117,4 @@
 		return null;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarListImportDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarListImportDataModelProvider.java
index 3f530ca..b92188d 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarListImportDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/J2EEUtilityJarListImportDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -276,26 +276,26 @@
 				IProject earProject = ResourcesPlugin.getWorkspace().getRoot().getProject(earProjectName);
 				try {
 					if (!earProject.isAccessible())
-						return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.getString("J2EEUtilityJarListImportDataModel_Specify_Valid_Project"), null); //$NON-NLS-1$
+						return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.J2EEUtilityJarListImportDataModel_Specify_Valid_Project, null); 
 					return Status.OK_STATUS;
 				} catch (Exception e) {
-					return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.getString("J2EEUtilityJarListImportDataModel_Specify_Valid_Project"), e); //$NON-NLS-1$
+					return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.J2EEUtilityJarListImportDataModel_Specify_Valid_Project, e); 
 				}
 			}
-			return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.getString("J2EEUtilityJarListImportDataModel_Specify_Valid_Project"), null); //$NON-NLS-1$
+			return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.J2EEUtilityJarListImportDataModel_Specify_Valid_Project, null); 
 
 		} else if (UTILITY_JAR_LIST.equals(propertyName) || J2EEUtilityJarListImportDataModelProvider.OVERWRITE_IF_NECESSARY.equals(propertyName)) {
 
 			Object[] list = (Object[]) getProperty(UTILITY_JAR_LIST);
 			if (list == null || list.length == 0)
-				return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.getString("J2EEUtilityJarListImportDataModel_Select_Jar"), null); //$NON-NLS-1$
+				return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.J2EEUtilityJarListImportDataModel_Select_Jar, null); 
 
 			/* return validateExistingProjects(); */
 
 			return Status.OK_STATUS;
 		} else if (LINKED_PATH_VARIABLE.equals(propertyName)) {
 			if (isLinkedPathVariableInvalid())
-				return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.getString("J2EEUtilityJarListImportDataModel_Specify_Linked_Path"), null); //$NON-NLS-1$
+				return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.J2EEUtilityJarListImportDataModel_Specify_Linked_Path, null); 
 		} else if (PROJECT_ROOT.equals(propertyName)) {
 			return validateProjectRoot();
 		}
@@ -307,7 +307,7 @@
 			String loc = (String) getProperty(PROJECT_ROOT);
 			File file = new File(loc);
 			if (!file.canWrite() || !file.isDirectory())
-				return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.getString("J2EEUtilityJarListImportDataModel.0"), null); //$NON-NLS-1$
+				return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, 0, EARCreationResourceHandler.J2EEUtilityJarListImportDataModel_0, null); 
 		}
 		return OK_STATUS;
 	}
@@ -335,4 +335,4 @@
 	// return Status.OK_STATUS;
 	// }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/RemoveComponentFromEnterpriseApplicationOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/RemoveComponentFromEnterpriseApplicationOperation.java
index 27a0f85..95ef8ca 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/RemoveComponentFromEnterpriseApplicationOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/RemoveComponentFromEnterpriseApplicationOperation.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 import java.util.List;
@@ -35,6 +45,7 @@
 		EARArtifactEdit earEdit = null;
 		try {
 			IVirtualComponent comp = (IVirtualComponent) model.getProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT);
+			if (!comp.getProject().isAccessible()) return;
 			earEdit = EARArtifactEdit.getEARArtifactEditForWrite(comp.getProject());
 			if (earEdit != null) {
 				Application application = earEdit.getApplication();
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProperties.java
index a08e5cc..36573c5 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.application.internal.operations;
 
 public interface UpdateManifestDataModelProperties {
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProvider.java
index 2cd3b58..e95e85f 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -93,4 +93,4 @@
 	public IDataModelOperation getDefaultOperation() {
 		return new UpdateManifestOperation(model);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestOperation.java
index 1317f2d..7c1ff04 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/application/internal/operations/UpdateManifestOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -76,4 +76,4 @@
 		// TODO Auto-generated method stub
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/componentcore/util/EARArtifactEdit.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/componentcore/util/EARArtifactEdit.java
index a553111..3337a84 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/componentcore/util/EARArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/componentcore/util/EARArtifactEdit.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.componentcore.util;
 
@@ -17,6 +19,7 @@
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.j2ee.application.Application;
 import org.eclipse.jst.j2ee.application.ApplicationFactory;
 import org.eclipse.jst.j2ee.application.ApplicationResource;
@@ -74,7 +77,8 @@
 		super(aProject, toAccessAsReadOnly);
 	}
 	
-	protected EARArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
+	//This should be revereted to protected when 115924 is fixed
+	public EARArtifactEdit(IProject aProject, boolean toAccessAsReadOnly, boolean forCreate) throws IllegalArgumentException {
 		super(aProject, toAccessAsReadOnly, forCreate, J2EEProjectUtilities.ENTERPRISE_APPLICATION);
 	}
 
@@ -437,6 +441,36 @@
 		}
 		return null;
 	}
+	
+	public IVirtualComponent getModuleByManifestURI(final String uri){
+		StructureEdit core = null;
+		try {
+			core = StructureEdit.getStructureEditForRead(getProject());
+			WorkbenchComponent component = core.getComponent();
+			List referencedComponents = component.getReferencedComponents();
+			
+			for (int i=0; i<referencedComponents.size(); i++) {
+				ReferencedComponent ref = (ReferencedComponent) referencedComponents.get(i);
+				if(ref.getDependentObject() != null){
+					Module module = (Module)ref.getDependentObject();
+					if(uri.equals(module.getUri())){
+						String componentName;
+						try {
+							componentName = ModuleURIUtil.getArchiveName(ref.getHandle());
+							return getModule(componentName);
+						} catch (UnresolveableURIException e) {
+							Logger.getLogger().logError(e);
+						}
+					}
+				}
+			}
+		} finally {
+			if (core != null)
+				core.dispose();
+		}
+		return null;
+	}
+	
     /**
      * This method will return the an IVirtualComponent for the given module name.  The method take either moduleName or 
      * moduleName + ".module_extension" (module_extension = ".jar" || ".war" || ".rar") which allows users to get a IVirtualComponent 
@@ -547,4 +581,4 @@
 			earEdit.dispose();
 		} 
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/DefaultJ2EEComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/DefaultJ2EEComponentCreationDataModelProvider.java
index edb04df..7b5f71e 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/DefaultJ2EEComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/DefaultJ2EEComponentCreationDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -13,13 +13,12 @@
 import java.util.ArrayList;
 import java.util.Set;
 
-import org.eclipse.core.internal.localstore.CoreFileSystemLibrary;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jst.j2ee.application.internal.operations.DefaultJ2EEComponentCreationOperation;
-import org.eclipse.jst.j2ee.applicationclient.internal.creation.AppClientComponentCreationDataModelProvider;
+import org.eclipse.jst.j2ee.applicationclient.internal.creation.AppClientFacetProjectCreationDataModelProvider;
 import org.eclipse.jst.j2ee.datamodel.properties.IJ2EEComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
@@ -28,12 +27,20 @@
 import org.eclipse.jst.j2ee.internal.moduleextension.JcaModuleExtension;
 import org.eclipse.jst.j2ee.internal.moduleextension.WebModuleExtension;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEModuleFacetInstallDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+import org.eclipse.wst.common.frameworks.internal.WTPPlugin;
 import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonMessages;
 import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 
 public class DefaultJ2EEComponentCreationDataModelProvider extends AbstractDataModelProvider implements IDefaultJ2EEComponentCreationDataModelProperties {
 	private static String CREATE_BASE = "DefaultJ2EEComponentCreationDataModel.CREATE_"; //$NON-NLS-1$
@@ -49,9 +56,13 @@
 	private static final String CONNECTOR_SUFFIX = "Connector"; //$NON-NLS-1$
 
 	private IDataModel ejbModel;
+	private IDataModel ejbFacetModel;
 	private IDataModel webModel;
+	private IDataModel webFacetModel;
 	private IDataModel jcaModel;
+	private IDataModel jcaFacetModel;
 	private IDataModel clientModel;
+	private IDataModel clientFacetModel;
 
 	public DefaultJ2EEComponentCreationDataModelProvider() {
 		super();
@@ -76,12 +87,13 @@
 		propertyNames.add(NESTED_MODEL_EJB);
 		propertyNames.add(NESTED_MODEL_JCA);
 		propertyNames.add(NESTED_MODEL_WEB);
+		propertyNames.add(FACET_RUNTIME);
 		return propertyNames;
 	}
 
 
 	public IDataModelOperation getDefaultOperation() {
-		return new DefaultJ2EEComponentCreationOperation(getDataModel());
+		return new DefaultJ2EEComponentCreationOperation(model);
 	}
 
 	public void init() {
@@ -90,25 +102,37 @@
 	}
 
 	protected void initNestedCreationModels() {
-		clientModel = DataModelFactory.createDataModel(new AppClientComponentCreationDataModelProvider());
+		clientModel = DataModelFactory.createDataModel(new AppClientFacetProjectCreationDataModelProvider());
 		model.addNestedModel(NESTED_MODEL_CLIENT, clientModel);
+		clientFacetModel = ((FacetDataModelMap)clientModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP)).getFacetDataModel(J2EEProjectUtilities.APPLICATION_CLIENT);
+		clientFacetModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR, false);
+		
 		EjbModuleExtension ejbExt = EarModuleManager.getEJBModuleExtension();
 		if (ejbExt != null) {
 			ejbModel = ejbExt.createProjectDataModel();
-			if (ejbModel != null)
+			if (ejbModel != null){
 				model.addNestedModel(NESTED_MODEL_EJB, ejbModel);
+				ejbFacetModel = ((FacetDataModelMap)ejbModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP)).getFacetDataModel(J2EEProjectUtilities.EJB);
+				ejbFacetModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR, false);
+			}
 		}
 		WebModuleExtension webExt = EarModuleManager.getWebModuleExtension();
 		if (webExt != null) {
 			webModel = webExt.createProjectDataModel();
-			if (webModel != null)
+			if (webModel != null){
 				model.addNestedModel(NESTED_MODEL_WEB, webModel);
+				webFacetModel = ((FacetDataModelMap)webModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP)).getFacetDataModel(J2EEProjectUtilities.DYNAMIC_WEB);
+				webFacetModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR, false);
+			}
 		}
 		JcaModuleExtension rarExt = EarModuleManager.getJCAModuleExtension();
 		if (rarExt != null) {
 			jcaModel = rarExt.createProjectDataModel();
-			if (jcaModel != null)
+			if (jcaModel != null){
 				model.addNestedModel(NESTED_MODEL_JCA, jcaModel);
+				jcaFacetModel = ((FacetDataModelMap)jcaModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP)).getFacetDataModel(J2EEProjectUtilities.JCA);
+				jcaFacetModel.setBooleanProperty(IJ2EEModuleFacetInstallDataModelProperties.ADD_TO_EAR, false);
+			}
 		}
 	}
 
@@ -161,11 +185,32 @@
 		if (propertyName.equals(J2EE_VERSION)) {
 			updatedJ2EEVersion((Integer) propertyValue);
 			return true;
-		}
-		if (propertyName.startsWith(CREATE_BASE))
+		}else if (propertyName.startsWith(CREATE_BASE)){
 			notifyEnablement(convertPropertyNameToInt(propertyName));
-		if (propertyName.equals(EAR_COMPONENT_NAME)) {
+		}else if (propertyName.equals(EAR_COMPONENT_NAME)) {
 			setDefaultComponentNames((String) propertyValue);
+		}else if(webModel != null && propertyName.equals(WEB_COMPONENT_NAME)){
+			webModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, propertyValue);
+		}else if(clientModel != null && propertyName.equals(APPCLIENT_COMPONENT_NAME)){
+			clientModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, propertyValue);
+		}else if(ejbModel != null && propertyName.equals(EJB_COMPONENT_NAME)){
+			ejbModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, propertyValue);
+		}else if(jcaModel != null && propertyName.equals(CONNECTOR_COMPONENT_NAME)){
+			jcaModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, propertyValue);
+		} 
+		else if(FACET_RUNTIME.equals(propertyName)){
+			if(webModel != null){
+				webModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_RUNTIME, propertyValue);
+			}
+			if(clientModel != null){
+				clientModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_RUNTIME, propertyValue);
+			}
+			if(ejbModel != null){
+				ejbModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_RUNTIME, propertyValue);
+			}
+			if(jcaModel != null){
+				jcaModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_RUNTIME, propertyValue);
+			}
 		}
 		return notify;
 	}
@@ -205,13 +250,13 @@
 			boolean errorNoSelection = true;
 			if (getBooleanProperty(CREATE_APPCLIENT)) {
 				actualProjectName = clientModel.getStringProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME);
-				projectName = CoreFileSystemLibrary.isCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
+				projectName = WTPPlugin.isPlatformCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
 				list.add(projectName);
 				errorNoSelection = false;
 			}
 			if (getBooleanProperty(CREATE_EJB)) {
 				actualProjectName = ejbModel.getStringProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME);
-				projectName = CoreFileSystemLibrary.isCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
+				projectName = WTPPlugin.isPlatformCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
 				if (!list.contains(projectName)) {
 					list.add(projectName);
 				} else {
@@ -221,7 +266,7 @@
 			}
 			if (!errorCollision && getBooleanProperty(CREATE_WEB)) {
 				actualProjectName = webModel.getStringProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME);
-				projectName = CoreFileSystemLibrary.isCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
+				projectName = WTPPlugin.isPlatformCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
 				if (!list.contains(projectName)) {
 					list.add(projectName);
 				} else {
@@ -231,7 +276,7 @@
 			}
 			if (!errorCollision && getBooleanProperty(CREATE_CONNECTOR)) {
 				actualProjectName = jcaModel.getStringProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME);
-				projectName = CoreFileSystemLibrary.isCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
+				projectName = WTPPlugin.isPlatformCaseSensitive() ? actualProjectName : actualProjectName.toLowerCase();
 				if (!list.contains(projectName)) {
 					list.add(projectName);
 				} else {
@@ -242,7 +287,7 @@
 			if (errorCollision) {
 				return J2EEPlugin.newErrorStatus(EARCreationResourceHandler.getString("DuplicateModuleNames", new Object[]{actualProjectName}), null); //$NON-NLS-1$
 			} else if (errorNoSelection) {
-				return J2EEPlugin.newErrorStatus(EARCreationResourceHandler.getString("NoModulesSelected"), null); //$NON-NLS-1$
+				return J2EEPlugin.newErrorStatus(EARCreationResourceHandler.NoModulesSelected, null); 
 			}
 		}
 
@@ -274,7 +319,7 @@
 		IStatus status = OK_STATUS;
 		if (status.isOK()) {
 			if (componentName.indexOf("#") != -1) { //$NON-NLS-1$
-				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_INVALID_CHARS); //$NON-NLS-1$
+				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_INVALID_CHARS); 
 				return WTPCommonPlugin.createErrorStatus(errorMessage);
 			} else if (componentName == null || componentName.equals("")) { //$NON-NLS-1$
 				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_EMPTY_MODULE_NAME);
@@ -288,7 +333,7 @@
 		IDataModel modModule = getNestedModel(flag);
 		if (modModule != null) {
 			String compName = ensureUniqueProjectName(name);
-			modModule.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_NAME, compName);
+			modModule.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, compName);
 		}
 	}
 
@@ -322,54 +367,28 @@
 
 	private void setNestedJ2EEVersion(Object j2eeVersion) {
 		int j2eeVer = ((Integer) j2eeVersion).intValue();
-		if (ejbModel != null) {
-			int ejbVersion = J2EEVersionUtil.convertJ2EEVersionIDToEJBVersionID(j2eeVer);
-			ejbModel.setIntProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_VERSION, ejbVersion);
+		if (ejbFacetModel != null) {
+			String facetVersionString = J2EEVersionUtil.convertVersionIntToString(J2EEVersionUtil.convertJ2EEVersionIDToEJBVersionID(j2eeVer));
+			IProjectFacetVersion facetVersion = ProjectFacetsManager.getProjectFacet(ejbFacetModel.getStringProperty(IFacetDataModelProperties.FACET_ID)).getVersion(facetVersionString);
+			ejbFacetModel.setProperty(IFacetDataModelProperties.FACET_VERSION, facetVersion);
 		}
-		if (webModel != null) {
-			int webVersion = J2EEVersionUtil.convertJ2EEVersionIDToWebVersionID(j2eeVer);
-			webModel.setIntProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_VERSION, webVersion);
+		if (webFacetModel != null) {
+			String facetVersionString = J2EEVersionUtil.convertVersionIntToString(J2EEVersionUtil.convertJ2EEVersionIDToWebVersionID(j2eeVer));
+			IProjectFacetVersion facetVersion = ProjectFacetsManager.getProjectFacet(webFacetModel.getStringProperty(IFacetDataModelProperties.FACET_ID)).getVersion(facetVersionString);
+			webFacetModel.setProperty(IFacetDataModelProperties.FACET_VERSION, facetVersion);
 		}
-		if (jcaModel != null) {
-			int jcaVersion = J2EEVersionUtil.convertJ2EEVersionIDToConnectorVersionID(j2eeVer);
-			jcaModel.setIntProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_VERSION, jcaVersion);
+		if (jcaFacetModel != null) {
+			String facetVersionString = J2EEVersionUtil.convertVersionIntToString(J2EEVersionUtil.convertJ2EEVersionIDToConnectorVersionID(j2eeVer));
+			IProjectFacetVersion facetVersion = ProjectFacetsManager.getProjectFacet(jcaFacetModel.getStringProperty(IFacetDataModelProperties.FACET_ID)).getVersion(facetVersionString);
+			jcaFacetModel.setProperty(IFacetDataModelProperties.FACET_VERSION, facetVersion);
 		}
-		if (clientModel != null)
-			clientModel.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_VERSION, j2eeVersion);
-	}
-
-	private void setNestedComponentName(int flag, String compName) {
-		IDataModel model = getNestedModel(flag);
-		if (model != null) {
-			model.setProperty(IJ2EEComponentCreationDataModelProperties.COMPONENT_NAME, compName);
+		if (clientFacetModel != null){
+			String facetVersionString = J2EEVersionUtil.convertVersionIntToString(j2eeVer);
+			IProjectFacetVersion facetVersion = ProjectFacetsManager.getProjectFacet(clientFacetModel.getStringProperty(IFacetDataModelProperties.FACET_ID)).getVersion(facetVersionString);
+			clientFacetModel.setProperty(IFacetDataModelProperties.FACET_VERSION, facetVersion);
 		}
 	}
 
-	private IStatus validateNestedProjectName(int flag) {
-		IDataModel model = getNestedModel(flag);
-		if (model != null) {
-			String createProperty = null;
-			switch (flag) {
-				case EJB :
-					createProperty = CREATE_EJB;
-					break;
-				case WEB :
-					createProperty = CREATE_WEB;
-					break;
-				case CLIENT :
-					createProperty = CREATE_APPCLIENT;
-					break;
-				case RAR :
-					createProperty = CREATE_CONNECTOR;
-					break;
-			}
-			if (null != createProperty && getBooleanProperty(createProperty)) {
-				return model.validateProperty(IJ2EEComponentCreationDataModelProperties.PROJECT_NAME);
-			}
-		}
-		return J2EEPlugin.OK_STATUS;
-	}
-
 	private IDataModel getNestedModel(int flag) {
 		switch (flag) {
 			case EJB :
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EARCreationResourceHandler.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EARCreationResourceHandler.java
index acd17ef..1909982 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EARCreationResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EARCreationResourceHandler.java
@@ -1,84 +1,105 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.earcreation;
 
 
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-public class EARCreationResourceHandler {
+public class EARCreationResourceHandler extends NLS {
 
-	public static final String ADD_MODULE_MODULE_TYPE = "1"; //$NON-NLS-1$
-	public static final String ADD_MODULE_MODULE_EXISTS = "2"; //$NON-NLS-1$
-	public static final String ADD_MODULE_MODULE_CLOSED = "3"; //$NON-NLS-1$
-	public static final String ADD_MODULE_MODULE_NULL = "4"; //$NON-NLS-1$
-	public static final String ADD_PROJECT_URI_EXISTS = "5"; //$NON-NLS-1$
-	public static final String ADD_PROJECT_NOT_JAVA = "6"; //$NON-NLS-1$
-	public static final String ADD_PROJECT_UTIL_URI = "7"; //$NON-NLS-1$
-	public static final String ADD_PROJECT_UTIL_MAPPED = "8"; //$NON-NLS-1$
-	public static final String ADD_PROJECT_NOT_EAR = "9"; //$NON-NLS-1$
-	public static final String ADD_PROJECT_URI_EMPTY = "10"; //$NON-NLS-1$
-	public static final String NOT_AN_APP_CLIENT = "11"; //$NON-NLS-1$
-	public static final String NOT_AN_EAR = "12"; //$NON-NLS-1$
-	public static final String NOT_AN_EJB = "13"; //$NON-NLS-1$
-	public static final String NOT_A_RAR = "14"; //$NON-NLS-1$
-	public static final String NOT_A_WAR = "15"; //$NON-NLS-1$
-	public static final String SERVER_TARGET_NOT_SUPPORT_EAR = "16"; //$NON-NLS-1$
-	public static final String EAR_PROJECTNAME_SAMEAS_MODULE= "EAR_PROJECTNAME_SAMEAS_MODULE"; //$NON-NLS-1$	
+	private static final String BUNDLE_NAME = "earcreation";//$NON-NLS-1$
 
-	private static ResourceBundle fgResourceBundle;
-
-
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("earcreation");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private EARCreationResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String Error_occured_getting_appl_ERROR_;
+	public static String Error_occured_getting_appl1_ERROR_;
+	public static String Creating__UI_;
+	public static String Creating_EAR_Project_UI_;
+	public static String The_project_already_exist_ERROR_;
+	public static String EARProjectCreationOperatio_ERROR_;
+	public static String ABS_PATH_CHANGED_UI_;
+	public static String UNSAVED_CHANGES_WARN_;
+	public static String PROJECT_MAP_PROBLEMS_ERROR_;
+	public static String MODULE_PROJECTS_CLOSED_WARN_;
+	public static String Add_Module_Command_Label_UI_;
+	public static String Remove_Module_Command_Label_UI_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	public static String Set_project_UI_;
+	public static String Add_Utility_JAR_UI;
+	public static String REM_UTIL_JAR_UI;
+	public static String PROJ_DESC_UPDATE_ERROR_UI_;
+	public static String Not_an_ear_project_UI_;
+	public static String EAR_PROJECT_MUST_BE_OPEN_UI_;
+	public static String Updating_absolute_paths_UI_;
+	public static String DuplicateModuleNames;
+	public static String NoModulesSelected;
+
+	public static String KEY_1;
+	public static String KEY_2;
+	public static String KEY_3;
+	public static String KEY_4;
+	public static String KEY_5;
+	public static String KEY_6;
+	public static String KEY_7;
+	public static String KEY_8;
+	public static String KEY_9;
+	public static String KEY_10;
+	public static String KEY_11;
+	public static String KEY_12;
+	public static String KEY_13;
+	public static String KEY_14;
+	public static String KEY_15;
+	public static String KEY_16;
+	public static String J2EEUtilityJarListImportOperation_UI_0;
+	public static String J2EEUtilityJarListImportOperation_UI_1;
+	public static String J2EEUtilityJarListImportOperation_UI_2;
+	public static String J2EEUtilityJarListImportDataModel_0;
+	public static String J2EEUtilityJarListImportDataModel_Specify_Valid_Project;
+	public static String J2EEUtilityJarListImportDataModel_Select_Jar;
+	public static String J2EEUtilityJarListImportDataModel_Specify_Linked_Path;
+	public static String EARImportDataModel_UI_0;
+	public static String EARImportDataModel_UI_1;
+	public static String EARImportDataModel_UI_2;
+	public static String EARImportDataModel_UI_3;
+	public static String ModuleMappingImpl_UI_0;
+	public static String UtilityJARMappingImpl_UI_0;
+	public static String importWrongType;
+	public static String importWrongVersion;
+	public static String EAR_PROJECTNAME_SAMEAS_MODULE;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, EARCreationResourceHandler.class);
 	}
 
 	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
+		return NLS.bind(key, args);
 	}
 
-	public static void nlsConcatenationFinder() {
-		// used to tag methods which have concatenated strings
-	}
-
-}
\ No newline at end of file
+	public static final String ADD_MODULE_MODULE_TYPE = KEY_1;
+	public static final String ADD_MODULE_MODULE_EXISTS = KEY_2;
+	public static final String ADD_MODULE_MODULE_CLOSED = KEY_3;
+	public static final String ADD_MODULE_MODULE_NULL = KEY_4;
+	public static final String ADD_PROJECT_URI_EXISTS = KEY_5;
+	public static final String ADD_PROJECT_NOT_JAVA = KEY_6;
+	public static final String ADD_PROJECT_UTIL_URI = KEY_7;
+	public static final String ADD_PROJECT_UTIL_MAPPED = KEY_8;
+	public static final String ADD_PROJECT_NOT_EAR = KEY_9;
+	public static final String ADD_PROJECT_URI_EMPTY = KEY_10;
+	public static final String NOT_AN_APP_CLIENT = KEY_11;
+	public static final String NOT_AN_EAR = KEY_12;
+	public static final String NOT_AN_EJB = KEY_13;
+	public static final String NOT_A_RAR = KEY_14;
+	public static final String NOT_A_WAR = KEY_15;
+	public static final String SERVER_TARGET_NOT_SUPPORT_EAR = KEY_16;
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationDataModelProvider.java
index edb9e4b..2b9fe87 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationDataModelProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.earcreation;
 
 import java.util.Collections;
@@ -17,6 +27,7 @@
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.project.facet.EARFacetProjectCreationDataModelProvider;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelPropertyDescriptor;
@@ -27,6 +38,11 @@
 import org.eclipse.wst.server.core.IRuntimeType;
 import org.eclipse.wst.server.core.ServerCore;
 
+/**
+ * @deprecated 
+ * @see EARFacetProjectCreationDataModelProvider
+ */
+
 public class EarComponentCreationDataModelProvider extends J2EEComponentCreationDataModelProvider implements IEarComponentCreationDataModelProperties {
 
     public IDataModelOperation getDefaultOperation() {
@@ -150,7 +166,7 @@
 	                        IRuntimeType type = runtime.getRuntimeType();
 	                        String typeId = type.getId();
 	                        if (typeId.startsWith("org.eclipse.jst.server.tomcat")) { //$NON-NLS-1$
-	                            String msg = EARCreationResourceHandler.getString(EARCreationResourceHandler.SERVER_TARGET_NOT_SUPPORT_EAR);
+	                            String msg = EARCreationResourceHandler.SERVER_TARGET_NOT_SUPPORT_EAR;
 	                            return WTPCommonPlugin.createErrorStatus(msg);
 	                        }
 	                    }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationFacetOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationFacetOperation.java
index e163aed..bbdbf58 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationFacetOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarComponentCreationFacetOperation.java
@@ -38,29 +38,27 @@
 import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
 import org.eclipse.wst.common.project.facet.core.runtime.RuntimeManager;
 
-public class EarComponentCreationFacetOperation extends AbstractDataModelOperation {
+public class EarComponentCreationFacetOperation extends AbstractDataModelOperation implements IFacetProjectCreationDataModelProperties {
 
 	public EarComponentCreationFacetOperation(IDataModel model) {
 		super(model);
 	}
 
 	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
-		
+
 
 		IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
 		String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, projectName);
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION,
-				model.getProperty(IComponentCreationDataModelProperties.LOCATION));
-		
-		List facetDMs = new ArrayList();
-		facetDMs.add(setupEarInstallAction());
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
-		
+		dm.setProperty(FACET_PROJECT_NAME, projectName);
+
+		IDataModel newDM = setupEarInstallAction();
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(FACET_DM_MAP);
+		map.add(newDM);
+
 		IStatus stat = dm.getDefaultOperation().execute(monitor, info);
-		if( stat.isOK() )
-			addModulesToEAR( monitor );
-	
+		if (stat.isOK())
+			addModulesToEAR(monitor);
+
 		return stat;
 	}
 
@@ -81,33 +79,33 @@
 			Logger.getLogger().logError(e);
 		}
 	}
-	
-	private IStatus  addModulesToEAR(IProgressMonitor monitor) {
-		IStatus stat = OK_STATUS;
-		try{
-			IDataModel dm = (IDataModel)model.getProperty(IEarComponentCreationDataModelProperties.NESTED_ADD_COMPONENT_TO_EAR_DM);
-			String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
-			IProject project = J2EEProjectUtilities.getProject( projectName );
-            IVirtualComponent component = ComponentCore.createComponent( project );
 
-            
+	private IStatus addModulesToEAR(IProgressMonitor monitor) {
+		IStatus stat = OK_STATUS;
+		try {
+			IDataModel dm = (IDataModel) model.getProperty(IEarComponentCreationDataModelProperties.NESTED_ADD_COMPONENT_TO_EAR_DM);
+			String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
+			IProject project = J2EEProjectUtilities.getProject(projectName);
+			IVirtualComponent component = ComponentCore.createComponent(project);
+
+
 			dm.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, component);
 
-			List moduleProjectsList = (List)model.getProperty(IEarComponentCreationDataModelProperties.J2EE_PROJECTS_LIST);
+			List moduleProjectsList = (List) model.getProperty(IEarComponentCreationDataModelProperties.J2EE_PROJECTS_LIST);
 			if (moduleProjectsList != null && !moduleProjectsList.isEmpty()) {
 				List moduleComponentsList = new ArrayList(moduleProjectsList.size());
-				for(int i=0;i<moduleProjectsList.size(); i++){
-					moduleComponentsList.add(ComponentCore.createComponent((IProject)moduleProjectsList.get(i)));
+				for (int i = 0; i < moduleProjectsList.size(); i++) {
+					moduleComponentsList.add(ComponentCore.createComponent((IProject) moduleProjectsList.get(i)));
 				}
 				dm.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, moduleComponentsList);
 				stat = dm.validateProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
-				if( stat != OK_STATUS )
+				if (stat != OK_STATUS)
 					return stat;
-				dm.getDefaultOperation().execute(monitor, null);				
-			}	
-		}catch(Exception e) {
-			 Logger.getLogger().log(e);
-		 }
+				dm.getDefaultOperation().execute(monitor, null);
+			}
+		} catch (Exception e) {
+			Logger.getLogger().log(e);
+		}
 		return stat;
-	}		
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarFacetInstallDataModelProvider.java
index 0b521d2..4b7a635 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarFacetInstallDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/EarFacetInstallDataModelProvider.java
@@ -1,26 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.earcreation;
 
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
-import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.J2EEFacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
-public class EarFacetInstallDataModelProvider extends FacetInstallDataModelProvider
-implements IEarFacetInstallDataModelProperties{
+public class EarFacetInstallDataModelProvider extends J2EEFacetInstallDataModelProvider implements IEarFacetInstallDataModelProperties {
 
 	public Set getPropertyNames() {
 		Set names = super.getPropertyNames();
 		names.add(CONTENT_DIR);
+		names.add(J2EE_PROJECTS_LIST);
+		names.add(JAVA_PROJECT_LIST);
 		return names;
 	}
-	
+
 	public Object getDefaultProperty(String propertyName) {
-		if(propertyName.equals(FACET_ID)){
+		if (propertyName.equals(FACET_ID)) {
 			return J2EEProjectUtilities.ENTERPRISE_APPLICATION;
+		} else if (propertyName.equals(CONTENT_DIR)) {
+			return "EarContent";
+		} else if (propertyName.equals(J2EE_PROJECTS_LIST) || propertyName.equals(JAVA_PROJECT_LIST)) {
+			return Collections.EMPTY_LIST;
 		}
-        else if(propertyName.equals(CONTENT_DIR)) {
-            return "EarContent";
-        }
 		return super.getDefaultProperty(propertyName);
 	}
+
+	public IStatus validate(String name) {
+		if (name.equals(J2EE_PROJECTS_LIST)) {
+			return validateTargetComponentVersion((List) model.getProperty(J2EE_PROJECTS_LIST));
+		}
+		return super.validate(name);
+	}
+
+	private IStatus validateTargetComponentVersion(List list) {
+		int earVersion = getJ2EEVersion();
+		for (Iterator iter = list.iterator(); iter.hasNext();) {
+			IProject handle = (IProject) iter.next();
+			IVirtualComponent comp = ComponentCore.createComponent(handle.getProject());
+			if (comp == null) return OK_STATUS; //Not a faceted project, so version not relevant
+			int compVersion = J2EEVersionUtil.convertVersionStringToInt(comp);
+			if (earVersion < compVersion) {
+				String errorStatus = "The Module specification level of " + handle.getName() + ", is incompatible with the containing EAR version"; //$NON-NLS-1$
+				return J2EEPlugin.newErrorStatus(errorStatus, null);
+			}
+		}
+		return OK_STATUS;
+	}
+
+	protected int convertFacetVersionToJ2EEVersion(IProjectFacetVersion version) {
+		return J2EEVersionUtil.convertVersionStringToInt(version.getVersionString());
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IDefaultJ2EEComponentCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IDefaultJ2EEComponentCreationDataModelProperties.java
index 57d4991..5fc021a 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IDefaultJ2EEComponentCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IDefaultJ2EEComponentCreationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -69,5 +69,7 @@
     public static final String NESTED_MODEL_WEB = "DefaultJ2EEComponentCreationDataModel.NESTED_MODEL_WEB"; //$NON-NLS-1$
     public static final String NESTED_MODEL_JCA = "DefaultJ2EEComponentCreationDataModel.NESTED_MODEL_JCA"; //$NON-NLS-1$
     public static final String NESTED_MODEL_CLIENT = "DefaultJ2EEComponentCreationDataModel.NESTED_MODEL_CLIENT"; //$NON-NLS-1$
+    
+    public static final String FACET_RUNTIME = "DefaultJ2EEComponentCreationDataModel.FACET_RUNTIME";//$NON-NLS-1$
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IEarFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IEarFacetInstallDataModelProperties.java
index a04d987..9ffe4bd 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IEarFacetInstallDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/IEarFacetInstallDataModelProperties.java
@@ -1,8 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.earcreation;
 
-import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetInstalDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
 
-public interface IEarFacetInstallDataModelProperties extends IFacetInstalDataModelProperties {
 
-    public static final String CONTENT_DIR = "IEarFacetInstallDataModelProperties.CONTENT_DIR";
+public interface IEarFacetInstallDataModelProperties extends IJ2EEFacetInstallDataModelProperties {
+
+	//TODO what is this???
+	public static final String CONTENT_DIR = "IEarFacetInstallDataModelProperties.CONTENT_DIR";//$NON-NLS-1$
+
+	public static final String J2EE_PROJECTS_LIST = "IEarFacetInstallDataModelProperties.J2EE_PROJECTS_LIST"; //$NON-NLS-1$
+	public static final String JAVA_PROJECT_LIST = "IEarFacetInstallDataModelProperties.JAVA_PROJECT_LIST"; //$NON-NLS-1$
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/ILooseConfigConstants.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/ILooseConfigConstants.java
index df3027e..fd059de 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/ILooseConfigConstants.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/ILooseConfigConstants.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.earcreation;
 
 
@@ -24,4 +26,4 @@
 	/** The property name used by WebSphere to lookup the loose configuration location to load */
 	String WAS_PROPERTY = LooseConfigRegister.LOOSE_CONFIG_PROPERTY;
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMap.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMap.java
index ee0c457..49d57de 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMap.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMap.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMapImpl.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMapImpl.java
index 553ec66..ed53a87 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMapImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/EARProjectMapImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMapping.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMapping.java
index f5eec2d..cee99ee 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMapping.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMappingImpl.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMappingImpl.java
index 1177cd3..333f8d9 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModuleMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapAdapterFactory.java
index ca12d2e..ae34dbb 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapAdapterFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactory.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactory.java
index 4d4fe83..33a1f77 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactory.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactoryImpl.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactoryImpl.java
index 52ce4a4..1f132f3 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactoryImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapFactoryImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapInit.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapInit.java
index e3fd4a5..a833ba4 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapInit.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapInit.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.earcreation.modulemap;
 
 
@@ -48,4 +50,4 @@
 		//TODO Should remove....
 		//com.ibm.ejs.models.base.extensions.init.ExtensionsInit.init(shouldPreRegisterPackages);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackage.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackage.java
index 5e47aab..638f73a 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackage.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackage.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackageImpl.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackageImpl.java
index 3fa38b9..a0184ec 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackageImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapPackageImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapSwitch.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapSwitch.java
index e12237c..ff5df4d 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapSwitch.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/ModulemapSwitch.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMapping.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMapping.java
index f35b0bd..e523561 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMapping.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMapping.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMappingImpl.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMappingImpl.java
index 8f5b6b8..d935451 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMappingImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/earcreation/modulemap/UtilityJARMappingImpl.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/modulecore/util/EarEditAdapterFactory.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/modulecore/util/EarEditAdapterFactory.java
index 36f22da..889db80 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/modulecore/util/EarEditAdapterFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/modulecore/util/EarEditAdapterFactory.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.modulecore.util;
 
 import org.eclipse.core.runtime.IAdapterFactory;
@@ -49,4 +51,4 @@
 
 		return new Class[]{ArtifactEdit.class, EARArtifactEdit.class};
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtension.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtension.java
index e1e60d4..71c0def 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtension.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -42,4 +42,4 @@
 	IDataModelOperation createProjectCreationOperation(IDataModel dataModel);
 
 	IDataModelOperation createProjectCreationOperation(ImportOption option);
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionImpl.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionImpl.java
index 536ef45..d67120d 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionImpl.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionImpl.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 /*
  * Created on Sep 29, 2003
  * 
@@ -43,4 +45,4 @@
 		return dataModel.getDefaultOperation();
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionRegistry.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionRegistry.java
index 8ef204c..3a9ed14 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleExtensionRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -69,4 +69,4 @@
 		EarModuleManager.registerModuleExtension(ext);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleManager.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleManager.java
index f3ca979..14d2cfb 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleManager.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EarModuleManager.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -91,4 +91,4 @@
 	public static void removeModuleExtension(String key) {
 		moduleExtensions.remove(key);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EjbModuleExtension.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EjbModuleExtension.java
index d801a27..7f2a5fa 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EjbModuleExtension.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/EjbModuleExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -18,8 +18,8 @@
 
 import org.eclipse.core.resources.IProject;
 import org.eclipse.jst.j2ee.ejb.EJBJar;
-//import org.eclipse.jst.j2ee.internal.earcreation.UpdateModuleReferencesInEARProjectCommand;
-//import org.eclipse.jst.j2ee.internal.project.J2EENature;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
 
 
 /**
@@ -40,6 +40,11 @@
 
 	IProject getDefinedEJBClientJARProject(IProject anEJBProject);
 
-    //JavaUtilityComponentCreationOperation createEJBClientJARProject(IProject anEJBProject);
-
-}
\ No newline at end of file
+	IDataModelOperation createEJBClientJARProject(
+			final String clientProjectName,
+			final String srcFolderName,
+			final String ejbProjectName,
+			final String earProjectName,
+			final org.eclipse.wst.common.project.facet.core.runtime.IRuntime runtime);
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/JcaModuleExtension.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/JcaModuleExtension.java
index d2859e6..92ca9ca 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/JcaModuleExtension.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/JcaModuleExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -33,4 +33,4 @@
 	//J2EEJavaProjectInfo createProjectInfo();
 
 	//J2EEImportOperation createImportOperation(IProject proj, RARFile rarFile);
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/WebModuleExtension.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/WebModuleExtension.java
index a7dc0cc..cf9a5d0 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/WebModuleExtension.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/internal/moduleextension/WebModuleExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -55,4 +55,4 @@
 
 	boolean hasRuntime(IProject project);
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EARFacetProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EARFacetProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..21d44f0
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EARFacetProjectCreationDataModelProvider.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+import org.eclipse.jst.j2ee.internal.earcreation.EarFacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class EARFacetProjectCreationDataModelProvider extends FacetProjectCreationDataModelProvider {
+
+	public EARFacetProjectCreationDataModelProvider() {
+		super();
+	}
+
+	public void init() {
+		super.init();
+		FacetDataModelMap map = (FacetDataModelMap) getProperty(FACET_DM_MAP);
+		IDataModel earFacet = DataModelFactory.createDataModel(new EarFacetInstallDataModelProvider());
+		map.add(earFacet);
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EARFacetUtils.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EARFacetUtils.java
new file mode 100644
index 0000000..d4c3ba9
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EARFacetUtils.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+
+public class EARFacetUtils {
+
+	public static final IProjectFacetVersion EAR_12 = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE).getVersion("1.2"); //$NON-NLS-1$
+	public static final IProjectFacetVersion EAR_13 = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE).getVersion("1.3"); //$NON-NLS-1$
+	public static final IProjectFacetVersion EAR_14 = ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE).getVersion("1.4"); //$NON-NLS-1$
+
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetInstallDelegate.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetInstallDelegate.java
index a2f8979..9676275 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetInstallDelegate.java
@@ -11,19 +11,31 @@
 
 package org.eclipse.jst.j2ee.project.facet;
 
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
+import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.project.facet.WtpUtils;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationDataModelProvider;
 import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit;
 import org.eclipse.jst.j2ee.internal.J2EEConstants;
 import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
 import org.eclipse.jst.j2ee.internal.earcreation.IEarFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.FacetDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
@@ -55,6 +67,38 @@
 				int nVer = J2EEVersionUtil.convertVersionStringToInt(ver);
 				EARArtifactEdit.createDeploymentDescriptor(project, nVer);
 			}
+			List dependentProjects = (List) model.getProperty(IEarFacetInstallDataModelProperties.J2EE_PROJECTS_LIST);
+			dependentProjects.addAll((List) model.getProperty(IEarFacetInstallDataModelProperties.JAVA_PROJECT_LIST));
+			if (!dependentProjects.isEmpty()) {
+				List dependentComponents = new ArrayList(dependentProjects.size());
+				for (Iterator iterator = dependentProjects.iterator(); iterator.hasNext();) {
+					IProject depProject = (IProject) iterator.next();
+					IVirtualComponent depComp = ComponentCore.createComponent(depProject);
+					if (depComp == null) {
+						JavaProjectMigrationOperation utilOp = J2EEProjectUtilities.createFlexJavaProjectForProjectOperation(depProject);
+						utilOp.execute(null, null);
+						depComp = ComponentCore.createComponent(depProject);
+					}
+
+					dependentComponents.add(depComp);
+				}
+
+				final IDataModel dataModel = DataModelFactory.createDataModel(new AddComponentToEnterpriseApplicationDataModelProvider());
+				dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, c);
+				List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+				modList.addAll(dependentComponents);
+				dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
+				try {
+					dataModel.getDefaultOperation().execute(null, null);
+				} catch (ExecutionException e) {
+					Logger.getLogger().logError(e);
+				}
+			}
+			try {
+				((IDataModelOperation) model.getProperty(FacetDataModelProvider.NOTIFICATION_OPERATION)).execute(monitor, null);
+			} catch (ExecutionException e) {
+				Logger.getLogger().logError(e);
+			}
 		}
 
 		finally {
@@ -63,4 +107,5 @@
 			}
 		}
 	}
+
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetVersionChangeDelegate.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetVersionChangeDelegate.java
index fa0f668..e121e6b 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetVersionChangeDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/EarFacetVersionChangeDelegate.java
@@ -14,8 +14,11 @@
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.wst.common.componentcore.ComponentCore;
-import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+/**
+ * Warning clean-up 12/05/2005
+ */   
+//import org.eclipse.wst.common.componentcore.ComponentCore;
+//import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
@@ -43,8 +46,10 @@
         
         try
         {
-            
-            final IVirtualComponent c = ComponentCore.createComponent(project);
+         /**
+          * Warning clean-up 12/05/2005
+          */   
+            //final IVirtualComponent c = ComponentCore.createComponent(project);
             
 //            final StructureEdit edit 
 //                = StructureEdit.getStructureEditForWrite( project );
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaProjectMigrationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaProjectMigrationDataModelProperties.java
index cfec82b..0eab85c 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaProjectMigrationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaProjectMigrationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaUtilityProjectCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaUtilityProjectCreationDataModelProperties.java
new file mode 100644
index 0000000..9f90935
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IJavaUtilityProjectCreationDataModelProperties.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+public interface IJavaUtilityProjectCreationDataModelProperties {
+
+	public static final String PROJECT_NAME = "IJavaUtilityProjectCreationDataModelProperties.PROJECT_NAME"; //$NON-NLS-1$
+	
+//	public static final String PROJECT_LOCATION = "IJavaUtilityProjectCreationDataModelProperties.PROJECT_LOCATION"; //$NON-NLS-1$	
+	
+	public static final String EAR_PROJECT_NAME = "IJavaUtilityProjectCreationDataModelProperties.EAR_PROJECT_NAME"; //$NON-NLS-1$
+
+	public static final String RUNTIME = "IJavaUtilityProjectCreationDataModelProperties.RUNTIME";	//$NON-NLS-1$
+	
+	public static final String SOURCE_FOLDER = "IJavaUtilityProjectCreationDataModelProperties.SOURCE_FOLDER";	//$NON-NLS-1$
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IUtilityFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IUtilityFacetInstallDataModelProperties.java
index d4e3af7..ce202cc 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IUtilityFacetInstallDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/IUtilityFacetInstallDataModelProperties.java
@@ -10,10 +10,9 @@
  *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
-import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetInstallDataModelProperties;
 
 
 
-public interface IUtilityFacetInstallDataModelProperties extends IJ2EEFacetInstallDataModelProperties {
+public interface IUtilityFacetInstallDataModelProperties extends IJ2EEModuleFacetInstallDataModelProperties {
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationDataModelProvider.java
index bd817ac..54b3101 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationDataModelProvider.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationOperation.java
index f4a36b6..b9839d3 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaProjectMigrationOperation.java
@@ -1,75 +1,63 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 
 package org.eclipse.jst.j2ee.project.facet;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.eclipse.core.commands.ExecutionException;
-import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
 import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
 
-public  class JavaProjectMigrationOperation extends AbstractDataModelOperation implements IJavaProjectMigrationDataModelProperties{
+public class JavaProjectMigrationOperation extends AbstractDataModelOperation implements IJavaProjectMigrationDataModelProperties {
 
-	private static String WTP_MODULE_FILE_NAME = ".wtpmodules"; //$NON-NLS-1$
-	
-    public JavaProjectMigrationOperation(IDataModel model) {
-        super(model);
-    }
 
-    public IStatus execute(IProgressMonitor monitor, IAdaptable info) {
-			
-    	IProject project = ProjectUtilities.getProject(model.getStringProperty(PROJECT_NAME));
-    	
+
+	public JavaProjectMigrationOperation(IDataModel model) {
+		super(model);
+	}
+
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) {
+
+
+
 		IDataModel jdm = DataModelFactory.createDataModel(new JavaFacetInstallDataModelProvider());
-		
-		jdm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME,
-			model.getStringProperty(PROJECT_NAME));
-	
+
+		jdm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(PROJECT_NAME));
+
 		jdm.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, "1.4"); //$NON-NLS-1$
-	
 
 		IDataModel udm = DataModelFactory.createDataModel(new UtilityFacetInstallDataModelProvider());
-		try{
-			udm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME,
-					model.getStringProperty(PROJECT_NAME));
+		try {
+			udm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(PROJECT_NAME));
 			udm.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, "1.0"); //$NON-NLS-1$
-		}catch(Exception e){
+		} catch (Exception e) {
 			Logger.getLogger().logError(e);
 		}
-			
-			
+
 		IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME,
-				model.getStringProperty(PROJECT_NAME));
-		
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION,
-				project.getLocation().toString());
-		List facetDMs = new ArrayList();
-		facetDMs.add( jdm );
-		facetDMs.add( udm );
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
+		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(PROJECT_NAME));
+
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+		map.add(jdm);
+		map.add(udm);
 
 		try {
 			dm.getDefaultOperation().execute(monitor, null);
@@ -77,16 +65,6 @@
 			Logger.getLogger().logError(e);
 		}
 		return OK_STATUS;
-    }
-
-	public IStatus redo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
-		// TODO Auto-generated method stub
-		return null;
 	}
 
-	public IStatus undo(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
-		// TODO Auto-generated method stub
-		return null;
-	}		
-	
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationDataModelProvider.java
index 269210b..b661a11 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationDataModelProvider.java
@@ -1,17 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
 
 import java.util.Set;
 
+import org.eclipse.jst.j2ee.datamodel.properties.IUtilityJavaComponentCreationDataModelProperties;
 import org.eclipse.jst.j2ee.internal.archive.operations.JavaComponentCreationDataModelProvider;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 
+/**
+ * 
+ * @deprecated
+ * @see UtilityProjectCreationDataModelProvider
+ */
 
 public class JavaUtilityComponentCreationDataModelProvider
-	extends JavaComponentCreationDataModelProvider{
+	extends JavaComponentCreationDataModelProvider implements IUtilityJavaComponentCreationDataModelProperties{
 
 	public Set getPropertyNames() {
 		Set propertyNames = super.getPropertyNames();
+			propertyNames.add(EAR_PROJECT_NAME);
 		return propertyNames;
 	}
 	
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationFacetOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationFacetOperation.java
index a5712e9..7488ca2 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationFacetOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityComponentCreationFacetOperation.java
@@ -1,60 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
-import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 
 
-public class JavaUtilityComponentCreationFacetOperation 
-	extends J2EEComponentCreationFacetOperation{
+public class JavaUtilityComponentCreationFacetOperation extends J2EEComponentCreationFacetOperation {
 
-	public JavaUtilityComponentCreationFacetOperation(IDataModel model){
+	public JavaUtilityComponentCreationFacetOperation(IDataModel model) {
 		super(model);
 	}
 
 	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
-		
+
 		IStatus result = OK_STATUS;
-		try{	
+		try {
 			IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
-			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME,
-					(String)model.getProperty(JavaUtilityComponentCreationDataModelProvider.PROJECT_NAME));
+			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, (String) model.getProperty(JavaUtilityComponentCreationDataModelProvider.PROJECT_NAME));
+
+			FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+			map.add(setupJavaInstallAction());
 			
-			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION, 
-					(String)model.getProperty(IComponentCreationDataModelProperties.LOCATION));
-			List facetDMs = new ArrayList();
-			facetDMs.add( setupJavaInstallAction() );
-			facetDMs.add( setupUtilityInstallAction(model) );
-			dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
+			IDataModel newModel = setupUtilityInstallAction(model);
+			map.add( newModel );
+
+			setRuntime(newModel, dm); // Setting runtime property
+			
 			result = dm.getDefaultOperation().execute(monitor, null);
-		}catch(ExecutionException e){
+		} catch (ExecutionException e) {
 			Logger.getLogger().logError(e);
 		}
 		return result;
 	}
-	
-	protected IDataModel setupUtilityInstallAction(IDataModel aDM){
+
+	protected IDataModel setupUtilityInstallAction(IDataModel aDM) {
 		IDataModel dm = DataModelFactory.createDataModel(new UtilityFacetInstallDataModelProvider());
-		try{
-			dm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME,
-					(String)model.getProperty(JavaUtilityComponentCreationDataModelProvider.PROJECT_NAME));
+		try {
+			dm.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(JavaUtilityComponentCreationDataModelProvider.PROJECT_NAME));
 			dm.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, "1.0"); //$NON-NLS-1$
-		}catch(Exception e){
+			dm.setProperty(IUtilityFacetInstallDataModelProperties.RUNTIME_TARGET_ID, model.getProperty(JavaUtilityComponentCreationDataModelProvider.RUNTIME_TARGET_ID));
+			dm.setProperty(IUtilityFacetInstallDataModelProperties.CONFIG_FOLDER, 
+					model.getProperty(JavaUtilityComponentCreationDataModelProvider.JAVASOURCE_FOLDER));
+			dm.setStringProperty(IUtilityFacetInstallDataModelProperties.EAR_PROJECT_NAME,model.getStringProperty(JavaUtilityComponentCreationDataModelProvider.EAR_PROJECT_NAME));
+			
+		} catch (Exception e) {
 			Logger.getLogger().logError(e);
 		}
-		
+
 		return dm;
-	}	
-	
-}
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..ba73143
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityProjectCreationDataModelProvider.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+
+import java.util.Set;
+
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+
+
+public class JavaUtilityProjectCreationDataModelProvider
+	extends AbstractDataModelProvider implements IJavaUtilityProjectCreationDataModelProperties{
+
+	public JavaUtilityProjectCreationDataModelProvider() {
+		super();
+	}
+	
+	public Set getPropertyNames() {
+		Set propertyNames = super.getPropertyNames();
+		propertyNames.add(PROJECT_NAME);
+		//propertyNames.add(PROJECT_LOCATION);
+		propertyNames.add(EAR_PROJECT_NAME);
+		propertyNames.add(RUNTIME);
+		propertyNames.add(SOURCE_FOLDER);
+		return propertyNames;
+	}
+	
+	
+	public IDataModelOperation getDefaultOperation() {
+		return new JavaUtilityProjectCreationOperation(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityProjectCreationOperation.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityProjectCreationOperation.java
new file mode 100644
index 0000000..a7baf75
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/JavaUtilityProjectCreationOperation.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
+import org.eclipse.wst.common.componentcore.internal.operation.FacetProjectCreationOperation;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
+
+public class JavaUtilityProjectCreationOperation extends AbstractDataModelOperation implements IJavaUtilityProjectCreationDataModelProperties{
+
+
+	
+	public JavaUtilityProjectCreationOperation(IDataModel model) {
+		super(model);
+	}
+	
+
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		
+		IStatus stat = OK_STATUS;
+		
+		String projectName = model.getStringProperty( IJavaUtilityProjectCreationDataModelProperties.PROJECT_NAME );
+		String earProjectName = model.getStringProperty( IJavaUtilityProjectCreationDataModelProperties.EAR_PROJECT_NAME );;
+		String javaSourceFolder = model.getStringProperty( IJavaUtilityProjectCreationDataModelProperties.SOURCE_FOLDER );
+		
+		org.eclipse.wst.common.project.facet.core.runtime.IRuntime runtime = (IRuntime) model.getProperty(IJavaUtilityProjectCreationDataModelProperties.RUNTIME);
+		
+		IDataModel dm = DataModelFactory.createDataModel(new UtilityProjectCreationDataModelProvider());
+		
+		
+		//IDataModel pdm = dm.getNestedModel( IFacetProjectCreationDataModelProperties.NESTED_PROJECT_DM );
+		//pdm.setStringProperty( IProjectCreationPropertiesNew.PROJECT_LOCATION, model.getStringProperty( IJavaUtilityProjectCreationDataModelProperties.PROJECT_LOCATION ) );
+		
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(UtilityProjectCreationDataModelProvider.FACET_DM_MAP);
+		
+		IDataModel javadm = map.getFacetDataModel( IModuleConstants.JST_JAVA );
+		IDataModel utildm = map.getFacetDataModel( J2EEProjectUtilities.UTILITY );
+		
+		
+		javadm.setProperty( JavaFacetInstallDataModelProvider.FACET_PROJECT_NAME,
+				projectName);
+		
+		
+		javadm.setProperty( JavaFacetInstallDataModelProvider.SOURCE_FOLDER_NAME,
+				javaSourceFolder);
+		
+
+		utildm.setProperty( IUtilityFacetInstallDataModelProperties.EAR_PROJECT_NAME, earProjectName);
+		
+		utildm.setProperty( IUtilityFacetInstallDataModelProperties.FACET_RUNTIME, runtime );
+		dm.setProperty(UtilityProjectCreationDataModelProvider.FACET_RUNTIME, runtime);
+
+		FacetProjectCreationOperation op = new FacetProjectCreationOperation(dm);
+		try {
+			stat = op.execute( monitor, null );
+		} catch (ExecutionException e) {
+			Logger.getLogger().logError(e);
+		}
+		return stat;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDataModelProvider.java
index 371b9ea..e13df82 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDataModelProvider.java
@@ -1,24 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
-import java.util.Set;
-
 import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
-import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
-public class UtilityFacetInstallDataModelProvider
-	extends FacetInstallDataModelProvider
-    implements IUtilityFacetInstallDataModelProperties {
-
-	public Set getPropertyNames() {
-		Set names = super.getPropertyNames();
-        names.add(EAR_PROJECT_NAME);
-		return names;
-	}
+public class UtilityFacetInstallDataModelProvider extends J2EEModuleFacetInstallDataModelProvider implements IUtilityFacetInstallDataModelProperties {
 	
 	public Object getDefaultProperty(String propertyName) {
-		if(propertyName.equals(FACET_ID)){
+		if (FACET_ID.equals(propertyName)) {
 			return J2EEProjectUtilities.UTILITY;
 		}
 		return super.getDefaultProperty(propertyName);
-	}	
+	}
+
+	protected int convertFacetVersionToJ2EEVersion(IProjectFacetVersion version) {
+		return 0;
+	}
 }
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDelegate.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDelegate.java
index 834f932..be36a1a 100644
--- a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityFacetInstallDelegate.java
@@ -11,10 +11,14 @@
 
 package org.eclipse.jst.j2ee.project.facet;
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 
 import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -25,18 +29,21 @@
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.common.project.facet.WtpUtils;
+import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
 import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationDataModelProvider;
 import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.FacetDataModelProvider;
 import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
 import org.eclipse.wst.common.project.facet.core.IDelegate;
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
-public final class UtilityFacetInstallDelegate implements IDelegate {
-	
+public final class UtilityFacetInstallDelegate extends J2EEFacetInstallDelegate implements IDelegate {
+
 	public void execute(final IProject project, final IProjectFacetVersion fv, final Object cfg, final IProgressMonitor monitor) throws CoreException {
 		if (monitor != null) {
 			monitor.beginTask("", 1); //$NON-NLS-1$
@@ -44,7 +51,7 @@
 
 		try {
 
-            final IDataModel model = (IDataModel) cfg;
+			final IDataModel model = (IDataModel) cfg;
 
 			// Add WTP natures.
 
@@ -65,36 +72,76 @@
 
 				if (cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
 					IPath path = cpe.getPath().removeFirstSegments(1);
-					if( path.isEmpty() ){
+					if (path.isEmpty()) {
 						path = new Path("/"); //$NON-NLS-1$
 					}
 					jsrc.createLink(path, 0, null);
 				}
 			}
 
-			// Associate with an EAR, if necessary.
+			final IWorkspace ws = ResourcesPlugin.getWorkspace();
 
-            final String earProjectName = model.getStringProperty(IUtilityFacetInstallDataModelProperties.EAR_PROJECT_NAME);
+			final IVirtualFolder root = c.getRootFolder();
 
-			if (earProjectName != null && earProjectName != "") {
-                IProject earProject = ProjectUtilities.getProject( earProjectName );
-                IVirtualComponent earComp = ComponentCore.createComponent( earProject );
-                
-                IDataModel dataModel = DataModelFactory.createDataModel( new AddComponentToEnterpriseApplicationDataModelProvider());
-                dataModel.setProperty( ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp );
-                List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
-                modList.add(c);
-                dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
-                try {
-                    dataModel.getDefaultOperation().execute(null, null);
-                } catch (ExecutionException e) {
-                    Logger.getLogger().logError(e);
-                }
+			IContainer container = null;
+
+			if (root.getProjectRelativePath().segmentCount() == 0) {
+				container = project;
+			} else {
+				container = project.getFolder(root.getProjectRelativePath());
 			}
 
+			try {
+				if (container != null)
+					createManifest(project, container, monitor);
+			} catch (InvocationTargetException e) {
+				Logger.getLogger().logError(e);
+			} catch (InterruptedException e) {
+				Logger.getLogger().logError(e);
+			}
+
+
+			ClasspathHelper.removeClasspathEntries(project, fv);
+
+			if (!ClasspathHelper.addClasspathEntries(project, fv)) {
+				// TODO: Support the no runtime case.
+				// ClasspathHelper.addClasspathEntries( project, fv, <something> );
+			}
+
+
+			// Associate with an EAR, if necessary.
+			if (model.getBooleanProperty(IUtilityFacetInstallDataModelProperties.ADD_TO_EAR)) {
+				final String earProjectName = model.getStringProperty(IUtilityFacetInstallDataModelProperties.EAR_PROJECT_NAME);
+				if (earProjectName != null && earProjectName != "") {
+					IProject earProject = ProjectUtilities.getProject(earProjectName);
+					if (earProject.exists()) {
+						IVirtualComponent earComp = ComponentCore.createComponent(earProject);
+
+						IDataModel dataModel = DataModelFactory.createDataModel(new AddComponentToEnterpriseApplicationDataModelProvider());
+						dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp);
+						List modList = (List) dataModel.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+						modList.add(c);
+						dataModel.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modList);
+						try {
+							dataModel.getDefaultOperation().execute(null, null);
+						} catch (ExecutionException e) {
+							Logger.getLogger().logError(e);
+						}
+					}
+				}
+			}
+
+
+			try {
+				((IDataModelOperation) model.getProperty(FacetDataModelProvider.NOTIFICATION_OPERATION)).execute(monitor, null);
+			} catch (ExecutionException e) {
+				Logger.getLogger().logError(e);
+			}
 			if (monitor != null) {
 				monitor.worked(1);
 			}
+		} catch (Exception e) {
+			Logger.getLogger().logError(e);
 		} finally {
 			if (monitor != null) {
 				monitor.done();
diff --git a/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityProjectCreationDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..404833d
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/earproject/org/eclipse/jst/j2ee/project/facet/UtilityProjectCreationDataModelProvider.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+import org.eclipse.jst.common.project.facet.JavaFacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class UtilityProjectCreationDataModelProvider extends FacetProjectCreationDataModelProvider {
+
+	public UtilityProjectCreationDataModelProvider() {
+		super();
+	}
+
+	public void init() {
+		super.init();
+		FacetDataModelMap map = (FacetDataModelMap) getProperty(FACET_DM_MAP);
+		IDataModel javaFacet = DataModelFactory.createDataModel(new JavaFacetInstallDataModelProvider());
+		map.add(javaFacet);
+		IDataModel utilFacet = DataModelFactory.createDataModel(new UtilityFacetInstallDataModelProvider());
+		map.add(utilFacet);
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/componentcore/EnterpriseArtifactEdit.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/componentcore/EnterpriseArtifactEdit.java
index c62e581..1243f3c 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/componentcore/EnterpriseArtifactEdit.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/componentcore/EnterpriseArtifactEdit.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 
 package org.eclipse.jst.j2ee.componentcore;
 
@@ -232,4 +234,4 @@
 	public Archive asArchive(boolean includeSource) throws OpenFailureException{
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/delete/DeleteModuleOperation.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/delete/DeleteModuleOperation.java
index 3a234ef..2a448a5 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/delete/DeleteModuleOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/delete/DeleteModuleOperation.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.delete;
 
 
@@ -248,4 +250,4 @@
 //		return deleteModuleDependencyOperation.getStatus();
 //	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/Assert.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/Assert.java
new file mode 100644
index 0000000..265ae9a
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/Assert.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal.project;
+
+/**
+ * <code>Assert</code> is useful for for embedding runtime sanity checks
+ * in code.
+ * The predicate methods all test a condition and throw some
+ * type of unchecked exception if the condition does not hold.
+ * <p>
+ * Assertion failure exceptions, like most runtime exceptions, are
+ * thrown when something is misbehaving. Assertion failures are invariably
+ * unspecified behavior; consequently, clients should never rely on
+ * these being thrown (and certainly should not being catching them
+ * specifically).
+ * </p>
+ */
+public final class Assert {
+	/* This class is not intended to be instantiated. */
+	private Assert() {
+		// not allowed
+	}
+
+	/** Asserts that an argument is legal. If the given boolean is
+	 * not <code>true</code>, an <code>IllegalArgumentException</code>
+	 * is thrown.
+	 *
+	 * @param expression the outcode of the check
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 * @exception IllegalArgumentException if the legality test failed
+	 */
+	public static boolean isLegal(boolean expression) {
+		return isLegal(expression, ""); //$NON-NLS-1$
+	}
+
+	/** Asserts that an argument is legal. If the given boolean is
+	 * not <code>true</code>, an <code>IllegalArgumentException</code>
+	 * is thrown.
+	 * The given message is included in that exception, to aid debugging.
+	 *
+	 * @param expression the outcode of the check
+	 * @param message the message to include in the exception
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 * @exception IllegalArgumentException if the legality test failed
+	 */
+	public static boolean isLegal(boolean expression, String message) {
+		if (!expression)
+			throw new IllegalArgumentException(message);
+		return expression;
+	}
+
+	/** Asserts that the given object is not <code>null</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 * 
+	 * @param object the value to test
+	 * @exception IllegalArgumentException if the object is <code>null</code>
+	 */
+	public static void isNotNull(Object object) {
+		isNotNull(object, ""); //$NON-NLS-1$
+	}
+
+	/** Asserts that the given object is not <code>null</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 * The given message is included in that exception, to aid debugging.
+	 *
+	 * @param object the value to test
+	 * @param message the message to include in the exception
+	 * @exception IllegalArgumentException if the object is <code>null</code>
+	 */
+	public static void isNotNull(Object object, String message) {
+		if (object == null)
+			throw new AssertionFailedException("null argument:" + message); //$NON-NLS-1$
+	}
+
+	/** Asserts that the given boolean is <code>true</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 *
+	 * @param expression the outcode of the check
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 */
+	public static boolean isTrue(boolean expression) {
+		return isTrue(expression, ""); //$NON-NLS-1$
+	}
+
+	/** Asserts that the given boolean is <code>true</code>. If this
+	 * is not the case, some kind of unchecked exception is thrown.
+	 * The given message is included in that exception, to aid debugging.
+	 *
+	 * @param expression the outcode of the check
+	 * @param message the message to include in the exception
+	 * @return <code>true</code> if the check passes (does not return
+	 *    if the check fails)
+	 */
+	public static boolean isTrue(boolean expression, String message) {
+		if (!expression)
+			throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$
+		return expression;
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/AssertionFailedException.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/AssertionFailedException.java
new file mode 100644
index 0000000..91c64d9
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/AssertionFailedException.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal.project;
+
+/**
+ * <code>AssertionFailedException</code> is a runtime exception thrown
+ * by some of the methods in <code>Assert</code>.
+ * <p>
+ * This class is not declared public to prevent some misuses; programs that catch 
+ * or otherwise depend on assertion failures are susceptible to unexpected
+ * breakage when assertions in the code are added or removed.
+ * </p>
+ */
+/* package */
+class AssertionFailedException extends RuntimeException {
+	/**
+	 * All serializable objects should have a stable serialVersionUID
+	 */
+	private static final long serialVersionUID = 1L;
+
+	/** Constructs a new exception with the given message.
+	 */
+	public AssertionFailedException(String detail) {
+		super(detail);
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EECreationResourceHandler.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EECreationResourceHandler.java
index c072ce8..d4ea873 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EECreationResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EECreationResourceHandler.java
@@ -1,63 +1,161 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.project;
 
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-public class J2EECreationResourceHandler {
+public class J2EECreationResourceHandler extends NLS {
+	private static final String BUNDLE_NAME = "j2eecreation";//$NON-NLS-1$
 
-	private static ResourceBundle fgResourceBundle;
-
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("j2eecreation");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String) will return the key
-			// it was called with
-		}
-		return null;
+	private J2EECreationResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String EJBReferenceDataModel_UI_12;
+	public static String MIGRATE_J2EE_SPEC_UI_;
+	public static String EJBReferenceDataModel_UI_11;
+	public static String EJBReferenceDataModel_UI_10;
+	public static String REQUIRED_CLIENT_VIEW_TITLE;
+	public static String MIGRATION_COMPLETE;
+	public static String NOT_NEEDED_DEPLOYMENT_DESC_MIG;
+	public static String MIGRATION_WARNINGS_REPORT_UI_;
+	public static String BACKEND_MIGRATION_FAILED;
+	public static String REUSE_DELETED_CLIENT_VIEW_NAME_UI_;
+	public static String EJB_PROJECTS_UI_;
+	public static String NOT_NEEDED_BACKEND_MIG;
+	public static String MIGRATION_NOT_POSSIBLE_REPORT;
+	public static String PROJECT_MUST_BE_SELECTED_UI_;
+	public static String JAR_11_IMPORT_20_UI_;
+	public static String WEBCONTENT_FOLDER_RENAME_SKIPPED;
+	public static String CONFIRM_MIGRATE_PROJECT_STRUCTURE;
+	public static String WEBPROJECT_VERSION_MIGRATE_FAILED;
+	public static String JdkJarFileDoesNotExist_UI;
+	public static String Local_cannot_be_empty_UI_;
+	public static String LOCAL_CLIENT_NOT_NEEDED;
+	public static String REMOTE_CLIENT_VIEWS_NOT_EXIST_UI_;
+	public static String MIGRATING_PROJECT_STRUCTURES_UI_;
+	public static String ResourceEnvironmentReferenceDataModel_2;
+	public static String J2EE_1_2_ONLY_HAVE_REMOTE;
+	public static String OPEN_EDITORS_TITLE;
+	public static String EJB_MUST_BE_SELECTED_UI_;
+	public static String FAILED_MIGRATING_IMPORTED_CLASSES;
+	public static String OPEN_J2EE_MIGRATION_WIZARD_UI_;
+	public static String LOCAL_CLIENT_VIEWS_EXIST_UI_;
+	public static String DELETING_REMOTE_CLIENT_VIEWS_UI_;
+	public static String EJB_UI_;
+	public static String CONFIRM_CLIENT_VIEW_REQUIRED;
+	public static String MIGRATION_NOT_NEEDED;
+	public static String ADDING_LOCAL_CLIENT_VIEWS_UI_;
+	public static String WEB_UI_;
+	public static String DeleteModuleOperation_UI_0;
+	public static String Home_cannot_be_empty_UI_;
+	public static String WEBCONTENT_LIBPATH_UPDATE_FAILED;
+	public static String REMOTE_CLIENT_DELETE_SUCCESS_UI_;
+	public static String ServerTargetDataModel_UI_9;
+	public static String LOCAL_CLIENT_ADD_FAILED_UI_;
+	public static String ServerTargetDataModel_UI_8;
+	public static String OLD_PROJECT_STRUCTURE_UI_;
+	public static String ServerTargetDataModel_UI_7;
+	public static String INFORM_PROPER_SELECTION;
+	public static String MIGRATE_MODULE_PROJECTS_UI_;
+	public static String COMPLETED_LOCAL_CLIENT_CREATE;
+	public static String IMPORTED_CLASSES_FILE_DELETED;
+	public static String ADD_LOCAL_CLIENT_VIEWS_BAN_UI_;
+	public static String USE_REMOTE_FOR_DIFFERENT_EAR;
+	public static String APP_PROJECT_ERROR_EXC_;
+	public static String InvalidCharsError;
+	public static String ENTERPRISE_APPLICATIONS_UI_;
+	public static String ResourceReferenceDataModel_UI_1;
+	public static String ResourceReferenceDataModel_UI_0;
+	public static String DELETE_REM_CLIENT_VIEWS_UI_;
+	public static String Errors_occurred_renaming_module_dependencies_UI_;
+	public static String MIGRATION_ERRORS_REPORT_UI_;
+	public static String J2EE_VERSION_FAILED_UI_;
+	public static String COMPLETED_DEPLOY_DELETE;
+	public static String PROJECT_REFERENCES_UPDATED;
+	public static String TARGET_ALSO_EXIST_IN_SAME_EAR;
+	public static String WEBCONTENT_FOLDER_RENAME_FAILED;
+	public static String MIGRATE_UI_;
+	public static String Creating__UI_;
+	public static String Error_creating_an_EAR_proj_UI_;
+	public static String ReferenceDataModel_UI_6;
+	public static String ReferenceDataModel_UI_5;
+	public static String ReferenceDataModel_UI_3;
+	public static String ENTERPRISE_BEANS_BAN_UI_;
+	public static String ADD_LOCAL_CLIENT_VIEWS_CHECK_UI_;
+	public static String Can_not_rename_module_dependency_from_project_UI_;
+	public static String PROJECT_STRUCTURE_SUCCESS_UI_;
+	public static String SOURCE_FOLDER_RENAME_SKIPPED;
+	public static String UNKNOWN_UI_;
+	public static String WIZ_BAN_DESC_UI_;
+	public static String COMPLETED_CMP20_CODEGEN;
+	public static String PROJECT_NOT_NEED_MIGRATION_UI_;
+	public static String SELECT_EJB_CLIENT_VIEWS_UI_;
+	public static String Creating_Java_Project_UI_;
+	public static String REMOTE_CLIENT_DELETE_FAILED_UI_;
+	public static String FILES_OUT_OF_SYNC;
+	public static String MIGRATE_CMP_BEANS_UI_;
+	public static String Remote_cannot_be_empty_UI_;
+	public static String Errors_occurred_deleting_module_dependencies_UI_;
+	public static String Can_not_remove_module_dependency_from_project_UI_;
+	public static String INVALID_SELECTION_TITLE;
+	public static String ABS_PATHS_APP_EXT_REMOVED;
+	public static String Local_home_cannot_be_empty_UI_;
+	public static String USE_LOCAL_FOR_DIFFERENT_EAR;
+	public static String ENTERPRISE_APP_PROJECTS_UI_;
+	public static String MIGRATE_J2EE_PROJECTS_UI_;
+	public static String MIGRATION_SUCCESS_REPORT_UI_;
+	public static String FAILED_DEPLOY_DELETE;
+	public static String J2EE_VERSION_NOT_NEED_MIGRATION_UI_;
+	public static String MIGRATING_J2EE_VERSION_UI_;
+	public static String APPLICATION_CLIENTS_UI_;
+	public static String ServiceReferenceDataModel_ERROR_8;
+	public static String PROJECT_STRUCTURE_FAILED_UI_;
+	public static String LOCAL_CLIENT_ADD_SUCCESS_UI_;
+	public static String COMPONENT_ALREADYINEAR;
+	public static String COMPLETED_BACKEND_MIG;
+	public static String MIGRATE_EJB_SPEC_UI_;
+	public static String RenameModuleOperation_UI_0;
+	public static String CMP_11_IMPORT_20_UI_;
+	public static String J2EE_PROJECT_MIGRATION_TITLE_UI_;
+	public static String APP_CLIENT_ONLY_HAVE_REMOTE;
+	public static String MIGRATION_NOT_NEEDED_REPORT;
+	public static String LOCAL_CLIENT_VIEW_SCHEME_UI_;
+	public static String BINARY_MIGRATION_FAILED;
+	public static String ENTERPRISE_APPLICATION_UI_;
+	public static String INFORM_OPEN_EDITORS;
+	public static String EXTRACTED_IMPORTED_CLASSES;
+	public static String J2EE_VERSION_SUCCESS_UI_;
+	public static String SUFFIX_EXAMPLE_UI_;
+	public static String CONFIRMATION_TITLE;
+	public static String MIGRATION_ERRORS;
+	public static String APPLICATION_CLIENT_UI_;
+	public static String SPECIFY_SUFFIX_UI_;
+	public static String CONFIRM_MIGRATE_J2EE_13;
+	public static String PortComponentReferenceDataModel_ERROR_4;
+	public static String FAILED_LOCAL_CLIENT_CREATE;
+	public static String MessageDestReferenceDataModel_9;
+	public static String APPLICATION_CLIENT_PROJECTS_UI_;
+	public static String MessageDestReferenceDataModel_8;
+	public static String SOURCE_FOLDER_RENAME_FAILED;
+	public static String MessageDestReferenceDataModel_7;
+	public static String ENTERPRISE_BEANS_LIST_UI_;
+	public static String PROJECT_CLASSPATH_UPDATED;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, J2EECreationResourceHandler.class);
 	}
 
 	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
+		return NLS.bind(key, args);
 	}
-
-	public static String getString(String key, Object[] args, int x) {
-
-		return getString(key);
-	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEJavaProjectInfo.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEJavaProjectInfo.java
index 4b163f8..bdbacdd 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEJavaProjectInfo.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEJavaProjectInfo.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -105,7 +105,7 @@
 		IClasspathEntry[] entry = new IClasspathEntry[1];
 		Path path = new Path(jdkJarFullPathName);
 		if (!path.toFile().exists()) {
-			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(J2EECreationResourceHandler.getString("JdkJarFileDoesNotExist_UI", new Object[]{jdkJarFullPathName})); //$NON-NLS-1$
+			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(J2EECreationResourceHandler.getString(J2EECreationResourceHandler.JdkJarFileDoesNotExist_UI, new Object[]{jdkJarFullPathName})); 
 			return false;
 		}
 
@@ -478,4 +478,4 @@
 	public void setServerTarget(IRuntime target) {
 		serverTarget = target;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEProjectUtilities.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEProjectUtilities.java
index 298de62..805d21b 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEProjectUtilities.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/J2EEProjectUtilities.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.project;
 
 
@@ -19,10 +21,12 @@
 import java.util.List;
 import java.util.Map;
 
+import org.eclipse.core.resources.ICommand;
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
@@ -61,6 +65,7 @@
 import org.eclipse.jst.j2ee.project.facet.IJavaProjectMigrationDataModelProperties;
 import org.eclipse.jst.j2ee.project.facet.JavaProjectMigrationDataModelProvider;
 import org.eclipse.jst.j2ee.project.facet.JavaProjectMigrationOperation;
+import org.eclipse.jst.server.core.FacetUtil;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
 import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
@@ -72,6 +77,7 @@
 import org.eclipse.wst.common.project.facet.core.IFacetedProject;
 import org.eclipse.wst.common.project.facet.core.IProjectFacet;
 import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+import org.eclipse.wst.server.core.IRuntime;
 
 
 
@@ -288,7 +294,7 @@
 			pDep = pDep.removeFirstSegments(1);
 		}
 
-		IPath result = null; //$NON-NLS-1$
+		IPath result = null; 
 		StringBuffer buf = new StringBuffer();
 		String segment = null;
 		do {
@@ -358,6 +364,31 @@
 			return null;
 		}
 	}
+	public static void removeBuilders(IProject project,List builderids) throws CoreException {
+		IProjectDescription desc = project.getDescription();
+		ICommand[] oldSpec = desc.getBuildSpec();
+		int oldLength = oldSpec.length;
+		if (oldLength == 0)
+			return;
+		int remaining = 0;
+		//null out all commands that match the builder to remove
+		for (int i = 0; i < oldSpec.length; i++) {
+			if (builderids.contains(oldSpec[i].getBuilderName()))
+				oldSpec[i] = null;
+			else
+				remaining++;
+		}
+		//check if any were actually removed
+		if (remaining == oldSpec.length)
+			return;
+		ICommand[] newSpec = new ICommand[remaining];
+		for (int i = 0, newIndex = 0; i < oldLength; i++) {
+			if (oldSpec[i] != null)
+				newSpec[newIndex++] = oldSpec[i];
+		}
+		desc.setBuildSpec(newSpec);
+		project.setDescription(desc, IResource.NONE, null);
+	}
 
 	public static IPath getSourcePathOrFirst(IProject p, String defaultSourceName) {
 		IJavaProject javaProj = JemProjectUtilities.getJavaProject(p);
@@ -578,6 +609,19 @@
 		else
 			return ""; //$NON-NLS-1$
 	}
+	
+	public static IRuntime getServerRuntime(IProject project) throws CoreException {
+		if (project == null)
+			return null;
+		IFacetedProject facetedProject = ProjectFacetsManager.create(project);
+		if (facetedProject == null)
+			return null;
+		org.eclipse.wst.common.project.facet.core.runtime.IRuntime runtime = facetedProject.getRuntime();
+		if (runtime == null)
+			return null;
+		return FacetUtil.getRuntime(runtime);
+	}
+
 	public static String getJ2EEProjectVersion(IProject project) {
 		String type = getJ2EEProjectType(project);
 		IFacetedProject facetedProject = null;
@@ -605,20 +649,25 @@
 	 * @return the array of IPackageFragmentRoots
 	 */
 	public static IPackageFragmentRoot[] getSourceContainers(IProject project) {
+		IJavaProject jProject = JemProjectUtilities.getJavaProject(project);
+		if (jProject == null)
+			return new IPackageFragmentRoot[0];
 		List list = new ArrayList();
-		IJavaProject jProject = JavaCore.create(project);
 		IVirtualComponent vc = ComponentCore.createComponent(project);
 		IPackageFragmentRoot[] roots;
 		try {
 			roots = jProject.getPackageFragmentRoots();
 			for (int i = 0; i < roots.length; i++) {
+				if (roots[i].getKind() != IPackageFragmentRoot.K_SOURCE)
+					continue;
 				IResource resource = roots[i].getResource();
 				if (null != resource) {
 					IVirtualResource[] vResources = ComponentCore.createResources(resource);
 					boolean found = false;
 					for (int j = 0; !found && j < vResources.length; j++) {
 						if (vResources[j].getComponent().equals(vc)) {
-							list.add(roots[i]);
+							if (!list.contains(roots[i]))
+								list.add(roots[i]);
 							found = true;
 						}
 					}
@@ -637,26 +686,32 @@
 	 * @return array of IContainers for the output folders
 	 */
 	public static IContainer[] getOutputContainers(IProject project) {
-		IPackageFragmentRoot[] sourceContainers = getSourceContainers(project);
-		IJavaProject jProject = JavaCore.create(project);
 		List result = new ArrayList();
+		try {
+			if (!project.hasNature(JavaCore.NATURE_ID))
+				return new IContainer[]{};
+		}
+		catch (Exception e) {}
+		IPackageFragmentRoot[] sourceContainers = getSourceContainers(project);
 		for (int i=0; i<sourceContainers.length; i++) {
-			try {
-				IFolder outputFolder;
-				IPath outputPath = sourceContainers[i].getRawClasspathEntry().getOutputLocation();
-				if (outputPath == null)
-					outputFolder = project.getFolder(jProject.getOutputLocation().removeFirstSegments(1));
-				else
-					outputFolder = project.getFolder(outputPath.removeFirstSegments(1));
-				if (outputFolder != null)
-					result.add(outputFolder);
-			} catch (Exception e) {
-				continue;
-			}
+			IFolder outputFolder = (IFolder) getOutputContainer(project,sourceContainers[i]);
+			if (outputFolder != null && !result.contains(outputFolder))
+				result.add(outputFolder);
 		}
 		return (IContainer[]) result.toArray(new IContainer[result.size()]);
 	}
 	
+	public static IContainer getOutputContainer(IProject project, IPackageFragmentRoot sourceContainer) {
+		try {
+			IJavaProject jProject = JavaCore.create(project);
+			IPath outputPath = sourceContainer.getRawClasspathEntry().getOutputLocation();
+			if (outputPath == null)
+				return project.getFolder(jProject.getOutputLocation().removeFirstSegments(1));
+			return project.getFolder(outputPath.removeFirstSegments(1));
+		} catch (Exception e) {}
+		return null;
+	}
+	
 	/**
 	 * 
 	 * @param name
@@ -704,10 +759,10 @@
 		List nonFlexJavaProjects = new ArrayList();
 		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
 		for (int i = 0; i < projects.length; i++) {
-			if (projects[i].isAccessible() && projects[i].hasNature(JemProjectUtilities.JEM_EMF_NatureID) && !projects[i].hasNature(IModuleConstants.MODULE_NATURE_ID)) {
+			if (projects[i].isAccessible() && projects[i].hasNature(JavaCore.NATURE_ID) && !projects[i].hasNature(IModuleConstants.MODULE_NATURE_ID)) {
 				nonFlexJavaProjects.add(projects[i]);
 			}
 		}
 		return nonFlexJavaProjects;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ManifestFileCreationAction.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ManifestFileCreationAction.java
index c7d7a2e..78e2cdd 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ManifestFileCreationAction.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ManifestFileCreationAction.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -38,4 +38,4 @@
 			throw ioe;
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ProjectSupportResourceHandler.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ProjectSupportResourceHandler.java
index 06bdb78..af7e182 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ProjectSupportResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/ProjectSupportResourceHandler.java
@@ -1,62 +1,60 @@
-package org.eclipse.jst.j2ee.internal.project;
-
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.internal.project;
 
-public class ProjectSupportResourceHandler {
+import org.eclipse.osgi.util.NLS;
 
-	private static ResourceBundle fgResourceBundle;
+public class ProjectSupportResourceHandler extends NLS {
+	private static final String BUNDLE_NAME = "projectsupport";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("projectsupport");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String) will return the key
-			// it was called with
-		}
-		return null;
+	private ProjectSupportResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String Folder_name_cannot_be_the_same_as_Java_source_folder_5;
+	public static String Target_Update_Op;
+	public static String Operation_failed_due_to_SA_ERROR_;
+	public static String Creating_Web_Project____UI_;
+	public static String Could_not_rename_____2;
+	public static String A_web_project_must_be_open_and_must_exist_for_properties_to_be_edited_30;
+	public static String Operation_failed_due_to_IO_ERROR_;
+	public static String Cannot_clone_TaglibInfo_1_EXC_;
+	public static String Syntax_Error_in_the_links_UI_;
+	public static String Sync_WLP_Op;
+	public static String Generated_by_Web_Tooling_23;
+	public static String _1concat_EXC_;
+	public static String File_Serving_Enabler_7;
+	public static String Auto_Generated___File_Enabler_9;
+	public static String Not_a_web_project_29;
+	public static String Names_cannot_begin_or_end_with_whitespace_5;
+	public static String The_character_is_invalid_in_a_context_root;
+	public static String Folder_name_cannot_be_the_same_as_Java_class_folder_6;
+	public static String The_path_for_the_links_sta_EXC_;
+	public static String Operation_failed_due_to_Ja_ERROR_;
+	public static String Folder_name_cannot_be_empty_2;
+	public static String Error_importing_Module_Fil_EXC_;
+	public static String Operation_failed_due_to_Co_ERROR_;
+	public static String Folder_names_cannot_be_equal_4;
+	public static String Could_not_read_TLD_15;
+	public static String Folder_name_is_not_valid;
+	public static String Invalid_Servlet_Level_set_on_WebNature_3_EXC_;
+	public static String Context_Root_cannot_be_empty_2;
+	public static String Error_while_saving_links_s_EXC_;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, ProjectSupportResourceHandler.class);
 	}
 
 	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
+		return NLS.bind(key, args);
 	}
-
-	public static String getString(String key, Object[] args, int x) {
-
-		return getString(key);
-	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/WTPJETEmitter.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/WTPJETEmitter.java
index 5b427f7..304e2ba 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/WTPJETEmitter.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/project/WTPJETEmitter.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -32,7 +32,6 @@
 import java.util.Map;
 import java.util.StringTokenizer;
 
-import org.eclipse.core.internal.runtime.Assert;
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
@@ -75,6 +74,7 @@
  */
 public class WTPJETEmitter extends JETEmitter {
 
+	public static final String PROJECT_NAME = ".JETEmitters"; //$NON-NLS-1$
 	private Map variables;
 
 	private boolean intelligentLinkingEnabled = false;
@@ -578,4 +578,4 @@
 		}
 		return jetCompiler;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetDataModelProvider.java
index 7624bcb..1a58029 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetDataModelProvider.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetDataModelProvider.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.servertarget;
 
 import java.util.Arrays;
@@ -275,13 +285,13 @@
 	private IStatus validateServerTarget() {
 		List targets = getValidServerTargets();
 		if (targets.isEmpty()) {
-			return J2EEPlugin.newErrorStatus(J2EECreationResourceHandler.getString("ServerTargetDataModel_UI_7"), null); //$NON-NLS-1$
+			return J2EEPlugin.newErrorStatus(J2EECreationResourceHandler.ServerTargetDataModel_UI_7, null); 
 		}
 		IRuntime target = getRuntimeTarget();
 		if (target == null) {
-			return J2EEPlugin.newErrorStatus(J2EECreationResourceHandler.getString("ServerTargetDataModel_UI_8"), null); //$NON-NLS-1$
+			return J2EEPlugin.newErrorStatus(J2EECreationResourceHandler.ServerTargetDataModel_UI_8, null); 
 		} else if (!targets.contains(target)) {
-			return J2EEPlugin.newErrorStatus(J2EECreationResourceHandler.getString("ServerTargetDataModel_UI_9"), null); //$NON-NLS-1$
+			return J2EEPlugin.newErrorStatus(J2EECreationResourceHandler.ServerTargetDataModel_UI_9, null); 
 		}
 		return OK_STATUS;
 	}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetOp.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetOp.java
index e96d069..2150639 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetOp.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/J2EEProjectServerTargetOp.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.servertarget;
 
 import org.eclipse.core.commands.ExecutionException;
@@ -12,7 +22,6 @@
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.server.core.IRuntime;
-import org.eclipse.wst.server.core.ServerCore;
 import org.eclipse.wst.server.core.internal.ResourceManager;
 
 public class J2EEProjectServerTargetOp extends AbstractDataModelOperation {
@@ -34,7 +43,7 @@
 			project = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
 		if (runtime != null && project != null) {
 			try {
-				ServerCore.getProjectProperties(project).setRuntimeTarget(runtime, monitor);
+				//ServerCore.getProjectProperties(project).setRuntimeTarget(runtime, monitor);
 				if (model.getBooleanProperty(IJ2EEProjectServerTargetDataModelProperties.UPDATE_MODULES) 
 						&& project.hasNature(IModuleConstants.MODULE_NATURE_ID)) {
 					//ServerTargetHelper.setNewServerTargetForEARModules(runtime, project);
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/ServerTargetHelper.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/ServerTargetHelper.java
index dbed6a0..879a735 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/ServerTargetHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/ServerTargetHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -473,4 +473,4 @@
 	 * ServerTargetManager.getTargetType(v50ServerTarget, IServerTargetConstants.WEB_TYPE); return
 	 * null; }
 	 */
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtension.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtension.java
index 6b24989..26334b1 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtension.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtension.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -59,4 +59,4 @@
 	public void setGroupId(String string) {
 		groupID = string;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtensionHandlerReader.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtensionHandlerReader.java
index 8c36e0d..f1b1bcc 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtensionHandlerReader.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/servertarget/TargetRuntimeExtensionHandlerReader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -140,4 +140,4 @@
 		}
 		return targetRuntimeExtHandler;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IFlexibleJavaProjectCreationDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IFlexibleJavaProjectCreationDataModelProperties.java
index 2cfd37f..2eb1e7c 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IFlexibleJavaProjectCreationDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IFlexibleJavaProjectCreationDataModelProperties.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004, 2005 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IJ2EEProjectServerTargetDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IJ2EEProjectServerTargetDataModelProperties.java
index 6c7a8c7..735a26f 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IJ2EEProjectServerTargetDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/datamodel/properties/IJ2EEProjectServerTargetDataModelProperties.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.datamodel.properties;
 
 import org.eclipse.wst.common.frameworks.datamodel.IDataModelProperties;
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEFacetInstallDataModelProperties.java
index 5301e52..968ed5d 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEFacetInstallDataModelProperties.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEFacetInstallDataModelProperties.java
@@ -1,11 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetInstallDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
 
-import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetInstalDataModelProperties;
+public interface IJ2EEFacetInstallDataModelProperties extends IFacetInstallDataModelProperties {
 
-public interface IJ2EEFacetInstallDataModelProperties extends IFacetInstalDataModelProperties {
-
-	public static final String EAR_PROJECT_NAME = "IJ2EEFacetInstallDataModelProperties.EAR_PROJECT_NAME";
-	public static final String CONFIG_FOLDER = "IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER";
-    public static final String RUNTIME_TARGET_ID = "IJ2EEFacetInstallDataModelProperties.RUNTIME_TARGET_ID";
+	//TODO this property should probably be deleted
+	public static final String RUNTIME_TARGET_ID = "IJ2EEFacetInstallDataModelProperties.RUNTIME_TARGET_ID"; //$NON-NLS-1$
+	
+	public static final String FACET_RUNTIME = IFacetProjectCreationDataModelProperties.FACET_RUNTIME; 
+	
 }
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEModuleFacetInstallDataModelProperties.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEModuleFacetInstallDataModelProperties.java
new file mode 100644
index 0000000..f64f06b
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/IJ2EEModuleFacetInstallDataModelProperties.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+public interface IJ2EEModuleFacetInstallDataModelProperties extends IJ2EEFacetInstallDataModelProperties{
+
+	public static final String ADD_TO_EAR = "IJ2EEFacetInstallDataModelProperties.ADD_TO_EAR"; //$NON-NLS-1$
+	public static final String EAR_PROJECT_NAME = "IJ2EEFacetInstallDataModelProperties.EAR_PROJECT_NAME"; //$NON-NLS-1$
+	public static final String CONFIG_FOLDER = "IJ2EEFacetInstallDataModelProperties.CONFIG_FOLDER"; //$NON-NLS-1$
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEComponentCreationFacetOperation.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEComponentCreationFacetOperation.java
index 6a0ab7a..1d53f77 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEComponentCreationFacetOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEComponentCreationFacetOperation.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.project.facet;
 
 import java.util.List;
@@ -38,7 +48,7 @@
 		return null;
 	}
 	protected void setRuntime(IDataModel newModel, IDataModel facetModel) {
-		String runtime = newModel.getStringProperty(IJ2EEFacetInstallDataModelProperties.RUNTIME_TARGET_ID);
+		String runtime = newModel.getStringProperty(IJ2EEModuleFacetInstallDataModelProperties.RUNTIME_TARGET_ID);
 		try {
 			if (runtime != null) {
 				IRuntime run = getRuntimeByID(runtime);
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDataModelProvider.java
new file mode 100644
index 0000000..140da48
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDataModelProvider.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+import java.util.Set;
+
+import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+
+public abstract class J2EEFacetInstallDataModelProvider extends FacetInstallDataModelProvider  implements IJ2EEFacetInstallDataModelProperties{
+
+	public Set getPropertyNames() {
+		Set names = super.getPropertyNames();
+		names.add(RUNTIME_TARGET_ID);
+		names.add(FACET_RUNTIME);
+		return names;
+	}
+
+	protected final int getJ2EEVersion() {
+		return convertFacetVersionToJ2EEVersion((IProjectFacetVersion) getProperty(FACET_VERSION));
+	}
+
+	protected abstract int convertFacetVersionToJ2EEVersion(IProjectFacetVersion version);
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDelegate.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDelegate.java
index 45d8097..efeb5c6 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDelegate.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEFacetInstallDelegate.java
@@ -33,10 +33,11 @@
 import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 import org.eclipse.wst.common.project.facet.core.IFacetedProject.Action.Type;
+import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
 
 public abstract class J2EEFacetInstallDelegate {
 
-	protected void installEARFacet(String j2eeVersionText, String earProjectName, IProgressMonitor monitor){
+	protected void installEARFacet(String j2eeVersionText, String earProjectName, IRuntime runtime, IProgressMonitor monitor){
 
 		IProject project = ProjectUtilities.getProject(earProjectName); 
 		if( project.exists())
@@ -46,7 +47,8 @@
 		try {
 			facetProj = ProjectFacetsManager.create(earProjectName,
 					null, monitor);
-		
+			facetProj.setRuntime(runtime, monitor);
+			
 			IDataModel earFacetInstallDataModel = DataModelFactory.createDataModel(new EarFacetInstallDataModelProvider());
 			earFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, earProjectName);
 			earFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, j2eeVersionText);
@@ -63,11 +65,10 @@
 		}		
 	}
 	
-    protected void createManifest(IProject project, String configFolder, IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException {
+    protected void createManifest(IProject project, IContainer aFolder, IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException {
     	
-        IContainer container = project.getFolder(configFolder);
-        IFile file = container.getFile(new Path(J2EEConstants.MANIFEST_URI));
-
+        IFile file = aFolder.getFile(new Path(J2EEConstants.MANIFEST_URI));
+        if (file.exists()) return;
         try {
             ManifestFileCreationAction.createManifestFile(file, project);
         } catch (CoreException e) {
diff --git a/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEModuleFacetInstallDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEModuleFacetInstallDataModelProvider.java
new file mode 100644
index 0000000..91a6fb5
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/project/facet/J2EEModuleFacetInstallDataModelProvider.java
@@ -0,0 +1,229 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.project.facet;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
+import org.eclipse.jst.j2ee.internal.common.J2EEVersionUtil;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.ModuleCoreNature;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
+import org.eclipse.wst.common.componentcore.internal.StructureEdit;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelPropertyDescriptor;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonMessages;
+import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+
+public abstract class J2EEModuleFacetInstallDataModelProvider extends J2EEFacetInstallDataModelProvider implements IJ2EEModuleFacetInstallDataModelProperties {
+
+	/**
+	 * An internal Boolean property used to prohibit adding this module to an EAR. This is set on
+	 * the nested models when used during EAR creation since EAR creation handles adding to the EAR
+	 */
+	public static final String PROHIBIT_ADD_TO_EAR = "J2EEModuleFacetInstallDataModelProvider.PROHIBIT_ADD_TO_EAR"; //$NON-NLS-1$
+
+	public Set getPropertyNames() {
+		Set names = super.getPropertyNames();
+		names.add(ADD_TO_EAR);
+		names.add(PROHIBIT_ADD_TO_EAR);
+		names.add(CONFIG_FOLDER);
+		names.add(EAR_PROJECT_NAME);
+		return names;
+	}
+
+	public Object getDefaultProperty(String propertyName) {
+		if (propertyName.equals(PROHIBIT_ADD_TO_EAR)) {
+			return Boolean.FALSE;
+		} else if (propertyName.equals(ADD_TO_EAR)) {
+			return Boolean.FALSE;
+		} else if (propertyName.equals(EAR_PROJECT_NAME)) {
+			return getDataModel().getStringProperty(FACET_PROJECT_NAME) + "EAR"; //$NON-NLS-1$
+		}
+		return super.getDefaultProperty(propertyName);
+	}
+
+	public boolean propertySet(String propertyName, Object propertyValue) {
+		if (propertyName.equals(PROHIBIT_ADD_TO_EAR)) {
+			setBooleanProperty(ADD_TO_EAR, false);
+		}
+		if (ADD_TO_EAR.equals(propertyName)) {
+			model.notifyPropertyChange(EAR_PROJECT_NAME, IDataModel.VALID_VALUES_CHG);
+		} else if (FACET_PROJECT_NAME.equals(propertyName)) {
+			if (getBooleanProperty(ADD_TO_EAR)) {
+				if (!model.isPropertySet(EAR_PROJECT_NAME)) {
+					model.notifyPropertyChange(EAR_PROJECT_NAME, IDataModel.DEFAULT_CHG);
+				}
+			}
+		} else if (FACET_VERSION.equals(propertyName)) {
+			model.notifyPropertyChange(EAR_PROJECT_NAME, IDataModel.VALID_VALUES_CHG);
+		} else if (propertyName.equals(CONFIG_FOLDER)) {
+			IDataModel masterModel = (IDataModel) model.getProperty(MASTER_PROJECT_DM);
+			if (masterModel != null) {
+				FacetDataModelMap map = (FacetDataModelMap) masterModel.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+				IDataModel javaModel = map.getFacetDataModel(IModuleConstants.JST_JAVA);
+				if (javaModel != null)
+					javaModel.setProperty(IJavaFacetInstallDataModelProperties.SOURCE_FOLDER_NAME, propertyValue);
+			}
+		} else if (EAR_PROJECT_NAME.equals(propertyName)) {
+			IProject project = ProjectUtilities.getProject((String) propertyValue);
+			if (project.exists() && project.isAccessible() && J2EEProjectUtilities.isEARProject(project)) {
+				try {
+					IFacetedProject facetProj = ProjectFacetsManager.create(project, false, new NullProgressMonitor());
+					setProperty(FACET_RUNTIME, facetProj.getRuntime());
+				} catch (CoreException e) {
+					Logger.getLogger().logError(e);
+				}
+			}
+		}
+		return super.propertySet(propertyName, propertyValue);
+	}
+
+	public boolean isPropertyEnabled(String propertyName) {
+		if (ADD_TO_EAR.equals(propertyName)) {
+			return !getBooleanProperty(PROHIBIT_ADD_TO_EAR);
+		}
+		if (EAR_PROJECT_NAME.equals(propertyName)) {
+			return !getBooleanProperty(PROHIBIT_ADD_TO_EAR) && getBooleanProperty(ADD_TO_EAR);
+		}
+		return super.isPropertyEnabled(propertyName);
+	}
+
+	public DataModelPropertyDescriptor[] getValidPropertyDescriptors(String propertyName) {
+		if (EAR_PROJECT_NAME.equals(propertyName)) {
+			int j2eeVersion = getJ2EEVersion();
+			return getEARPropertyDescriptors(j2eeVersion);
+		}
+		return super.getValidPropertyDescriptors(propertyName);
+	}
+
+	protected DataModelPropertyDescriptor[] getEARPropertyDescriptors(int j2eeVersion) {
+		StructureEdit mc = null;
+		ArrayList earDescriptorList = new ArrayList();
+
+		IProject[] projs = ProjectUtilities.getAllProjects();
+
+		for (int index = 0; index < projs.length; index++) {
+			IProject flexProject = projs[index];
+			try {
+				if (flexProject != null) {
+					if (ModuleCoreNature.isFlexibleProject(flexProject)) {
+						IVirtualComponent comp = ComponentCore.createComponent(flexProject);
+						if (J2EEProjectUtilities.isEARProject(comp.getProject())) {
+							String sVer = J2EEProjectUtilities.getJ2EEProjectVersion(comp.getProject());
+							int ver = J2EEVersionUtil.convertVersionStringToInt(sVer);
+							if (j2eeVersion <= ver) {
+								DataModelPropertyDescriptor desc = new DataModelPropertyDescriptor(comp.getProject().getName());
+								earDescriptorList.add(desc);
+							}
+						}
+					}
+				}
+			} finally {
+				if (mc != null)
+					mc.dispose();
+			}
+		}
+		DataModelPropertyDescriptor[] descriptors = new DataModelPropertyDescriptor[earDescriptorList.size()];
+		for (int i = 0; i < descriptors.length; i++) {
+			DataModelPropertyDescriptor desc = (DataModelPropertyDescriptor) earDescriptorList.get(i);
+			descriptors[i] = new DataModelPropertyDescriptor(desc.getPropertyDescription(), desc.getPropertyDescription());
+		}
+		return descriptors;
+	}
+
+	public IStatus validate(String name) {
+		if (name.equals(EAR_PROJECT_NAME) && getBooleanProperty(ADD_TO_EAR)) {
+			validateEAR(getStringProperty(EAR_PROJECT_NAME));
+		} else if (name.equals(CONFIG_FOLDER)) {
+			String folderName = model.getStringProperty(CONFIG_FOLDER);
+			if (folderName == null || folderName.length() == 0) {
+				String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.SOURCEFOLDER_EMPTY);
+				return WTPCommonPlugin.createErrorStatus(errorMessage);
+			}
+		}
+		return super.validate(name);
+	}
+
+	protected IStatus validateEAR(String earName) {
+		if (earName.indexOf("#") != -1 || earName.indexOf("/") != -1) { //$NON-NLS-1$ //$NON-NLS-2$
+			String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_INVALID_CHARS); 
+			return WTPCommonPlugin.createErrorStatus(errorMessage);
+		} else if (earName == null || earName.equals("")) { //$NON-NLS-1$
+			String errorMessage = WTPCommonPlugin.getResourceString(WTPCommonMessages.ERR_EMPTY_MODULE_NAME);
+			return WTPCommonPlugin.createErrorStatus(errorMessage);
+		}
+		// IProject earProject =
+		// applicationCreationDataModel.getTargetProject();
+		// if (null != earProject && earProject.exists()) {
+		// if (earProject.isOpen()) {
+		// try {
+		// EARNatureRuntime earNature = (EARNatureRuntime)
+		// earProject.getNature(IEARNatureConstants.NATURE_ID);
+		// if (earNature == null) {
+		// return
+		// WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.PROJECT_NOT_EAR,
+		// new Object[]{earProject.getName()}));
+		// } else if (earNature.getJ2EEVersion() < getJ2EEVersion()) {
+		// String earVersion =
+		// EnterpriseApplicationCreationDataModel.getVersionString(earNature.getJ2EEVersion());
+		// return
+		// WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.INCOMPATABLE_J2EE_VERSIONS,
+		// new Object[]{earProject.getName(), earVersion}));
+		// }
+		// return OK_STATUS;
+		// } catch (CoreException e) {
+		// return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, -1, null, e);
+		// }
+		// }
+		// return
+		// WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.PROJECT_ClOSED,
+		// new Object[]{earProject.getName()}));
+		// } else if (null != earProject && null != getTargetProject()) {
+		// if (earProject.getName().equals(getTargetProject().getName())) {
+		// return
+		// WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.SAME_MODULE_AND_EAR_NAME,
+		// new Object[]{earProject.getName()}));
+		// } else if (!CoreFileSystemLibrary.isCaseSensitive()) {
+		// if
+		// (earProject.getName().toLowerCase().equals(getTargetProject().getName().toLowerCase()))
+		// {
+		// return
+		// WTPCommonPlugin.createErrorStatus(WTPCommonPlugin.getResourceString(WTPCommonMessages.SAME_MODULE_AND_EAR_NAME,
+		// new Object[]{earProject.getName()}));
+		// }
+		// }
+		// }
+		// IStatus status =
+		// applicationCreationDataModel.validateProperty(EnterpriseApplicationCreationDataModel.PROJECT_NAME);
+		// if (status.isOK()) {
+		// status =
+		// applicationCreationDataModel.validateProperty(EnterpriseApplicationCreationDataModel.PROJECT_LOCATION);
+		// }
+		// return status;
+
+		return OK_STATUS;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/DelegateConfigurationElement.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/DelegateConfigurationElement.java
deleted file mode 100644
index f19bcd6..0000000
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/DelegateConfigurationElement.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Created on Dec 14, 2004
- *
- * TODO To change the template for this generated file go to
- * Window - Preferences - Java - Code Style - Code Templates
- */
-package org.eclipse.jst.j2ee.internal;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExtension;
-import org.eclipse.core.runtime.InvalidRegistryObjectException;
-
-/**
- * An object which represents the user-defined contents of an extension in a plug-in manifest.
- */
-public class DelegateConfigurationElement implements IConfigurationElement {
-
-	private final IConfigurationElement delegateElement;
-	private static final String DELEGATE_NAME = "delegateConfigurationElement"; //$NON-NLS-1$ 
-	private static final String DELEGATE_NAMESPACE = "delegateConfigurationElementNamespace"; //$NON-NLS-1$ 
-	private static final String DELEGATE_NULL_STRING = "delegateConfigurationElement: NULL"; //$NON-NLS-1$ 
-
-	public DelegateConfigurationElement(IConfigurationElement aDelegate) {
-		delegateElement = aDelegate;
-	}
-
-	/**
-	 * @param propertyName
-	 * @return
-	 * @throws org.eclipse.core.runtime.CoreException
-	 */
-	public Object createExecutableExtension(String propertyName) throws CoreException {
-		if (delegateElement == null)
-			return null;
-		return delegateElement.createExecutableExtension(propertyName);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-	public boolean equals(Object obj) {
-		if (delegateElement == null)
-			return false;
-		return delegateElement.equals(obj);
-	}
-
-	/**
-	 * @param name
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String getAttribute(String name) throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return null;
-		return delegateElement.getAttribute(name);
-	}
-
-	/**
-	 * @param name
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String getAttributeAsIs(String name) throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return null;
-		return delegateElement.getAttributeAsIs(name);
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String[] getAttributeNames() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return new String[0];
-		return delegateElement.getAttributeNames();
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public IConfigurationElement[] getChildren() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return new IConfigurationElement[0];
-		return delegateElement.getChildren();
-	}
-
-	/**
-	 * @param name
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public IConfigurationElement[] getChildren(String name) throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return new IConfigurationElement[0];
-		return delegateElement.getChildren(name);
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public IExtension getDeclaringExtension() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			throw new InvalidRegistryObjectException();
-		return delegateElement.getDeclaringExtension();
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String getName() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return DELEGATE_NAME;
-		return delegateElement.getName();
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String getNamespace() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return DELEGATE_NAMESPACE;
-		return delegateElement.getNamespace();
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public Object getParent() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return null;
-		return delegateElement.getParent();
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String getValue() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return null;
-		return delegateElement.getValue();
-	}
-
-	/**
-	 * @return
-	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
-	 */
-	public String getValueAsIs() throws InvalidRegistryObjectException {
-		if (delegateElement == null)
-			return null;
-		return delegateElement.getValueAsIs();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#hashCode()
-	 */
-	public int hashCode() {
-		if (delegateElement == null)
-			return -1;
-		return delegateElement.hashCode();
-	}
-
-	/**
-	 * @return
-	 */
-	public boolean isValid() {
-
-		if (delegateElement == null)
-			return false;
-		return delegateElement.isValid();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#toString()
-	 */
-	public String toString() {
-		if (delegateElement == null)
-			return DELEGATE_NULL_STRING;
-		return delegateElement.toString();
-	}
-
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/J2EEModulePostImportHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/J2EEModulePostImportHelper.java
index d95bc5e..1f83987 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/J2EEModulePostImportHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/J2EEModulePostImportHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -34,10 +34,10 @@
  */
 public class J2EEModulePostImportHelper {
 
-	private static final String WEB = J2EEPluginResourceHandler.getString("J2EEModulePostImportHelper.0"); //$NON-NLS-1$
-	private static final String EJB = J2EEPluginResourceHandler.getString("J2EEModulePostImportHelper.1"); //$NON-NLS-1$
-	private static final String APP_CLIENT = J2EEPluginResourceHandler.getString("J2EEModulePostImportHelper.2"); //$NON-NLS-1$
-	private static final String CONNECTOR = J2EEPluginResourceHandler.getString("J2EEModulePostImportHelper.3"); //$NON-NLS-1$
+	private static final String WEB = J2EEPluginResourceHandler.J2EEModulePostImportHelper_0;
+	private static final String EJB = J2EEPluginResourceHandler.J2EEModulePostImportHelper_1;
+	private static final String APP_CLIENT = J2EEPluginResourceHandler.J2EEModulePostImportHelper_2;
+	private static final String CONNECTOR = J2EEPluginResourceHandler.J2EEModulePostImportHelper_3;
 
 	private static IConfigurationElement[] webExtensions = null;
 	private static IConfigurationElement[] ejbExtensions = null;
@@ -155,4 +155,4 @@
 			connectorExtensions = configElements;
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/ResourceTypeReaderHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/ResourceTypeReaderHelper.java
index c4768a0..f285040 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/ResourceTypeReaderHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/ResourceTypeReaderHelper.java
@@ -73,7 +73,7 @@
 
 	private IExtensionPoint getExtensionPoint() {
 		IExtensionRegistry registry = Platform.getExtensionRegistry();
-		IExtensionPoint exPoint = registry.getExtensionPoint(extensionPoint); //$NON-NLS-1$
+		IExtensionPoint exPoint = registry.getExtensionPoint(extensionPoint); 
 		return exPoint;
 	}
 
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistry.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistry.java
index c6ca071..a6722be 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistry.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistry.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -179,4 +179,4 @@
 		String runtimeID = runtime.getRuntimeType().getId();
 		return getDeployers(typeID, runtimeID);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistryReader.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistryReader.java
index b800043..4a439e1 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistryReader.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/DeployerRegistryReader.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -96,4 +96,4 @@
 		return false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/FatalDeployerException.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/FatalDeployerException.java
index 2ff200c..8d410b3 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/FatalDeployerException.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/FatalDeployerException.java
@@ -23,6 +23,11 @@
  * Generation - Code and Comments
  */
 public class FatalDeployerException extends Exception {
+    /**
+     * Warning clean-up 12/05/2005
+     */   
+	private static final long serialVersionUID = -7991505439979201757L;
+
 	/**
 	 *  
 	 */
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployHelper.java
index f5712d0..2168ead 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -142,4 +142,4 @@
 		}
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployOperation.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployOperation.java
index bb4f6cd..acf8701 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployOperation.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deploy/J2EEDeployOperation.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -31,12 +31,12 @@
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPluginResourceHandler;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
 import org.eclipse.wst.common.internal.emf.utilities.CommandContext;
 import org.eclipse.wst.common.internal.emf.utilities.ICommand;
 import org.eclipse.wst.common.internal.emf.utilities.ICommandContext;
 import org.eclipse.wst.server.core.IRuntime;
-import org.eclipse.wst.server.core.ServerCore;
 
 /**
  * @author cbridgha
@@ -76,12 +76,18 @@
 		DeployerRegistry reg = DeployerRegistry.instance();
 
 		List modules = DeployerRegistry.getSelectedModules(selection);
-		monitor.beginTask(J2EEPluginResourceHandler.getString("J2EEDeployOperation_UI_0"), modules.size()); //$NON-NLS-1$
+		monitor.beginTask(J2EEPluginResourceHandler.J2EEDeployOperation_UI_0, modules.size()); 
 		for (int i = 0; i < modules.size(); i++) {
 
 			EObject module = (EObject) modules.get(i);
 			IProject proj = ProjectUtilities.getProject(module);
-			IRuntime runtime = ServerCore.getProjectProperties(proj).getRuntimeTarget();
+			IRuntime runtime = null;
+			try {
+				runtime = J2EEProjectUtilities.getServerRuntime(proj);
+			}
+			catch (CoreException e) {
+				J2EEPlugin.getDefault().getLog().log(e.getStatus());
+			}
 			if (runtime == null)
 				continue;
 			List visitors = reg.getDeployModuleExtensions(module, runtime);
@@ -106,7 +112,7 @@
 			ICommandContext ctx = new CommandContext(monitor, null, module.eResource().getResourceSet());
 			dep.init(selection);
 
-			monitor.setTaskName(J2EEPluginResourceHandler.getString("J2EEDeployOperation_1_UI_", new Object[]{proj.getName(), dep.getClass().getName()})); //$NON-NLS-1$
+			monitor.setTaskName(J2EEPluginResourceHandler.getString(J2EEPluginResourceHandler.J2EEDeployOperation_1_UI_, new Object[]{proj.getName(), dep.getClass().getName()})); 
 			try {
 				dep.execute(proj, null, ctx);
 				addOKStatus(dep.getClass().getName(), main);
@@ -159,7 +165,7 @@
 
 	private IStatus addMainStatus(IProject proj) {
 
-		IStatus aStatus = new MultiStatus(J2EEPlugin.getPlugin().getPluginID(), IStatus.OK, J2EEPluginResourceHandler.getString("J2EEDeployOperation_4_UI_", new Object[]{proj.getName()}), null); //$NON-NLS-1$
+		IStatus aStatus = new MultiStatus(J2EEPlugin.getPlugin().getPluginID(), IStatus.OK, J2EEPluginResourceHandler.getString(J2EEPluginResourceHandler.J2EEDeployOperation_4_UI_, new Object[]{proj.getName()}), null); 
 
 		getMultiStatus().add(aStatus);
 		return aStatus;
@@ -179,4 +185,4 @@
 	public void setMultiStatus(List multiStatus) {
 		this.multiStatus = multiStatus;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/EnterpriseApplicationDeployableAdapterUtil.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/EnterpriseApplicationDeployableAdapterUtil.java
index 62c19ed..f1467a2 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/EnterpriseApplicationDeployableAdapterUtil.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/EnterpriseApplicationDeployableAdapterUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -142,7 +142,7 @@
 
 	protected static IModule getModule(IProject project, IVirtualComponent component) {
 		IModule deployable = null;
-		Iterator iterator = Arrays.asList(ServerUtil.getModules(J2EEProjectUtilities.ENTERPRISE_APPLICATION)).iterator(); //$NON-NLS-1$
+		Iterator iterator = Arrays.asList(ServerUtil.getModules(J2EEProjectUtilities.ENTERPRISE_APPLICATION)).iterator(); 
 		String componentName = null;
 		if (component != null)
 			componentName = component.getName();
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/FlexibleProjectServerUtil.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/FlexibleProjectServerUtil.java
index 0e70624..8330be3 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/FlexibleProjectServerUtil.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/FlexibleProjectServerUtil.java
@@ -1,3 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.deployables;
 
 import org.eclipse.core.resources.IProject;
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableFactory.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableFactory.java
index 0f69c06..12390c7 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableFactory.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEDeployableFactory.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -10,19 +10,17 @@
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.deployables;
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
+import java.util.Map;
 
-import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
 import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.ModuleCoreNature;
-import org.eclipse.wst.common.componentcore.internal.StructureEdit;
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.server.core.IModule;
@@ -30,128 +28,73 @@
 import org.eclipse.wst.server.core.util.ProjectModuleFactoryDelegate;
 
 /**
- * J2EE deployable factory superclass.
+ * J2EE module factory.
  */
 public class J2EEDeployableFactory extends ProjectModuleFactoryDelegate {
+	protected Map moduleDelegates = new HashMap(5);
 
-	public static final String ID = "org.eclipse.jst.j2ee.server"; //$NON-NLS-1$
-	protected HashMap projectModules;
-
-	protected final List moduleDelegates = Collections.synchronizedList(new ArrayList(1));
-
-	private long cachedStamp = -2;
-
-	protected static boolean isFlexibleProject(IProject project) {
-		return ModuleCoreNature.getModuleCoreNature(project) != null;
-	}
-	
 	public J2EEDeployableFactory() {
 		super();
 	}
 
-	protected boolean needsUpdating(IProject project) {
-		if(!initialized)
-			return true;
-		IFile component = project.getFile(IModuleConstants.COMPONENT_FILE_PATH);
-		if (!component.exists())
-			return false;
-		if(component.getModificationStamp() != cachedStamp) {
-			cachedStamp = component.getModificationStamp();
-			return true;
-		}
-		return false;
-	}
-
-	protected IModule[] createModules(IProject project) {
-
-		// List modules = createModules(nature);
-		ModuleCoreNature nature = null;
+	protected IModule createModule(IProject project) {
 		try {
-			nature = (ModuleCoreNature) project.getNature(IModuleConstants.MODULE_NATURE_ID);
+			ModuleCoreNature nature = (ModuleCoreNature) project.getNature(IModuleConstants.MODULE_NATURE_ID);
+			if (nature != null)
+				return createModule(nature);
 		} catch (CoreException e) {
 			Logger.getLogger().write(e);
 		}
-		List modules = createModules(nature);
-		if (modules == null)
-			return new IModule[0];
-		IModule[] moduleArray = new IModule[modules.size()];
-		modules.toArray(moduleArray);
-		return moduleArray;
+		return null;
 	}
-	
-	protected List createModules(ModuleCoreNature nature) {
+
+	protected IModule createModule(ModuleCoreNature nature) {
 		IProject project = nature.getProject();
-		List modules = new ArrayList(1); 
-		StructureEdit moduleCore = null;
 		try {
 			IVirtualComponent comp = ComponentCore.createComponent(project);
-			modules = createModuleDelegates(comp);
-
+			return createModuleDelegates(comp);
 		} catch (Exception e) {
-			e.printStackTrace();
-		} finally {
-			if(moduleCore != null) 
-				moduleCore.dispose();
-		}
-		return modules;
-	}
-	
-	protected boolean isValidModule(IProject project) {
-		try {
-			return isFlexibleProject(project);
-		} catch (Exception e) {
-			//Ignore
-		}
-		return false;
-	}
-
-	public ModuleDelegate getModuleDelegate(IModule module) {
-		if(moduleDelegates.size() == 0)
-			return null;
-		ModuleDelegate[] delegates = (ModuleDelegate[])
-			moduleDelegates.toArray(new ModuleDelegate[moduleDelegates.size()]);
-		for (int i=0; i<delegates.length; i++) {			
-			if (module == delegates[i].getModule())
-				return delegates[i];
+			Logger.getLogger().write(e);
 		}
 		return null;
 	}
-	
-	public IModule[] getModules() {
-		cacheModules(false);
-		ArrayList moduleList = new ArrayList();
-		for (Iterator iter = projects.values().iterator(); iter.hasNext();) {
-			IModule[] element = (IModule[]) iter.next();
-			for (int j = 0; j < element.length; j++) {
-				moduleList.add(element[j]);
-			}
-		}
-		IModule[] modules = new IModule[moduleList.size()];
-		moduleList.toArray(modules);
-		return modules;
 
+	public ModuleDelegate getModuleDelegate(IModule module) {
+		return (ModuleDelegate) moduleDelegates.get(module);
 	}
-	
-	protected List createModuleDelegates(IVirtualComponent component) {
-		J2EEFlexProjDeployable moduleDelegate = null;
-		IModule module = null;
-		List moduleList = new ArrayList();
+
+	protected IModule createModuleDelegates(IVirtualComponent component) {
 		try {
-			moduleDelegate = new J2EEFlexProjDeployable(component.getProject(), ID, component);
-			module = createModule(component.getName(), component.getName(), moduleDelegate.getType(), moduleDelegate.getJ2EESpecificationVersion(), moduleDelegate.getProject());
-			moduleList.add(module);
-			moduleDelegate.initialize(module);
-			
-			// adapt(moduleDelegate, (WorkbenchComponent) workBenchModules.get(i));
+			String type = J2EEProjectUtilities.getJ2EEProjectType(component.getProject());
+			if (type != null && !type.equals("")) {
+				String version = J2EEProjectUtilities.getJ2EEProjectVersion(component.getProject());
+				IModule module = createModule(component.getName(), component.getName(), type, version, component.getProject());
+				J2EEFlexProjDeployable moduleDelegate = new J2EEFlexProjDeployable(component.getProject(), component);
+				moduleDelegates.put(module, moduleDelegate);
+				return module;
+			}
 		} catch (Exception e) {
 			Logger.getLogger().write(e);
-		} finally {
-			if (module != null) {
-				if (getModuleDelegate(module) == null)
-					moduleDelegates.add(moduleDelegate);
-			}
 		}
-		return moduleList;
+		return null;
 	}
 
+	/**
+	 * Returns the list of resources that the module should listen to
+	 * for state changes. The paths should be project relative paths.
+	 * Subclasses can override this method to provide the paths.
+	 *
+	 * @return a possibly empty array of paths
+	 */
+	protected IPath[] getListenerPaths() {
+		return new IPath[] {
+			new Path(".project"), // nature
+			new Path(".settings/.component"), // component
+			new Path(".settings/org.eclipse.wst.common.project.facet.core.xml") // facets
+		};
+	}
+
+	protected void clearCache() {
+		moduleDelegates = new HashMap(5);
+	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEFlexProjDeployable.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEFlexProjDeployable.java
index 0fe88f2..7d00e7c 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEFlexProjDeployable.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/deployables/J2EEFlexProjDeployable.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -18,19 +18,13 @@
 
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jem.workbench.utility.JemProjectUtilities;
 import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit;
 import org.eclipse.jst.j2ee.ejb.EJBJar;
@@ -49,258 +43,154 @@
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
-import org.eclipse.wst.common.componentcore.resources.IVirtualContainer;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
 import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
-import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
 import org.eclipse.wst.server.core.IModule;
-import org.eclipse.wst.server.core.internal.ModuleFile;
 import org.eclipse.wst.server.core.internal.ModuleFolder;
 import org.eclipse.wst.server.core.model.IModuleFolder;
 import org.eclipse.wst.server.core.model.IModuleResource;
-import org.eclipse.wst.server.core.util.ProjectModule;
-
+import org.eclipse.wst.web.internal.deployables.ComponentDeployable;
 /**
- * J2EE deployable superclass.
+ * J2EE module superclass.
  */
-public class J2EEFlexProjDeployable extends ProjectModule implements IJ2EEModule, IEnterpriseApplication, IApplicationClientModule, IConnectorModule, IEJBModule, IWebModule {
-	
-	private String factoryId;
-    protected IVirtualComponent component = null;
-    private boolean outputMembersAdded = false;
-    private List members = new ArrayList();
+public class J2EEFlexProjDeployable extends ComponentDeployable implements IJ2EEModule, IEnterpriseApplication, IApplicationClientModule, IConnectorModule, IEJBModule, IWebModule {
+	private static final IPath WEB_CLASSES_PATH = new Path("WEB-INF").append("classes"); //$NON-NLS-1$ //$NON-NLS-2$
 
 	/**
 	 * Constructor for J2EEFlexProjDeployable.
 	 * 
 	 * @param project
+	 * @param aComponent
 	 */
-	public J2EEFlexProjDeployable(IProject project, String aFactoryId, IVirtualComponent aComponent) {
+	public J2EEFlexProjDeployable(IProject project, IVirtualComponent aComponent) {
 		super(project);
-		factoryId = aFactoryId;
-		component = aComponent;
 	}
 
-	public String getJ2EESpecificationVersion() {
-		return J2EEProjectUtilities.getJ2EEProjectVersion(component.getProject());
+	/**
+	 * Returns the root folders for the resources in this module.
+	 * 
+	 * @return a possibly-empty array of resource folders
+	 */
+	public IContainer[] getResourceFolders() {
+		List result = new ArrayList();
+		IVirtualComponent vc = ComponentCore.createComponent(getProject());
+		if (vc != null) {
+			IVirtualFolder vFolder = vc.getRootFolder();
+			if (vFolder != null) {
+				IContainer[] underlyingFolders = vFolder.getUnderlyingFolders();
+				result.addAll(Arrays.asList(underlyingFolders));
+				IPackageFragmentRoot[] srcRoots = J2EEProjectUtilities.getSourceContainers(getProject());
+				try {
+					for (int i=0; i<srcRoots.length; i++) {
+						IResource corrResource = srcRoots[i].getCorrespondingResource();
+						if (corrResource == null || !(corrResource instanceof IContainer))
+							continue;
+						IContainer srcContainer = (IContainer) corrResource;
+						result.remove(srcContainer);
+					}
+				} catch (Exception e) {}
+			}
+		}
+		
+		return (IContainer[]) result.toArray(new IContainer[result.size()]);
+	}
+
+	/**
+	 * Returns the root folders containing Java output in this module.
+	 * 
+	 * @return a possibly-empty array of Java output folders
+	 */
+	public IContainer[] getJavaOutputFolders() {
+		IVirtualComponent vc = ComponentCore.createComponent(getProject());
+		if (vc == null)
+			return new IContainer[0];
+		
+		return J2EEProjectUtilities.getOutputContainers(getProject());
+	}
+
+	public IModuleResource[] members() throws CoreException {
+		members.clear();
+		IPath javaPath = Path.EMPTY;
+		if (J2EEProjectUtilities.isDynamicWebProject(component.getProject()))
+			javaPath = WEB_CLASSES_PATH;
+		
+		IVirtualComponent vc = ComponentCore.createComponent(getProject());
+		if (vc != null) {
+			IVirtualFolder vFolder = vc.getRootFolder();
+			IModuleResource[] mr = getMembers(vFolder, Path.EMPTY);
+			int size = mr.length;
+			for (int j = 0; j < size; j++) {
+				if (!members.contains(mr[j]))
+					members.add(mr[j]);
+			}
+		}
+		
+		IContainer[] javaCont = getJavaOutputFolders();		
+		int size = javaCont.length;
+		for (int i = 0; i < size; i++) {
+			IModuleResource[] mr = getMembers(javaCont[i], javaPath, javaPath, javaCont);
+			int size2 = mr.length;
+			for (int j = 0; j < size2; j++) {
+				if (!members.contains(mr[j]))
+					members.add(mr[j]);
+			}
+		}
+		
+		IModuleResource[] mr = new IModuleResource[members.size()];
+		members.toArray(mr);
+		return mr;
 	}
 	
-	/*
-	 * @see IModule#getFactoryId()
-	 */
-	public String getFactoryId() {
-		return factoryId;
+	protected IModuleResource[] handleJavaPath(IPath path, IPath javaPath, IPath curPath, IContainer[] javaCont, IModuleResource[] mr, IContainer cc) throws CoreException {
+		if (curPath.equals(javaPath)) {
+			int size = javaCont.length;
+			for (int i = 0; i < size; i++) {
+				IModuleResource[] mr2 = getMembers(javaCont[i], path.append(cc.getName()), null, null);
+				IModuleResource[] mr3 = new IModuleResource[mr.length + mr2.length];
+				System.arraycopy(mr, 0, mr3, 0, mr.length);
+				System.arraycopy(mr2, 0, mr3, mr.length, mr2.length);
+				mr = mr3;
+			}
+		} else {
+			boolean containsFolder = false;
+			String name = javaPath.segment(curPath.segmentCount());
+			int size = mr.length;
+			for (int i = 0; i < size && !containsFolder; i++) {
+				if (mr[i] instanceof IModuleFolder) {
+					IModuleFolder mf2 = (IModuleFolder) mr[i];
+					if (name.equals(mf2.getName())) {
+						containsFolder = true;
+					}
+				}
+			}
+			
+			if (!containsFolder && javaCont.length > 0) {
+				ModuleFolder mf2 = new ModuleFolder(javaCont[0], name, curPath);
+				IModuleResource[] mrf = new IModuleResource[0];
+				size = javaCont.length;
+				for (int i = 0; i < size; i++) {
+					IModuleResource[] mrf2 = getMembers(javaCont[i], javaPath, null, null);
+					IModuleResource[] mrf3 = new IModuleResource[mrf.length + mrf2.length];
+					System.arraycopy(mrf, 0, mrf3, 0, mrf.length);
+					System.arraycopy(mrf2, 0, mrf3, mrf.length, mrf2.length);
+					mrf = mrf3;
+				}
+				
+				mf2.setMembers(mrf);
+				
+				IModuleResource[] mr3 = new IModuleResource[mr.length + 1];
+				System.arraycopy(mr, 0, mr3, 0, mr.length);
+				mr3[mr.length] = mf2;
+				mr = mr3;
+			}
+		}
+		return mr;
 	}
 
-	/**
-	 * @see com.ibm.etools.server.j2ee.IJ2EEModule#isBinary()
-	 */
-	public boolean isBinary() {
-		return false;
-	}
-
-	public String getType() {
-		return J2EEProjectUtilities.getJ2EEProjectType(component.getProject());
-	}
-
-	/**
-	 * Return the module resources for both the component meta folder and the java output folder
-	 * 
-	 * @return IModuleResource[]
-	 */
-    public IModuleResource[] members() throws CoreException {
-        outputMembersAdded = false;
-        members.clear();
-        if (component == null)
-        	return new IModuleResource[] {};
-        try {
-        	// Retrieve the module resources from the virtual component's root folder
-	    	IVirtualFolder componentRoot = component.getRootFolder();
-	    	if (componentRoot!=null && componentRoot.exists()) {
-	    		IModuleResource[] rootResources = getModuleResources(Path.EMPTY, componentRoot);
-	    		members.addAll(Arrays.asList(rootResources));
-	    	}
-	    	
-        } catch (CoreException ce) {
-        	throw ce;
-        }
-        //Return the combined array of the meta resources and java class files
-        return (IModuleResource[]) members.toArray(new IModuleResource[members.size()]);
-    }
-    
-    /**
-     * Helper method to check a given list of resource trees for the given resource.  It will return the
-     * already existing instance of the module Resource if found, or it will return null.
-     * 
-     * @param List moduleResources
-     * @param IModuleResource aModuleResource
-     * @return existing module resource or null
-     */
-    private IModuleResource getExistingModuleResource(List moduleResources, IModuleResource aModuleResource) {
-    	IModuleResource result = null;
-    	// If the list is empty, return null
-    	if (moduleResources==null || moduleResources.isEmpty())
-    		return null;
-    	// Otherwise recursively check to see if given resource matches current resource or if it is a child
-    	int i=0;
-    	do {
-	    	IModuleResource moduleResource = (IModuleResource) moduleResources.get(i);
-	    		if (moduleResource.equals(aModuleResource))
-	    			result = moduleResource;
-	    		// if it is a folder, check its children for the resource path
-	    		else if (moduleResource instanceof IModuleFolder) {
-	    			result = getExistingModuleResource(Arrays.asList(((IModuleFolder)moduleResource).members()),aModuleResource);
-	    		}
-	    		i++;
-    	} while (result == null && i<moduleResources.size() );
-    	return result;
-    }
-    
-    /**
-     * This is a helper method for J2EE deployables to gather the module resources for a J2EE module
-     * using the virtual component API.  it ensures the non java meta files are represented by
-     * appropriate module resource files.
-     * 
-     * @param path
-     * @param container
-     * @return array of IModuleResources
-     * @throws CoreException
-     */
-    protected IModuleResource[] getModuleResources(IPath path, IVirtualContainer container) throws CoreException {
-    	List result = new ArrayList();
-        IVirtualResource[] resources = container.members();
-        if (resources != null) {
-            int size = resources.length;
-            for (int i = 0; i < size; i++) {
-                IVirtualResource resource = resources[i];
-                // If the resource is a folder, we need to add it and recursively add its members
-                if (resource!=null && resource.getType()==IVirtualResource.FOLDER) 
-                	addFolderModuleResources(path,container,resource,result);
-                // If the resource is a file, then make sure it does not exist in module resources, then add
-                else if (resource!=null && resource.getType()==IVirtualResource.FILE)
-                	addFileModuleResource(path,container,resource,result);
-            }
-        }
-        // return the result list as a ModuleResource array
-        return (IModuleResource[]) result.toArray(new IModuleResource[result.size()]);
-    }
-    
-    /**
-     * Helper method to add module resources for the given folder and its children
-     * 
-     * @param path
-     * @param container
-     * @param resource
-     * @param result
-     * @throws CoreException
-     */
-    private void addFolderModuleResources(IPath path, IVirtualContainer container, IVirtualResource resource, List result) throws CoreException {
-        IVirtualContainer container2 = (IVirtualContainer) resource;
-        if (container2 != null && container2.exists()) {
-        	ModuleFolder mf = new ModuleFolder((IContainer)container.getUnderlyingResource(), container2.getName(), path);
-        	//If the folder does not exist yet in module resources, let's create it
-        	if (getExistingModuleResource(members,mf)==null && getExistingModuleResource(result,mf)==null) {
-        		mf.setMembers(getModuleResources(path.append(container2.getName()), container2));
-                result.add(mf);
-        	}
-        	// if folder exists, we need to retreive the existing module folder and update
-        	else {
-        		// first try to retrieve from cached list
-        		ModuleFolder matchingMf = (ModuleFolder) getExistingModuleResource(members,mf);
-        		// if still null, retrieve from current result set which has not been added to cache
-        		if (matchingMf==null)
-        			matchingMf = (ModuleFolder) getExistingModuleResource(result,mf);
-        		// update the members on the existing module resource to have the new children 
-        		List currentMembers = new ArrayList();
-        		List membersList = Arrays.asList(matchingMf.members());
-            	List newMembers = Arrays.asList(getModuleResources(path.append(container2.getName()), container2));
-            	currentMembers.addAll(membersList);
-            	currentMembers.addAll(newMembers);
-            	matchingMf.setMembers((IModuleResource[])currentMembers.toArray(new IModuleResource[currentMembers.size()]));
-        	}
-        }
-    }
-    
-    /**
-     * Helper method to add a module resource for the given file
-     * 
-     * @param path
-     * @param container
-     * @param resource
-     * @param result
-     */
-    private void addFileModuleResource(IPath path, IVirtualContainer container, IVirtualResource resource, List result) {
-    	IFile file = null;
-    	String runtimePath = resource.getRuntimePath().toString();
-    	// temporary hack because virtual component API returns .java rather than .class files
-    	if (runtimePath.endsWith(".java")) { //$NON-NLS-1$
-    		IContainer output = J2EEProjectUtilities.getOutputContainers(container.getComponent().getProject())[0];
-    		runtimePath = resource.getRuntimePath().lastSegment().toString();
-    		String className = runtimePath.substring(0,runtimePath.length()-4)+"class"; //$NON-NLS-1$
-    		file = findClassFileInOutput(output,className);
-    	} else
-    		file = (IFile) resource.getUnderlyingResource();
-    	if (file == null)
-    		return;
-        ModuleFile moduleFile = new ModuleFile(file, file.getName(), path, file.getModificationStamp());
-        // we have to be sure its not in cache and current result group waiting to be added to cache
-        if (file != null && file.exists() && getExistingModuleResource(result,moduleFile)==null && getExistingModuleResource(members,moduleFile)==null)
-            result.add(moduleFile);
-    }
-    
-    private IFile findClassFileInOutput(IContainer container, String className) {
-    	IFile result = null;
-    	result = (IFile) container.findMember(className);
-    	if (result == null) {
-	    	try {
-	    		IResource[] currentMembers = container.members();
-	    		for (int i=0; i<currentMembers.length; i++) {
-	    			if (currentMembers[i].getType()==IResource.FOLDER) {
-	    				result = findClassFileInOutput((IContainer)currentMembers[i],className);
-	    				if (result != null)
-	    					break;
-	    			}
-	    		}
-	    	} catch (Exception e) {}
-    	}
-    	return result;
-    }
-    
-    protected IContainer getContainerResource(IResource resource){
-        if(resource instanceof IFolder) {
-            IJavaElement element =JavaCore.create((IFolder)resource);
-            if (element != null && element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT)
-                //means this is a source folder add output once and only once
-                return addOutputFolderIfNecessary(element);
-        }
-        return (IContainer)resource;
-    }
-    
-    private IContainer addOutputFolderIfNecessary(IJavaElement je) {
-        if(!outputMembersAdded){
-            outputMembersAdded = true;
-            IPath javaOutputPath = null;
-            try {
-                if (je.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
-                    IPackageFragmentRoot packRoot = (IPackageFragmentRoot) je;
-                    if (packRoot.getKind() == IPackageFragmentRoot.K_SOURCE) {
-                        IClasspathEntry ce = packRoot.getRawClasspathEntry();
-                        javaOutputPath = ce.getOutputLocation();
-                        javaOutputPath = javaOutputPath.removeFirstSegments(1);
-                        return getProject().getFolder(javaOutputPath);
-                    }
-                }
-            } catch (JavaModelException e) {
-                Logger.getLogger().log(e.getMessage());
-            }
-        }
-        return null;
-    }
-    
     /**
      * Returns the classpath as a list of absolute IPaths.
      * 
-     * @param java.util.List
+     * @return an array of paths
      */
     public IPath[] getClasspath() {
 		List paths = new ArrayList();
@@ -333,56 +223,43 @@
 		}
 		return modHelper == null ? null : modHelper.getJNDIName(jar, jar.getEnterpriseBeanNamed(ejbName));
 	}
-    
-    /**
-     * Returns the child modules of this module.
-     * 
-     * @return org.eclipse.wst.server.core.model.IModule[]
-     */
-    public IModule[] getChildModules() {
-        return getModules();
-    }
-    
-    public IModule[] getModules() {
-		List modules = new ArrayList();
-    	IVirtualReference[] components = component.getReferences();
-    	for (int i=0; i<components.length; i++) {
-			IVirtualReference reference = components[i];
-			IVirtualComponent virtualComp = reference.getReferencedComponent();
-			Object module = FlexibleProjectServerUtil.getModule(virtualComp.getProject());
-			if (module!=null)
-				modules.add(module);
-		}
-        return (IModule[]) modules.toArray(new IModule[modules.size()]);
-	}
-    
+
     public String getURI(IModule module) {
     	IVirtualComponent comp = ComponentCore.createComponent(module.getProject());
+    	String aURI = null;
     	if (J2EEProjectUtilities.isEARProject(comp.getProject())) {
 			EARArtifactEdit earEdit = null;
-			String aURI = null;
 			try {
 				earEdit = EARArtifactEdit.getEARArtifactEditForRead(component);
-				if (earEdit != null) {
+				if (earEdit != null)
 					aURI = earEdit.getModuleURI(comp);
-				}
 			} catch (Exception e) {
 				e.printStackTrace();
 			} finally {
 				if (earEdit != null)
 					earEdit.dispose();
 			}
-			return aURI;
     	}
     	else if (J2EEProjectUtilities.isDynamicWebProject(comp.getProject())) {
-    		String result = null;
     		if (!comp.isBinary()) {
         		IVirtualReference ref = component.getReference(comp.getName());
-        		result = ref.getRuntimePath().append(comp.getName()+IJ2EEModuleConstants.JAR_EXT).toString();
+        		aURI = ref.getRuntimePath().append(comp.getName()+IJ2EEModuleConstants.WAR_EXT).toString();
         	}
-        	return result;
+    	} else if (J2EEProjectUtilities.isEJBProject(comp.getProject()) || J2EEProjectUtilities.isApplicationClientProject(comp.getProject())) {
+    		if (!comp.isBinary()) {
+        		IVirtualReference ref = component.getReference(comp.getName());
+        		aURI = ref.getRuntimePath().append(comp.getName()+IJ2EEModuleConstants.JAR_EXT).toString();
+        	}
+    	} else if (J2EEProjectUtilities.isJCAProject(comp.getProject())) {
+    		if (!comp.isBinary()) {
+        		IVirtualReference ref = component.getReference(comp.getName());
+        		aURI = ref.getRuntimePath().append(comp.getName()+IJ2EEModuleConstants.RAR_EXT).toString();
+        	}
     	}
-    	return null;
+    	
+    	if (aURI !=null && aURI.length()>1 && aURI.startsWith("/")) //$NON-NLS-1$
+    		aURI = aURI.substring(1);
+    	return aURI;
 	}
     
     public String getContextRoot() {
@@ -391,4 +268,18 @@
 			return props.getProperty(J2EEConstants.CONTEXTROOT);
 	    return component.getName();
     }
+    
+    protected boolean isFileInSourceContainer(IFile file) {
+    	boolean result = false;
+    	if (file == null)
+    		return false;
+    	IPackageFragmentRoot[] srcContainers = J2EEProjectUtilities.getSourceContainers(getProject());
+    	for (int i=0; i<srcContainers.length; i++) {
+    		IPath srcPath = srcContainers[i].getPath();
+    		result = srcPath.isPrefixOf(file.getFullPath());
+    		if (result)
+    			break;
+    	}
+    	return result;
+    }
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/IJ2EEModuleConstants.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/IJ2EEModuleConstants.java
index aa2043b..88d4a30 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/IJ2EEModuleConstants.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/IJ2EEModuleConstants.java
@@ -1,13 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.plugin;
 
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 
 public interface IJ2EEModuleConstants extends IModuleConstants {
 	
-	final String J2EE_PLUGIN_ID = "org.eclipse.jst.j2ee"; //$NON-NLS-1$
+	public static final String J2EE_PLUGIN_ID = "org.eclipse.jst.j2ee"; //$NON-NLS-1$
 	
-	final String JAR_EXT = ".jar"; //$NON-NLS-1$
-	final String WAR_EXT = ".war"; //$NON-NLS-1$
-	final String RAR_EXT = ".rar"; //$NON-NLS-1$
+	public static final String JAR_EXT = ".jar"; //$NON-NLS-1$
+	public static final String WAR_EXT = ".war"; //$NON-NLS-1$
+	public static final String RAR_EXT = ".rar"; //$NON-NLS-1$
 
+	public static final String JST_EAR_TEMPLATE = "template.jst.ear"; //$NON-NLS-1$
+	public static final String JST_UTILITY_TEMPLATE = "template.jst.utility"; //$NON-NLS-1$
+	public static final String JST_APPCLIENT_TEMPLATE = "template.jst.appclient"; //$NON-NLS-1$
+	public static final String JST_EJB_TEMPLATE = "template.jst.ejb"; //$NON-NLS-1$
+	public static final String JST_JCA_TEMPLATE = "template.jst.connector"; //$NON-NLS-1$
+	public static final String JST_WEB_TEMPLATE = "template.jst.web"; //$NON-NLS-1$
+	public static final String WST_WEB_TEMPLATE = "template.wst.web"; //$NON-NLS-1$
 }
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEGroupInitializer.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEGroupInitializer.java
index c7ea080..69cb751 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEGroupInitializer.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEGroupInitializer.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -44,4 +44,4 @@
 		return true;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPlugin.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPlugin.java
index a1f8a69..cc9441e 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPlugin.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPlugin.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -24,6 +24,7 @@
 
 import org.eclipse.core.internal.boot.PlatformURLConnection;
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResourceChangeEvent;
 import org.eclipse.core.resources.IResourceStatus;
 import org.eclipse.core.resources.IWorkspace;
 import org.eclipse.core.resources.IWorkspaceRunnable;
@@ -42,8 +43,10 @@
 import org.eclipse.core.runtime.Status;
 import org.eclipse.emf.common.util.ResourceLocator;
 import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.jdt.core.ElementChangedEvent;
 import org.eclipse.jdt.core.IJavaModel;
 import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jem.util.UIContextDetermination;
 import org.eclipse.jem.workbench.utility.JemProjectUtilities;
 import org.eclipse.jst.j2ee.application.ApplicationFactory;
@@ -59,6 +62,8 @@
 import org.eclipse.jst.j2ee.internal.validation.ResourceUtil;
 import org.eclipse.jst.j2ee.internal.webservices.WSDLServiceExtensionRegistry;
 import org.eclipse.jst.j2ee.internal.xml.J2EEXmlDtDEntityResolver;
+import org.eclipse.jst.j2ee.refactor.listeners.J2EEElementChangedListener;
+import org.eclipse.jst.j2ee.refactor.listeners.ProjectRefactoringListener;
 import org.eclipse.wst.common.componentcore.internal.ArtifactEditModel;
 import org.eclipse.wst.common.componentcore.internal.impl.ReferencedComponentXMIResourceFactory;
 import org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry;
@@ -493,6 +498,14 @@
 		
 		manager.registerAdapters(new VirtualArchiveComponentAdapterFactory(), VirtualArchiveComponent.class );
 		
+		final ProjectRefactoringListener listener = new ProjectRefactoringListener();//ProjectDependencyCache.getCache());
+		// register the project rename/delete refactoring listener
+		ResourcesPlugin.getWorkspace().addResourceChangeListener(listener,
+				IResourceChangeEvent.POST_CHANGE | IResourceChangeEvent.PRE_DELETE);
+		
+		// register the IElementChangedLister that updates the .component file in 
+		// response to .classpath changes
+		JavaCore.addElementChangedListener(new J2EEElementChangedListener(), ElementChangedEvent.POST_CHANGE);
 	}
 
 	/*
@@ -565,4 +578,4 @@
 		return getString(key,substitutions);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPluginResourceHandler.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPluginResourceHandler.java
index 54eb060..f832639 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPluginResourceHandler.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPluginResourceHandler.java
@@ -1,58 +1,76 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.plugin;
 
 
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-public class J2EEPluginResourceHandler {
+public class J2EEPluginResourceHandler extends NLS {
 
-	private static ResourceBundle fgResourceBundle;
+	private static final String BUNDLE_NAME = "j2eewtpplugin";//$NON-NLS-1$
 
-	/**
-	 * Returns the resource bundle used by all classes in this Project
-	 */
-	public static ResourceBundle getResourceBundle() {
-		try {
-			return ResourceBundle.getBundle("j2eewtpplugin");//$NON-NLS-1$
-		} catch (MissingResourceException e) {
-			// does nothing - this method will return null and
-			// getString(String, String) will return the key
-			// it was called with
-		}
-		return null;
+	private J2EEPluginResourceHandler() {
+		// Do not instantiate
 	}
 
-	public static String getString(String key) {
-		if (fgResourceBundle == null) {
-			fgResourceBundle = getResourceBundle();
-		}
+	public static String __Considering_delta_INFO_;
+	public static String WARNING_METAFOLDER_MISSING_UI_;
+	public static String Not_a_J2EE_project_UI_;
+	public static String CoreException_could_not_initialize_Web_Service_class_path_variables_ERROR_;
+	public static String Error_opening_archive_for_export_2;
+	public static String J2EEDeployOperation_2_UI_;
+	public static String No_library_folder_UI_;
+	public static String J2EEDeployOperation_UI_Null_Status;
+	public static String RAR_File;
+	public static String NESTED_JAVA_OUTPUT_ERROR;
+	public static String J2EEModulePostImportHelper_3;
+	public static String J2EEModulePostImportHelper_2;
+	public static String J2EEModulePostImportHelper_1;
+	public static String J2EEModulePostImportHelper_0;
+	public static String Some_source_types_have______in_their_name_ERROR_;
+	public static String J2EEDeployOperation_UI_1;
+	public static String J2EEDeployOperation_UI_0;
+	public static String _UI_ParamValue_type;
+	public static String J2EEDeployOperation_1_UI_;
+	public static String An_error_occurred_while_sa_ERROR_;
+	public static String WARNING_FILE_MISSING_UI_;
+	public static String Cannot_load_EJBJar_because_model_is_null_UI_;
+	public static String __Bad_builder_order_for_project_INFO_;
+	public static String No_source_types_UI_;
+	public static String EJBProjectResources_getEJBJar_EJBEditModel__UI_;
+	public static String __No_imported_classes_folder__quitting_INFO_;
+	public static String The_following_resources_ne_UI_;
+	public static String J2EEDeployOperation_4_UI_;
+	public static String __Full_first_build_INFO_;
+	public static String Error_occurred_saving_the_manifest_7;
+	public static String Cannot_load_EJBFile_because_ejbNature_asEJBJarFile___returns_null_UI_;
+	public static String __Delta_build_INFO_;
+	public static String __Start_build_project_INFO_;
+	public static String Cannot_load_EJBFile_because_EJBNatureRuntime_is_null_UI_;
+	public static String Minimizing_project_UI_;
+	public static String Error_getting_project_nature_runtime_6;
+	public static String Creating_Connector_Project_5;
+	public static String Error_getting_project_nature_runtime_3;
+	public static String J2EEDeployOperation_3_UI_;
+	public static String Unable_to_save_read_only_f_ERROR_;
+	public static String Could_not_find_root_object_ERROR_;
+	public static String Cannot_run_J2EEUIWorkingCo_ERROR_;
+	public static String Cannot_load_EJBFile_because_EJBEditModel_is_null_UI_;
+	public static String Error_occurred_loading_ra_xml__4;
 
-		if (fgResourceBundle != null) {
-			try {
-				return fgResourceBundle.getString(key);
-			} catch (MissingResourceException e) {
-				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
-			}
-		}
-		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, J2EEPluginResourceHandler.class);
 	}
 
 	public static String getString(String key, Object[] args) {
-
-		try {
-			return MessageFormat.format(getString(key), args);
-		} catch (IllegalArgumentException e) {
-			return getString(key);
-		}
-
+		return NLS.bind(key, args);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/LibCopyBuilder.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/LibCopyBuilder.java
index 34dabd8..9332a37 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/LibCopyBuilder.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/LibCopyBuilder.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -109,20 +109,20 @@
 		sourceContainers = null;
 		needOutputRefresh = false;
 		if (DEBUG) {
-			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.getString("__Start_build_project_INFO_") + getProject().getName()); //$NON-NLS-1$
+			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.__Start_build_project_INFO_ + getProject().getName()); 
 		}
 
 		boolean builderOrderOK = checkBuilderOrdering();
 
 		if (DEBUG && !builderOrderOK) {
-			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.getString("__Bad_builder_order_for_project_INFO_") + getProject().getName()); //$NON-NLS-1$
+			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.__Bad_builder_order_for_project_INFO_ + getProject().getName()); 
 		}
 
 		IFolder[] classFolders = getClassesFolders();
 		if (classFolders.length == 0) {
 			// no files to copy
 			if (DEBUG)
-				System.out.println(BUILDER_ID + J2EEPluginResourceHandler.getString("__No_imported_classes_folder,_quitting_INFO_")); //$NON-NLS-1$
+				System.out.println(BUILDER_ID + J2EEPluginResourceHandler.__No_imported_classes_folder__quitting_INFO_); 
 			return null;
 		}
 
@@ -143,7 +143,7 @@
 		}
 
 		if (DEBUG) {
-			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.getString("__Full/first_build_INFO_")); //$NON-NLS-1$
+			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.__Full_first_build_INFO_);
 		}
 		copyAllClassFolders(monitor, classFolders, outputFolder);
 		lastOutputPath = outputPath;
@@ -180,7 +180,7 @@
 	 */
 	protected void processDelta(IResourceDelta delta, final IFolder outputFolder, final IProgressMonitor monitor, final IFolder[] classesFolders) {
 		if (DEBUG) {
-			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.getString("__Considering_delta_INFO_") + delta); //$NON-NLS-1$
+			System.out.println(BUILDER_ID + J2EEPluginResourceHandler.__Considering_delta_INFO_ + delta); 
 		}
 		IResourceDeltaVisitor visitor = new IResourceDeltaVisitor() {
 			private List copiedClassFolders = new ArrayList(classesFolders.length);
@@ -195,7 +195,7 @@
 							case IResourceDelta.ADDED :
 							case IResourceDelta.CHANGED :
 								if (DEBUG) {
-									System.out.println(BUILDER_ID + J2EEPluginResourceHandler.getString("__Delta_build_INFO_") + subdelta); //$NON-NLS-1$
+									System.out.println(BUILDER_ID + J2EEPluginResourceHandler.__Delta_build_INFO_ + subdelta); 
 								}
 								copyClassFiles(classesFolder, outputFolder, monitor);
 								break;
@@ -503,4 +503,4 @@
 			return new IFolder[0];
 		return (IFolder[]) result.toArray(new IFolder[result.size()]);
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/AWorkbenchMOFHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/AWorkbenchMOFHelper.java
index e31bbce..6e373f1 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/AWorkbenchMOFHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/AWorkbenchMOFHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -89,4 +89,4 @@
 		}
 		return null;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ApplicationClientHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ApplicationClientHelper.java
index 361278b..616a9da 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ApplicationClientHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ApplicationClientHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -82,4 +82,4 @@
 		if (appClientFile != null)
 			appClientFile.close();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/DependencyUtil.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/DependencyUtil.java
index 17e99e2..809f5c7 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/DependencyUtil.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/DependencyUtil.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others.
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -239,4 +239,4 @@
 			return EMPTY_JAVAPROJECTS;
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/EarHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/EarHelper.java
index 971825e..ab4ec2e 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/EarHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/EarHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.validation;
 
 
@@ -97,4 +99,4 @@
 			earFile = null;
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/J2EEValidationHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/J2EEValidationHelper.java
index 71d08a9..43b9abf 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/J2EEValidationHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/J2EEValidationHelper.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.validation;
 
 
@@ -102,4 +104,4 @@
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ManifestLineValidator.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ManifestLineValidator.java
index ddc79f1..d8ac09f 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ManifestLineValidator.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ManifestLineValidator.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.validation;
 
 
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ProjectValidationHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ProjectValidationHelper.java
index 0ac981e..4e5090f 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ProjectValidationHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ProjectValidationHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -25,30 +25,62 @@
 public class ProjectValidationHelper implements IProjectValidationHelper {
 
 	private static IContainer[] EMPTY_RESULT = new IContainer[] {};
+	private static ProjectValidationHelper INSTANCE;
+	private IContainer[] outputs;
+	private IContainer[] sources;
 	
-	public IContainer[] getOutputContainers(IProject project) {
-		
-		if (project == null || JemProjectUtilities.getJavaProject(project)==null)
+	public static ProjectValidationHelper getInstance(){
+		if (INSTANCE == null)
+			INSTANCE = new ProjectValidationHelper();
+		return INSTANCE;
+	}
+	public void disposeInstance(){
+		INSTANCE = null;
+	}
+	private IContainer[] getCachedOutputContainers(IProject project) {
+		if (outputs != null)
+			return outputs;
+		if (project == null || JemProjectUtilities.getJavaProject(project)==null) {
+			outputs = EMPTY_RESULT;
 			return EMPTY_RESULT;
+		}
 		IVirtualComponent comp = ComponentCore.createComponent(project);
-		if (comp == null || !comp.exists())
+		if (comp == null || !comp.exists()) {
+			outputs = EMPTY_RESULT;
 			return EMPTY_RESULT;
-		return J2EEProjectUtilities.getOutputContainers(project);
+		}
+		outputs = J2EEProjectUtilities.getOutputContainers(project);
+		return outputs;
+	
+	}
+	public IContainer[] getOutputContainers(IProject project) {
+		return getInstance().getCachedOutputContainers(project);
 	}
 	
-	public IContainer[] getSourceContainers(IProject project) {
-		if (project == null || JemProjectUtilities.getJavaProject(project)==null)
+	private IContainer[] getCachedSourceContainers(IProject project) {
+		if (sources != null)
+			return sources;
+		if (project == null || JemProjectUtilities.getJavaProject(project)==null) {
+			sources = EMPTY_RESULT;
 			return EMPTY_RESULT;
+		}
 		IVirtualComponent comp = ComponentCore.createComponent(project);
-		if (comp == null || !comp.exists())
+		if (comp == null || !comp.exists()) {
+			sources = EMPTY_RESULT;
 			return EMPTY_RESULT;
+		}
 		IPackageFragmentRoot[] roots = J2EEProjectUtilities.getSourceContainers(project);
 		List result = new ArrayList();
 		for (int i=0; i<roots.length; i++) {
 			if (roots[i].getResource() != null && roots[i].getResource() instanceof IContainer)
 				result.add(roots[i].getResource());
 		}
-		return (IContainer[]) result.toArray(new IContainer[result.size()]);
+		sources = (IContainer[]) result.toArray(new IContainer[result.size()]);
+		return sources;
+		
+	}
+	public IContainer[] getSourceContainers(IProject project) {
+		return getInstance().getCachedSourceContainers(project);
 	}
 
 }
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ResourceUtil.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ResourceUtil.java
index a4609a5..acb8bae 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ResourceUtil.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/ResourceUtil.java
@@ -1,11 +1,13 @@
-/***************************************************************************************************
- * Copyright (c) 2001, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2001, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.validation;
 
 
@@ -56,4 +58,4 @@
 
 		return IMessage.LINENO_UNSET;
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientMessageConstants.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientMessageConstants.java
index a2e9e3a..29bb967 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientMessageConstants.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientMessageConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientValidator.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientValidator.java
index 1cd30ed..8a29de7 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientValidator.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIApplicationClientValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarHelper.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarHelper.java
index eb56772..623c8cb 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarHelper.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarHelper.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -24,4 +24,4 @@
 	public UIEarHelper() {
 		super();
 	}
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarMessageConstants.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarMessageConstants.java
index 309b9cd..01d3189 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarMessageConstants.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarMessageConstants.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -46,4 +46,4 @@
 	public static final String INVALID_EAR_SERVER_TARGET_FOR_14_SPEC_LEVEL = "INVALID_EAR_SERVER_TARGET_FOR_14_SPEC_LEVEL";//$NON-NLS-1$
 	public static final String INVALID_MODULE_SERVER_TARGET_FOR_14_SPEC_LEVEL = "INVALID_MODULE_SERVER_TARGET_FOR_14_SPEC_LEVEL";//$NON-NLS-1$
 
-}
\ No newline at end of file
+}
diff --git a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarValidator.java b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarValidator.java
index 982d78e..c1ea1f6 100644
--- a/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarValidator.java
+++ b/plugins/org.eclipse.jst.j2ee/j2eeplugin/org/eclipse/jst/j2ee/internal/validation/UIEarValidator.java
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
+ *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -24,12 +24,16 @@
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.emf.common.command.Command;
+import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.URIConverter;
 import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverter;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.jem.workbench.utility.JemProjectUtilities;
+import org.eclipse.jst.j2ee.application.EjbModule;
+import org.eclipse.jst.j2ee.application.Module;
+import org.eclipse.jst.j2ee.application.WebModule;
 import org.eclipse.jst.j2ee.common.EjbRef;
 import org.eclipse.jst.j2ee.common.MessageDestinationRef;
 import org.eclipse.jst.j2ee.common.ResourceEnvRef;
@@ -40,6 +44,7 @@
 import org.eclipse.jst.j2ee.commonarchivecore.internal.ModuleFile;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.ValidateXmlCommand;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ManifestException;
+import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveConstants;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
 import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit;
@@ -49,8 +54,6 @@
 import org.eclipse.jst.j2ee.model.internal.validation.EarValidator;
 import org.eclipse.jst.j2ee.webservice.wsclient.ServiceRef;
 import org.eclipse.wst.common.componentcore.ComponentCore;
-import org.eclipse.wst.common.componentcore.internal.StructureEdit;
-import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
 import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
@@ -193,12 +196,12 @@
 	public void validate(IValidationContext inHelper, IReporter inReporter) throws org.eclipse.wst.validation.internal.core.ValidationException {
 		earHelper = ((UIEarHelper) inHelper);
 		IProject proj = ((IWorkbenchContext) inHelper).getProject();
-		IVirtualComponent wbModule = ComponentCore.createComponent(proj);
+		IVirtualComponent earModule = ComponentCore.createComponent(proj);
             if(J2EEProjectUtilities.isEARProject(proj)){
-				IVirtualFile ddFile = wbModule.getRootFolder().getFile(J2EEConstants.APPLICATION_DD_URI);
+				IVirtualFile ddFile = earModule.getRootFolder().getFile(J2EEConstants.APPLICATION_DD_URI);
 				if( ddFile.exists()) {				
 					super.validate(inHelper, inReporter);
-	//				validateModuleMaps(earEdit,earModule);
+					validateModuleMaps(earModule);
 					validateManifests();
 	//				validateUtilJarMaps(earEdit,earModule);
 	//				validateUriAlreadyExistsInEar(earEdit,earModule);
@@ -208,15 +211,7 @@
 		
 	}	
 
-	
 
-//	protected IProject getProject(Archive anArchive, EARFile earFileParam) {
-//		LoadStrategy loader = anArchive.getLoadStrategy();
-//		if (!(loader instanceof J2EELoadStrategyImpl))
-//			return ModuleMapHelper.getProject(anArchive.getURI(), earFileParam);
-//
-//		return ((J2EELoadStrategyImpl) loader).getProject();
-//	}
 
 	public void validateManifests() throws ValidationException {
 		
@@ -226,8 +221,6 @@
 		for (int i = 0; i < archives.size(); i++) {
 			try {
 				Archive anArchive = (Archive) archives.get(i);
-				//IProject project = getProject(anArchive, earFile);
-				//if (project != null && project.isAccessible()) {
 
 					IFile target = getManifestFile(anArchive);
 					if (target != null)
@@ -235,7 +228,7 @@
 					validateManifestCase(anArchive);
 					validateManifestLines(anArchive);
 					validateManifestClasspath(anArchive);
-				//}
+
 			} catch (MessageLimitException me) {
 			}
 		}
@@ -266,7 +259,7 @@
 
 	}
 
-	//public void validateManifestClasspath(IVirtualComponent component, Archive anArchive) throws ValidationException {
+
 	public void validateManifestClasspath(Archive anArchive) throws ValidationException {
 		ArchiveManifest manifest = null;
 		try{
@@ -280,7 +273,7 @@
 		
 		if(manifest == null)
 			return;
-		//String[] cp = anArchive.getManifest().getClassPathTokenized();
+
 		String[] cp = manifest.getClassPathTokenized();
 		
 		for (int i = 0; i < cp.length; i++) {
@@ -504,208 +497,50 @@
 		addError(getBaseName(), DUPLICATE_UTILJAR_FOR_PROJECT_NAME_ERROR_, params);
 	}// duplicateUtilError
 
-	public void validateModuleMaps(EARArtifactEdit edit, IVirtualComponent module) {
-		IVirtualReference[] modules = edit.getJ2EEModuleReferences();
-		StructureEdit mc = null;
-		if (modules.length > 0) {
-			for (int i = 0; i < modules.length; i++) {
-				try {
-				IVirtualReference aModuleRef = modules[i];
-				IVirtualComponent component = aModuleRef.getEnclosingComponent();
-				boolean uriExists = edit.uriExists(module.getName());
-				if (!uriExists) {
-					String[] params = new String[]{component.getName(), earHelper.getProject().getName()};
-					addWarning(getBaseName(), MISSING_PROJECT_FORMODULE_WARN_, params);
-				} else {
-					String projectName = component.getName();
-					if (projectName == null || projectName.length() == 0) {
-						String[] params = new String[]{component.getName(), earHelper.getProject().getName()};
-						addWarning(getBaseName(), MISSING_PROJECT_FORMODULE_WARN_, params);
-					} else {
-						mc = StructureEdit.getStructureEditForRead(earHelper.getProject());
-						WorkbenchComponent deployModule = mc.getComponent();
-						if (deployModule == null) {
-							String[] params = new String[]{deployModule.getName(),component.getName(), earHelper.getProject().getName()};
-							addWarning(getBaseName(), PROJECT_DOES_NOT_EXIST_WARN_, params);
-						} else if (earHelper.getProject().isOpen()) {
-							String[] params = new String[]{earHelper.getProject().getName()};
-							addWarning(getBaseName(), PROJECT_IS_CLOSED_WARN_, params);
-						} else {
-							
-							//validateModuleProjectsForValidNature(module);
-							//validateModuleProjectForValidServerTarget(project);
+	public void validateModuleMaps(IVirtualComponent component) {
+		IVirtualFile ddFile = component.getRootFolder().getFile(J2EEConstants.APPLICATION_DD_URI);
+		if( ddFile.exists()){
+			EList modules = appDD.getModules();
+			if (!modules.isEmpty()) {
+				EARArtifactEdit edit = null;
+				try{
+					edit = EARArtifactEdit.getEARArtifactEditForRead( component.getProject() );
+					
+					for (int i = 0; i < modules.size(); i++) {
+						Module module = (Module) modules.get(i);
+						String uri = module.getUri();
+						IVirtualComponent referencedComp = edit.getModule( uri );
+						if( referencedComp == null ){
+							String[] params = new String[]{uri, component.getProject().getName()};
+							addWarning(getBaseName(), MISSING_PROJECT_FORMODULE_WARN_, params);							
 						}
+						validateModuleURIExtension(module);
 					}
+				}finally{
+					if( edit != null )
+						edit.dispose();					
 				}
-				validateModuleURIExtension(module);
-				} finally {
-					if (mc != null)
-						mc.dispose();
-				}
-			}
-		}
-		//validateEARServerTargetJ2EESpecLevel(earEditModel);
-		//validateModuleMapsDuplicateProjects(earEditModel);
-	}
-
-
-	/**
-	 * @param project
-	 * This validation is not needed for Flex project
-	 */
-	/*private void validateModuleProjectForValidServerTarget(IProject project) {
-		IRuntime runtime = ServerCore.getProjectProperties(project).getRuntimeTarget();
-
-		EARNatureRuntime nature = earEditModel.getEARNature();
-		IProject earProject = nature.getProject();
-		IRuntime earRuntime = ServerCore.getProjectProperties(earProject).getRuntimeTarget();
-		if (earRuntime != null) {
-			if (runtime != null) {
-				if (runtime.getId() != earRuntime.getId())
-					unmatachedServerTargetOnModuleWarning(project, earProject);
-				//validateModuleServerTargetJ2EESpecLevel(project, runtime);
-			} else {
-				missingServerTargetOnModuleWarning(project, earProject);
-			}
-		} else if (runtime != null) {
-			missingServerTargetOnEARWarning(project, earProject);
-		}
-	}*/
-
-//	private void missingServerTargetOnEARWarning(IProject aProject, IProject earProject) {
-//		String[] params = new String[]{earProject.getName(), aProject.getName()};
-//		addWarning(getBaseName(), NO_SERVER_TARGET_ON_EAR_WITH_MODULE_SERVER_TARGETS, params);
-//	}
-//
-//	private void unmatachedServerTargetOnModuleWarning(IProject aProject, IProject earProject) {
-//		String[] params = new String[]{aProject.getName(), earProject.getName()};
-//		addWarning(getBaseName(), PROJECT_SERVER_TARGET_DOES_NOT_MATCH_EAR, params);
-//	}
-//
-//	private void missingServerTargetOnModuleWarning(IProject aProject, IProject earProject) {
-//		String[] params = new String[]{aProject.getName(), earProject.getName()};
-//		addWarning(getBaseName(), NO_SERVER_TARGET_MODULE_IN_EAR_WITH_SERVER_TARGET, params);
-//	}
-
-	/**
-	 * @param earProject
-	 *            
-	 * TODO This validation is RAD specific hence needs to be moved to a the RAD layered
-	 * plugin references to this method are commented out
-	 * This validation is not needed anymore for flex project
-	 */
-	/*private void validateEARServerTargetJ2EESpecLevel(EAREditModel editModel) {
-		EARNatureRuntime nature = earEditModel.getEARNature();
-		IProject earProject = nature.getProject();
-		IRuntime earRuntime = ServerCore.getProjectProperties(earProject).getRuntimeTarget();
-		if (earRuntime != null) {
-			try {
-				if (earProject.hasNature(IEARNatureConstants.NATURE_ID) && nature.getModuleVersion() == J2EEVersionConstants.J2EE_1_4_ID && !earRuntime.getRuntimeType().getVersion().equals("6.0")) { //$NON-NLS-1$
-					String[] params = new String[]{earProject.getName(), earRuntime.getName()};
-					addError(getBaseName(), INVALID_EAR_SERVER_TARGET_FOR_14_SPEC_LEVEL, params, earProject);
-				}
-			} catch (CoreException ce) {
-				Logger.getLogger().logError(ce);
-			}
-		}
-	}*/
-
-	/**
-	 * @param project
-	 *            TODO This validation is RAD specific hence needs to be moved to a the RAD layered
-	 *            plugin references to this method are commented out
-	 * This validation is no needed anymore for Flex project
-	 */
-	/*private void validateModuleServerTargetJ2EESpecLevel(IProject project, IRuntime runtime) {
-		boolean is14SpecLevelProject = false;
-		if (J2EENature.hasRuntime(project, new String[]{IWebNatureConstants.J2EE_NATURE_ID, IEJBNatureConstants.NATURE_ID, IApplicationClientNatureConstants.NATURE_ID})) {
-			J2EENature j2eeNature = J2EENature.getRegisteredRuntime(project);
-			is14SpecLevelProject = j2eeNature.getJ2EEVersion() == J2EEVersionConstants.J2EE_1_4_ID;
-			if (is14SpecLevelProject && !runtime.getRuntimeType().getVersion().equals("6.0")) { //$NON-NLS-1$
-				String[] params = new String[]{project.getName(), runtime.getName()};
-				addError(getBaseName(), INVALID_MODULE_SERVER_TARGET_FOR_14_SPEC_LEVEL, params);
-			}
-		}
-	}*/
-	
-	
-	//The module maps validation needs to be done in the component validator for flex project
-	/*protected void validateModuleMapsDuplicateProjects(WorkbenchComponent module) {
-		java.util.List moduleMaps = module.getReferencedComponents();
-		java.util.Set visitedProjectNames = new java.util.HashSet();
-		for (int i = 0; i < moduleMaps.size(); i++) {
-			WorkbenchComponent map = (WorkbenchComponent) moduleMaps.get(i);
-			if (map.getModule() != null) {
-				String moduleUri = map.getModule().getUri();
-				String earProjectName = earEditModelParam.getEARNature().getProject().getName();
-				String projectName = map.getProjectName();
-				if (visitedProjectNames.contains(projectName))
-					duplicateProjectMapError(earProjectName, moduleUri, projectName);
-				else
-					visitedProjectNames.add(projectName);
-			}
-		}
-	}*/
-
-	protected void validateModuleURIExtension(IVirtualComponent module) {
-		String fileExt = module.getRootFolder().getFileExtension();
-		if (fileExt != null && fileExt.length() > 0) {
-			if (J2EEProjectUtilities.isEJBProject(module.getProject()) && !fileExt.endsWith(".jar")) { //$NON-NLS-1$
-				String[] params = new String[1];
-				params[0] = module.getName();
-				IResource target = earHelper.getProject().getFile(J2EEConstants.APPLICATION_DD_URI);
-				addError(getBaseName(), INVALID_URI_FOR_MODULE_ERROR_, params, target);
-			} else if (J2EEProjectUtilities.isDynamicWebProject(module.getProject()) && !fileExt.endsWith(".war")) { //$NON-NLS-1$
-				String[] params = new String[1];
-				params[0] = module.getName();
-				IResource target = earHelper.getProject().getFile(J2EEConstants.APPLICATION_DD_URI);
-				addError(getBaseName(), INVALID_URI_FOR_MODULE_ERROR_, params, target);
 			}
 		}
 	}
 
-	/*
-	 * This validation is not needed anymore for flex project
-	 * public void validateModuleProjectsForValidNature(WorkbenchComponent module) {
-		
-		try {
-			if (module.getComponentType().getModuleTypeId().equals(IModuleConstants.JST_WEB_MODULE)) {
-				if (!project.hasNature(IWebNatureConstants.J2EE_NATURE_ID)) {
-					String[] params = new String[2];
-					params[0] = project.getName();
-					params[1] = earHelper.getProject().getName();
-					addWarning(getBaseName(), MISSING_WEBNATURE_FORMODULE_WARN_, params, appDD);
-				} else {
-					WebModuleExtension webExt = EarModuleManager.getWebModuleExtension();
-					if (webExt != null && !(webExt.compareWebContextRoot(module, project))) {
-						String[] params = new String[3];
-						params[0] = module.getUri();
-						params[1] = earHelper.getProject().getName();
-						params[2] = project.getName();
-						addWarning(getBaseName(), INVALID_CONTEXTROOT_WEBMODULE_WARN_, params, appDD);
-					}
-				}
 
-			} else if (module.getComponentType().getModuleTypeId().equals(IModuleConstants.JST_EJB_MODULE)) {
-				if (!project.hasNature(IEJBNatureConstants.NATURE_ID)) {
-					String[] params = new String[2];
-					params[0] = project.getName();
-					params[1] = earHelper.getProject().getName();
-					addWarning(getBaseName(), MISSING_EJBNATURE_FORMODULE_WARN_, params);
-				}
-			} else if (module.getComponentType().getModuleTypeId().equals(IModuleConstants.JST_UTILITY_MODULE)) {
-				if (!ApplicationClientNatureRuntime.hasRuntime(project)) {
-					String[] params = new String[2];
-					params[0] = project.getName();
-					params[1] = earHelper.getProject().getName();
-					addWarning(getBaseName(), MISSING_CLIENTNATURE_FORMODULE_WARN_, params);
-				}
+	protected void validateModuleURIExtension(Module module) {
+		String newUri = module.getUri();
+		if (newUri != null && newUri.length() > 0) {
+			if (module instanceof EjbModule && !newUri.endsWith(".jar")) { //$NON-NLS-1$
+				String[] params = new String[1];
+				params[0] = module.getUri();
+				IResource target = earHelper.getProject().getFile(ArchiveConstants.APPLICATION_DD_URI);
+				addError(getBaseName(), INVALID_URI_FOR_MODULE_ERROR_, params, target);
+			} else if (module instanceof WebModule && !newUri.endsWith(".war")) { //$NON-NLS-1$
+				String[] params = new String[1];
+				params[0] = module.getUri();
+				IResource target = earHelper.getProject().getFile(ArchiveConstants.APPLICATION_DD_URI);
+				addError(getBaseName(), INVALID_URI_FOR_MODULE_ERROR_, params, target);
 			}
-		} catch (org.eclipse.core.runtime.CoreException ce) {
-			org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(ce);
 		}
-
-	}*/
+	}
 
 	/*
 	 * @see J2EEValidator#cleanup()
diff --git a/plugins/org.eclipse.jst.j2ee/plugin.properties b/plugins/org.eclipse.jst.j2ee/plugin.properties
index 6102c3b..0c19b95 100644
--- a/plugins/org.eclipse.jst.j2ee/plugin.properties
+++ b/plugins/org.eclipse.jst.j2ee/plugin.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee/plugin.xml b/plugins/org.eclipse.jst.j2ee/plugin.xml
index 72979f1..9165361 100644
--- a/plugins/org.eclipse.jst.j2ee/plugin.xml
+++ b/plugins/org.eclipse.jst.j2ee/plugin.xml
@@ -526,7 +526,7 @@
     <project-facet id="jst.ear">
       <label>EAR</label>
       <description>Enables the project to be deployed as an EAR module.</description>
-      <icon>icons/ear.gif</icon>
+      <icon>icons/EAR.gif</icon>
     </project-facet>
 
     <project-facet-version facet="jst.ear" version="1.2">
@@ -534,9 +534,9 @@
         <delegate class="org.eclipse.jst.j2ee.project.facet.EarFacetInstallDelegate"/>
         <config-factory class="org.eclipse.jst.j2ee.internal.earcreation.EarFacetInstallDataModelProvider"/>
       </action>
-      <action type="version-change">
+<!--  <action type="version-change">
         <delegate class="org.eclipse.jst.j2ee.project.facet.EarFacetVersionChangeDelegate"/>
-      </action>
+      </action> -->
       <constraint>
         <and>
           <conflicts group="modules"/>
@@ -550,9 +550,9 @@
         <delegate class="org.eclipse.jst.j2ee.project.facet.EarFacetInstallDelegate"/>
         <config-factory class="org.eclipse.jst.j2ee.internal.earcreation.EarFacetInstallDataModelProvider"/>
       </action>
-      <action type="version-change">
+  <!-- <action type="version-change">
         <delegate class="org.eclipse.jst.j2ee.project.facet.EarFacetVersionChangeDelegate"/>
-      </action>
+      </action> -->
       <constraint>
         <and>
           <conflicts group="modules"/>
@@ -566,9 +566,9 @@
         <delegate class="org.eclipse.jst.j2ee.project.facet.EarFacetInstallDelegate"/>
         <config-factory class="org.eclipse.jst.j2ee.internal.earcreation.EarFacetInstallDataModelProvider"/>
       </action>
-      <action type="version-change">
+ <!-- <action type="version-change">
         <delegate class="org.eclipse.jst.j2ee.project.facet.EarFacetVersionChangeDelegate"/>
-      </action>
+      </action> -->
       <constraint>
         <and>
           <conflicts group="modules"/>
@@ -592,7 +592,7 @@
       </action>
       <constraint>
         <and>
-          <requires facet="jst.java" version="1.3" allow-newer="true"/>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -616,6 +616,7 @@
       </action>
       <constraint>
         <and>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -632,6 +633,7 @@
       </action>
       <constraint>
         <and>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -648,6 +650,7 @@
       </action>
       <constraint>
         <and>
+          <requires facet="jst.java" version="&gt;=1.3"/>
           <conflicts group="modules"/>
         </and>
       </constraint>
@@ -661,13 +664,13 @@
     </template>
     
     <template id="template.jst.utility">
-      <label>Utility Project</label>
+      <label>Java Utility Project</label>
       <fixed facet="jst.java"/>
       <fixed facet="jst.utility"/>
     </template>
 
     <template id="template.jst.appclient">
-      <label>EAR Project</label>
+      <label>Application Client Project</label>
       <fixed facet="jst.java"/>
       <fixed facet="jst.appclient"/>
     </template>    
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/appclientarchiveops.properties b/plugins/org.eclipse.jst.j2ee/property_files/appclientarchiveops.properties
index f761423..bac1406 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/appclientarchiveops.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/appclientarchiveops.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -22,4 +22,4 @@
 APPCLIENT_IMPORT_ERROR=Error importing application client file..
 ARCHIVE_OPERATION_ErrorOccured=Error occurred getting module folder name..
 Application_Client_File_UI_=Application Client File
-(c)_Copyright_IBM_Corporation_2001_1=(c) Copyright IBM Corporation 2001
+_c__Copyright_IBM_Corporation_2001_1=(c) Copyright IBM Corporation 2001
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/appclientcreation.properties b/plugins/org.eclipse.jst.j2ee/property_files/appclientcreation.properties
index 6b04f20..f42d2b8 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/appclientcreation.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/appclientcreation.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/commonedit.properties b/plugins/org.eclipse.jst.j2ee/property_files/commonedit.properties
index a81abe8..92b14c0 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/commonedit.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/commonedit.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/eararchiveops.properties b/plugins/org.eclipse.jst.j2ee/property_files/eararchiveops.properties
index b061128..975e160 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/eararchiveops.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/eararchiveops.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -30,6 +30,6 @@
 Updating_project_classpath_UI_=Updating project classpaths...
 
 UNABLE_TO_LOAD_MODULE_ERROR_=IWAE0001E The module \" {0} \" in Enterprise Application project \" {1} \" could not be loaded.\n {2};
-.jar_UI_=.jar
-Updating_manifest_Class-Path__attributes_UI_=Updating manifest Class-Path: attributes
-.preDeploy_ERROR_=IWAE0002E {0}.preDeploy
+_jar_UI_=.jar
+Updating_manifest_Class_Path__attributes_UI_=Updating manifest Class-Path: attributes
+_preDeploy_ERROR_=IWAE0002E {0}.preDeploy
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/earcreation.properties b/plugins/org.eclipse.jst.j2ee/property_files/earcreation.properties
index b7cea65..d51443b 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/earcreation.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/earcreation.properties
@@ -1,17 +1,17 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
 Error_occured_getting_appl_ERROR_=IWAE0001E Error occurred getting appliction.xml:
 Error_occured_getting_appl1_ERROR_=IWAE0002E Error occurred getting application.xml:
 Creating__UI_=Creating:
-Creating_EAR_Project..._UI_=Creating Enterprise Application project...
+Creating_EAR_Project_UI_=Creating Enterprise Application project...
 The_project_already_exist_ERROR_=IWAE0003E The project already exist.
 EARProjectCreationOperatio_ERROR_=IWAE0004E EARProjectCreationOperation.getNewProject :
 ABS_PATH_CHANGED_UI_=The IBM extensions file contains deprecated absolute paths.  This can be auto-corrected and should be saved.  This will remove the paths from the file, and only needs to be done once.  Would you like to auto-correct?
@@ -32,27 +32,26 @@
 NoModulesSelected=No module types selected.
 
 
-1=Project must be of type Web, EJB, Application client or Connector
-2=Module already exists.
-3=Selected project is closed.
-4=Select a project from the list.
-5=URI exists.
-6=Selected project is not a Java project.
-7=The uri must end with '.jar'.
-8=Utility JAR already exists.
-9=An open EAR project is required.
-10=URI cannot be empty.
-11=The module "{0}" is not an Application Client module.
-12=The module "{0}" is not an EAR module.
-13=The module "{0}" is not an EJB module.
-14=The module "{0}" is not a RAR module.
-15=The module "{0}" is not a WAR module.
-16=The selected server target is not valid for the specified EAR component. The selected server may not support EAR component.
-EAR_PROJECTNAME_SAMEAS_MODULE
+KEY_1=Project must be of type Web, EJB, Application client or Connector
+KEY_2=Module already exists.
+KEY_3=Selected project is closed.
+KEY_4=Select a project from the list.
+KEY_5=URI exists.
+KEY_6=Selected project is not a Java project.
+KEY_7=The uri must end with '.jar'.
+KEY_8=Utility JAR already exists.
+KEY_9=An open EAR project is required.
+KEY_10=URI cannot be empty.
+KEY_11=The module "{0}" is not an Application Client module.
+KEY_12=The module "{0}" is not an EAR module.
+KEY_13=The module "{0}" is not an EJB module.
+KEY_14=The module "{0}" is not a RAR module.
+KEY_15=The module "{0}" is not a WAR module.
+KEY_16=The selected server target is not valid for the specified EAR component. The selected server may not support EAR component.
 J2EEUtilityJarListImportOperation_UI_0=Import Utility Jars
 J2EEUtilityJarListImportOperation_UI_1=Importing
 J2EEUtilityJarListImportOperation_UI_2=Problem importing Utility Jar
-J2EEUtilityJarListImportDataModel.0=Invalid path location.
+J2EEUtilityJarListImportDataModel_0=Invalid path location.
 J2EEUtilityJarListImportDataModel_Specify_Valid_Project=Please specify a valid Enterprise Application Project.
 J2EEUtilityJarListImportDataModel_Select_Jar=Please select one or more Utility Jars.
 J2EEUtilityJarListImportDataModel_Specify_Linked_Path=Please specify a non-empty value for the Linked Path Variable name.
@@ -64,4 +63,4 @@
 UtilityJARMappingImpl_UI_0=projectName: {0}, uri: {1}
 importWrongType=The specified project \" {0} \" is not the correct J2EE type.
 importWrongVersion=The specified project \" {0} \" is not J2EE version compatible with the specified archive.
-EAR_PROJECTNAME_SAMEAS_MODULE=The EAR Project name cannot be same as the Project Name.
\ No newline at end of file
+EAR_PROJECTNAME_SAMEAS_MODULE=The EAR Project name cannot be same as the Project Name.
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/ejbarchiveops.properties b/plugins/org.eclipse.jst.j2ee/property_files/ejbarchiveops.properties
index 1caec70..9bb668d 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/ejbarchiveops.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/ejbarchiveops.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/j2ee_common.properties b/plugins/org.eclipse.jst.j2ee/property_files/j2ee_common.properties
index df6123d..b3ea55f 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/j2ee_common.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/j2ee_common.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/j2eecreation.properties b/plugins/org.eclipse.jst.j2ee/property_files/j2eecreation.properties
index 4a9db0c..061eadb 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/j2eecreation.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/j2eecreation.properties
@@ -1,10 +1,10 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
@@ -120,10 +120,10 @@
 EJBReferenceDataModel_UI_11=Selected target EJB does not have remote interfaces.
 EJBReferenceDataModel_UI_12=Target bean must be selected.
 PortComponentReferenceDataModel_ERROR_4=IWAE0042E Service Endpoint Interface must be indicated.
-MessageDestReferenceDataModel.7=Type must be indicated.
-MessageDestReferenceDataModel.8=Usage must be indicated.
-MessageDestReferenceDataModel.9=Link must be unique within EAR.
-ResourceEnvironmentReferenceDataModel.2=Type must be selected.
+MessageDestReferenceDataModel_7=Type must be indicated.
+MessageDestReferenceDataModel_8=Usage must be indicated.
+MessageDestReferenceDataModel_9=Link must be unique within EAR.
+ResourceEnvironmentReferenceDataModel_2=Type must be selected.
 RenameModuleOperation_UI_0=No Projects to rename.
 ServerTargetDataModel_UI_7=There are no available target servers.
 ServerTargetDataModel_UI_8=A target server must be set.
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/j2eewtpplugin.properties b/plugins/org.eclipse.jst.j2ee/property_files/j2eewtpplugin.properties
index e3ec266..4421e4e 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/j2eewtpplugin.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/j2eewtpplugin.properties
@@ -1,49 +1,49 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
 Could_not_find_root_object_ERROR_=IWAE0001E Could not find root object in resource: {0}
 An_error_occurred_while_sa_ERROR_=IWAE0002E An error occurred while saving.
 Cannot_run_J2EEUIWorkingCo_ERROR_=IWAE0003E Cannot run J2EEUIWorkingCopyManager operation because the Workspace tree is locked.
-Unable_to_save_read-only_f_ERROR_=IWAE0004E Unable to save read-only file: {0}
+Unable_to_save_read_only_f_ERROR_=IWAE0004E Unable to save read-only file: {0}
 The_following_resources_ne_UI_=The following resources need to be saved but are currently shared, do you want to save now?
 Cannot_load_EJBFile_because_EJBEditModel_is_null_UI_=Cannot load EJBFile because EJBEditModel is null
 WARNING_METAFOLDER_MISSING_UI_=WARNING_METAFOLDER_MISSING
-Cannot_load_EJBFile_because_ejbNature.asEJBJarFile()_returns_null_UI_=Cannot load EJBFile because ejbNature.asEJBJarFile() returns null
-EJBProjectResources.getEJBJar(EJBEditModel)_UI_=EJBProjectResources.getEJBJar(EJBEditModel)
+Cannot_load_EJBFile_because_ejbNature_asEJBJarFile___returns_null_UI_=Cannot load EJBFile because ejbNature.asEJBJarFile() returns null
+EJBProjectResources_getEJBJar_EJBEditModel__UI_=EJBProjectResources.getEJBJar(EJBEditModel)
 Cannot_load_EJBJar_because_model_is_null_UI_=Cannot load EJBJar because model is null
 Cannot_load_EJBFile_because_EJBNatureRuntime_is_null_UI_=Cannot load EJBFile because EJBNatureRuntime is null
 WARNING_FILE_MISSING_UI_=WARNING_FILE_MISSING
 CoreException_could_not_initialize_Web_Service_class_path_variables_ERROR_=IWAE0005E CoreException could not initialize Web Service class path variables
 __Start_build_project_INFO_=IWAE0006I : Start build project
 __Bad_builder_order_for_project_INFO_=IWAE0007I : Bad builder order for project
-__No_imported_classes_folder,_quitting_INFO_=IWAE0008I : No imported classes folder, quitting
-__Full/first_build_INFO_=IWAE0009I : Full/first build
+__No_imported_classes_folder__quitting_INFO_=IWAE0008I : No imported classes folder, quitting
+__Full_first_build_INFO_=IWAE0009I : Full/first build
 __Considering_delta_INFO_=IWAE0010I : Considering delta
 __Delta_build_INFO_=IWAE0011I : Delta build
 Minimizing_project_UI_=Minimizing project
 No_library_folder_UI_=No library folder
 Not_a_J2EE_project_UI_=Not a J2EE project
 No_source_types_UI_=No source types
-Some_source_types_have___$___in_their_name_ERROR_=IWAE0012E Some source types have \'$\' in their name
+Some_source_types_have______in_their_name_ERROR_=IWAE0012E Some source types have \'$\' in their name
 RAR_File=RAR File
 Error_opening_archive_for_export_2=Error opening archive for export
 Error_getting_project_nature_runtime_3=Error getting project nature runtime
-Error_occurred_loading_ra.xml__4=Error occurred loading ra.xml:
+Error_occurred_loading_ra_xml__4=Error occurred loading ra.xml:
 Creating_Connector_Project_5=Creating Connector Project
 Error_getting_project_nature_runtime_6=Error getting project nature runtime
 Error_occurred_saving_the_manifest_7=Error occurred saving the manifest
 _UI_ParamValue_type=Param:
-J2EEModulePostImportHelper.0=WEB
-J2EEModulePostImportHelper.1=EJB
-J2EEModulePostImportHelper.2=ApplicationClient
-J2EEModulePostImportHelper.3=Connector
+J2EEModulePostImportHelper_0=WEB
+J2EEModulePostImportHelper_1=EJB
+J2EEModulePostImportHelper_2=ApplicationClient
+J2EEModulePostImportHelper_3=Connector
 J2EEDeployOperation_UI_0=Deploying selected modules
 J2EEDeployOperation_UI_1=Fatal Exception occured
 J2EEDeployOperation_UI_Null_Status=Deployed successfully.
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/projectsupport.properties b/plugins/org.eclipse.jst.j2ee/property_files/projectsupport.properties
index ad0be1f..5a4f0dc 100644
--- a/plugins/org.eclipse.jst.j2ee/property_files/projectsupport.properties
+++ b/plugins/org.eclipse.jst.j2ee/property_files/projectsupport.properties
@@ -1,14 +1,14 @@
 ###############################################################################
-# Copyright (c) 2003, 2004 IBM Corporation and others.
+# Copyright (c) 2003, 2005 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License v1.0
 # which accompanies this distribution, and is available at
 # http://www.eclipse.org/legal/epl-v10.html
-# 
+#
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-Creating_Web_Project..._UI_=Creating Web Project...
+Creating_Web_Project____UI_=Creating Web Project...
 The_path_for_the_links_sta_EXC_=IWAE0001E The path for the links state file is incorrect
 Syntax_Error_in_the_links_UI_=Syntax Error in the links state file
 Error_while_saving_links_s_EXC_=IWAE0002E Error while saving links state file
@@ -16,12 +16,12 @@
 Operation_failed_due_to_IO_ERROR_=IWAE0004E Operation failed due to IO error:
 Operation_failed_due_to_Co_ERROR_=IWAE0005E Operation failed due to Core error:
 Operation_failed_due_to_Ja_ERROR_=IWAE0006E Operation failed due to Java Model error:
-1concat_EXC_=IWAE0007E Error occured getting web.xml: {0}
+_1concat_EXC_=IWAE0007E Error occured getting web.xml: {0}
 Error_importing_Module_Fil_EXC_=IWAE0008E Error importing Module File
 Cannot_clone_TaglibInfo_1_EXC_=IWAE0009E Cannot clone TaglibInfo
 Could_not_read_TLD_15=Could not read TLD
 File_Serving_Enabler_7=File Serving Enabler
-Auto_Generated_-_File_Enabler_9=Auto Generated - File Enabler
+Auto_Generated___File_Enabler_9=Auto Generated - File Enabler
 Generated_by_Web_Tooling_23=Generated by Web Tooling
 Not_a_web_project_29=Not a web project
 A_web_project_must_be_open_and_must_exist_for_properties_to_be_edited_30=A web project must be open and must exist for properties to be edited
diff --git a/plugins/org.eclipse.jst.j2ee/property_files/refactor.properties b/plugins/org.eclipse.jst.j2ee/property_files/refactor.properties
new file mode 100644
index 0000000..5999e14
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/property_files/refactor.properties
@@ -0,0 +1,21 @@
+###############################################################################
+#  Copyright (c) 2005 BEA Systems, Inc.
+#  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:
+#   BEA Systems, Inc. - initial API and implementation
+###############################################################################
+#This properties file contains string for refactoring logic
+
+pre_delete_not_received_for_removed=Missed PRE_DELETE event for removed project {0}, unable to update dependencies.
+pre_delete_not_received_for_renamed=Missed PRE_DELETE event for renamed project {0}, unable to update dependencies.
+invalid_property_name=Invalid property name: {0}
+task_name=Project refactoring
+missing_natures=Refactored project does not have either the ModuleCoreNature or JavaNature
+error_reading_manifest=Error reading manifest
+error_updating_project_on_delete=Error updating dependencies for deleted J2EE project {0}
+error_updating_project_on_rename=Error updating dependencies for renamed J2EE project {0}
+error_updating_server=Error updating server {0} on refactor of project {1}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/ProjectDependencyCache.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/ProjectDependencyCache.java
new file mode 100644
index 0000000..75c5e2f
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/ProjectDependencyCache.java
@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jem.util.logger.proxy.Logger;
+
+/**
+ * Maintains a cache of project dependencies as represented by references in the .project file.
+ * 
+ * XXX DependencyManagerGraph is being used instead now that inter-project dependencies have
+ * dependent-module entries, however, this type of dependency representation might be useful if
+ * we want to capture dependencies on projects not represented in the .component file.
+ */
+public class ProjectDependencyCache {
+
+	private static ProjectDependencyCache cache;
+	
+	public synchronized static ProjectDependencyCache getCache() {
+		if (cache == null) {
+			try {
+				cache = new ProjectDependencyCache();
+			} catch (CoreException ce) {
+				Logger.getLogger().logError(ce);
+			}
+		}
+		return cache;
+	}
+	
+	/*
+	 * Map from target IProject to List of dependent IProjects
+	 */
+	private final Map dependencyCache = new HashMap();
+	
+	/*
+	 * Map from dependent IProject to List of target IProject
+	 */
+	private final Map referenceCache = new HashMap();
+	
+	/**
+	 * Creates and initializes the cache.
+	 */
+	protected ProjectDependencyCache() throws CoreException {
+		final IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
+		for (int i = 0; i < projects.length; i++) {
+			refreshDependencies(projects[i]);
+		}
+	}
+	
+	public synchronized IProject[] getDependentProjects(final IProject project) {
+		List dependencies = (List) dependencyCache.get(project);
+		if (dependencies == null) {
+			return new IProject[0];
+		}
+		return (IProject[]) dependencies.toArray(new IProject[dependencies.size()]);		
+	}
+	
+	public synchronized void refreshDependencies(final IProject project) throws CoreException {
+		List oldRefs = (List) referenceCache.get(project);
+		if (oldRefs == null) {
+			oldRefs = new ArrayList();
+		}
+		final IProject[] refProjects = project.getDescription().getReferencedProjects();
+		final List newRefs = new ArrayList();
+		for (int j = 0; j < refProjects.length; j++) {
+			addDependency(refProjects[j], project);
+			newRefs.add(refProjects[j]);
+			oldRefs.remove(refProjects[j]);
+		}
+		referenceCache.put(project, newRefs);
+		
+		// need to cull the stale refs from the reverse map
+		Iterator i = oldRefs.iterator();
+		while (i.hasNext()) {
+			removeDependency((IProject) i.next(), project);
+		}
+	}
+	
+	public synchronized void refreshDependenciesForTarget(final IProject target) throws CoreException {
+		final IProject[] dependents= getDependentProjects(target);
+		for (int i = 0; i < dependents.length; i++) {
+			refreshDependencies(dependents[i]);
+		}
+	}
+	
+	public synchronized void removeProject(final IProject project) throws CoreException {
+		// remove from the dependency cache
+		dependencyCache.remove(project);
+		// remove from the reference cache and clear the from the cache of all dependent projects
+		List dependencies = (List) referenceCache.remove(project);
+		if (dependencies != null) {
+			final Iterator i = dependencies.iterator();
+			while (i.hasNext()) {
+				removeDependency((IProject) i.next(), project); 
+			}
+		}
+	}
+	
+	public synchronized void replaceProject(final IProject originalProject, final IProject newProject) throws CoreException {
+		// rename dependencyCache entry
+		dependencyCache.put(newProject, dependencyCache.remove(originalProject));
+		
+		// rename reference cache and clear the from the cache of all dependent projects
+		List dependencies = (List) referenceCache.remove(originalProject);
+		referenceCache.put(newProject, dependencies);
+		if (dependencies != null) {
+			final Iterator i = dependencies.iterator();
+			while (i.hasNext()) {
+				final IProject ref = (IProject) i.next();
+				removeDependency(ref, originalProject); 
+				addDependency(ref, newProject);
+			}
+		}
+	}
+	
+	private void removeDependency(final IProject target, final IProject dependent) {
+		List dependentProjects = (List) dependencyCache.get(target);
+		if (dependentProjects != null) {
+			dependentProjects.remove(dependent);
+		}
+	}
+	
+	private void addDependency(final IProject target, final IProject dependent) {
+		List dependentProjects = (List) dependencyCache.get(target);
+		if (dependentProjects == null) {
+			dependentProjects = new ArrayList();
+			dependencyCache.put(target, dependentProjects);
+		}
+		if (!dependentProjects.contains(dependent)) {
+			dependentProjects.add(dependent);
+		}
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/RefactorResourceHandler.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/RefactorResourceHandler.java
new file mode 100644
index 0000000..ba04f3a
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/RefactorResourceHandler.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.refactor;
+
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+ * Supports access to resource strings.
+ */
+public class RefactorResourceHandler {
+
+	private static ResourceBundle fgResourceBundle;
+
+	/**
+	 * Returns the resource bundle used by all classes in this Project
+	 */
+	public static ResourceBundle getResourceBundle() {
+		try {
+			return ResourceBundle.getBundle("refactor");//$NON-NLS-1$
+		} catch (MissingResourceException e) {
+			// does nothing - this method will return null and
+			// getString(String, String) will return the key
+			// it was called with
+		}
+		return null;
+	}
+
+	public static String getString(String key) {
+		if (fgResourceBundle == null) {
+			fgResourceBundle = getResourceBundle();
+		}
+
+		if (fgResourceBundle != null) {
+			try {
+				return fgResourceBundle.getString(key);
+			} catch (MissingResourceException e) {
+				return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+			}
+		}
+		return "!" + key + "!";//$NON-NLS-2$//$NON-NLS-1$
+	}
+
+	public static String getString(String key, Object[] args) {
+
+		try {
+			return MessageFormat.format(getString(key), args);
+		} catch (IllegalArgumentException e) {
+			return getString(key);
+		}
+
+	}
+
+	public static void nlsConcatenationFinder() {
+		// used to tag methods which have concatenated strings
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/listeners/J2EEElementChangedListener.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/listeners/J2EEElementChangedListener.java
new file mode 100644
index 0000000..cc6386d
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/listeners/J2EEElementChangedListener.java
@@ -0,0 +1,152 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jst.j2ee.refactor.listeners;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.WorkspaceJob;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jdt.core.ElementChangedEvent;
+import org.eclipse.jdt.core.IElementChangedListener;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaElementDelta;
+import org.eclipse.jdt.core.IJavaModel;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jst.j2ee.internal.J2EEConstants;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.ModuleCoreNature;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+
+/**
+ * Implementation of <code>IElementChangedListener that updates mappings for src folders
+ * in the .component file in response to changes in a project's Java classpath. 
+ */
+public class J2EEElementChangedListener implements IElementChangedListener {
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.jdt.core.IElementChangedListener#elementChanged(org.eclipse.jdt.core.ElementChangedEvent)
+	 */
+	public void elementChanged(final ElementChangedEvent event) {
+		processJavaElementDelta(event.getDelta());
+	}
+	
+	private void processJavaElementDelta(final IJavaElementDelta delta) {
+		final int kind = delta.getKind();
+		if (kind == IJavaElementDelta.CHANGED) {
+			final int flags = delta.getFlags();
+			final IJavaElement element = delta.getElement();
+			if ((flags & IJavaElementDelta.F_CHILDREN) == IJavaElementDelta.F_CHILDREN) {
+				if (element instanceof IJavaModel) {
+					final IJavaElementDelta[] children = delta.getChangedChildren();
+					for (int i = 0; i < children.length; i++) {
+						// handle all of the IJavaProject children
+						processJavaElementDelta(children[i]);
+					}					
+				} else if (element instanceof IJavaProject
+						&& (flags & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0) {
+					final IJavaProject jproject = (IJavaProject) element;
+					final IProject project = jproject.getProject();
+					// make certain this is a J2EE project
+					if (ModuleCoreNature.getModuleCoreNature(project) != null) {
+						try {
+							alterMapping(delta.getAffectedChildren(), jproject, project);
+						} catch (CoreException ce) {
+							Logger.getLogger().logError(ce);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/*
+	 * Adds or removes a resource mapping from the .component file.
+	 */
+	private void alterMapping(final IJavaElementDelta[] children, final IJavaProject jproject,
+			final IProject project) throws CoreException {
+		for (int i = 0; i < children.length; i++) {
+			final IJavaElementDelta delta = children[i];
+			final IJavaElement element = delta.getElement();
+			final int kind = delta.getKind();
+			final int flags = delta.getFlags();
+			if (element instanceof IPackageFragmentRoot) {
+				final IPackageFragmentRoot root = (IPackageFragmentRoot) element;
+				int cpeKind = IPackageFragmentRoot.K_SOURCE;
+				try {
+					cpeKind = root.getKind();
+				} catch (JavaModelException jme) {
+					// this is thrown if the folder corresponding to the CPE has been deleted
+					// since it could represent another error, we need to set to binary to 
+					// avoid adding mappings for binary folders
+					cpeKind = IPackageFragmentRoot.K_BINARY;
+				}
+
+				final IPath path = root.getPath().removeFirstSegments(1);
+				WorkspaceJob job= null;
+				// kind and flags for CP additions are somewhat sporadic; either:
+				// -kind is ADDED and flags are 0
+				//   or
+				// -kind is CHANGED and flags are F_ADDED_TO_CLASSPATH
+				if (kind == IJavaElementDelta.ADDED || 
+						(flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) == IJavaElementDelta.F_ADDED_TO_CLASSPATH) {
+					// can only add if we know it is a src folder
+					if (cpeKind == IPackageFragmentRoot.K_SOURCE) {
+						job = new WorkspaceJob("J2EEComponentLinkAdditionJob") {
+							public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
+								getDestinationFolder(project).createLink(path, 0, monitor);
+								return Status.OK_STATUS;
+							}
+						};
+					}
+				// getting a kind = REMOVED and flags = 0 for removal of the folder (w/o removing the CPE), probably
+			    // should not be generated
+				} else if ((flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) == IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) {						
+					job = new WorkspaceJob("J2EEComponentMappingRemovalJob") {							
+						public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
+							getDestinationFolder(project).removeLink(path, 0, monitor);
+							return Status.OK_STATUS;
+						}
+					};
+				}
+				if (job != null) {
+					job.setRule(project);
+					job.schedule();
+				}
+			}
+		}
+	}
+
+	/*
+	 * Retrieves the IVirtualFolder to which Java src folders should be mapped
+	 */
+	private IVirtualFolder getDestinationFolder(final IProject project) throws CoreException {
+		final IVirtualComponent c = ComponentCore.createComponent(project);
+		c.create(0, null);
+		final IVirtualFolder root = c.getRootFolder();
+		if (J2EEProjectUtilities.isDynamicWebProject(project)) {
+			// web projects map to WEB-INF/classes
+			return root.getFolder(new Path(J2EEConstants.WEB_INF_CLASSES));
+		}
+		// all other J2EE project types (that are Java projects) map 
+		// Java src folders to the project root
+		return root;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/listeners/ProjectRefactoringListener.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/listeners/ProjectRefactoringListener.java
new file mode 100644
index 0000000..e8c17fa
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/listeners/ProjectRefactoringListener.java
@@ -0,0 +1,280 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.listeners;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.IResourceDeltaVisitor;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.resources.WorkspaceJob;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
+import org.eclipse.jst.j2ee.refactor.RefactorResourceHandler;
+import org.eclipse.jst.j2ee.refactor.operations.ProjectDeleteDataModelProvider;
+import org.eclipse.jst.j2ee.refactor.operations.ProjectRefactorMetadata;
+import org.eclipse.jst.j2ee.refactor.operations.ProjectRefactoringDataModelProvider;
+import org.eclipse.jst.j2ee.refactor.operations.ProjectRenameDataModelProvider;
+import org.eclipse.wst.common.componentcore.ModuleCoreNature;
+import org.eclipse.wst.common.componentcore.internal.builder.DependencyGraphManager;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Listens for project rename/delete events and, if the project had the
+ * ModuleCore nature, executes the appropriate logic to update
+ * project references.
+  */
+public final class ProjectRefactoringListener implements IResourceChangeListener, IResourceDeltaVisitor {
+	
+	/*
+	 * Map from name of deleted project to ProjectRefactorMetadata instances.
+	 */
+	private final Map deletedProjectMetadata = new HashMap();
+	
+	/**
+	 * Maintains a cache of project depencencies;
+	 */
+	//private final ProjectDependencyCache cache;
+	
+	//private boolean hasProcessedSavedState = false;
+	
+	public ProjectRefactoringListener() {//final ProjectDependencyCache dependencyCache) {
+		//cache = dependencyCache;
+		// force a refresh of the DependencyGraphManager; was hitting an NPE
+		// in StructureEdit when the DGM was getting constructed during the receipt of the
+		// first pre-delete event
+		DependencyGraphManager.getInstance();
+	}
+	
+	// XXX not very feasible to make workspace save participation work given the need to process the
+	// pre-delete events
+	/*private synchronized void processPendingEvents() {
+		if (hasProcessedSavedState) {
+			return;
+		}
+		hasProcessedSavedState = true;
+		//process any project rename/delete events that have occurred prior to our activation 
+		try {
+			ISavedState lastState =	ResourcesPlugin.getWorkspace().addSaveParticipant(J2EEPlugin.getDefault(), this);
+			if (lastState != null) {
+				lastState.processResourceChangeEvents(this);
+			}
+		} catch (CoreException ce) {
+			Logger.getLogger().logError(ce);
+		}
+	}*/
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
+	 */
+	public void resourceChanged(final IResourceChangeEvent event) {
+		// if we haven't already processed the pending resource change events, process them 
+		//processPendingEvents();
+		
+		// need to capture PRE_DELETE events so that metadata about the
+		// deleted project can be collected and cached
+		try {
+			/*if (event.getType() == IResourceChangeEvent.POST_BUILD) {
+				// we get this event type when processing pending events
+				IResource resource = event.getResource();
+				IResourceDelta delta = event.getDelta();
+				if (resource instanceof IProject && delta.getKind() == IResourceDelta.REMOVED) {
+					cacheDeletedProjectMetadata((IProject)resource);
+				} else {
+					delta.accept(this);
+				}
+			} else */
+			if (event.getType() == IResourceChangeEvent.PRE_DELETE) {
+				// for now, only dependencies on ModuleCoreNature projects
+				final IProject project = (IProject) event.getResource();
+				if (ModuleCoreNature.getModuleCoreNature(project) != null) {
+					cacheDeletedProjectMetadata(project);
+				}
+			} else {
+				event.getDelta().accept(this);
+			}
+		} catch (CoreException ce) {
+			Logger.getLogger().logError(ce);
+		}
+	}
+	
+	private synchronized void cacheDeletedProjectMetadata(final IProject project) {
+		final ProjectRefactorMetadata metadata = new ProjectRefactorMetadata(project, ProjectRefactorMetadata.REFERER_CACHING);
+		// precompute the metadata while the project still exists
+		metadata.computeMetadata();
+		metadata.computeServers();
+		metadata.computeDependentMetadata(ProjectRefactorMetadata.REF_CACHING,
+				DependencyGraphManager.getInstance().getDependencyGraph().getReferencingComponents(project));
+		//, cache.getDependentProjects(project));
+		deletedProjectMetadata.put(project.getName(), metadata); 		
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)
+	 */
+	public boolean visit(final IResourceDelta delta) throws CoreException {
+		final IResource resource = delta.getResource();
+		if (resource instanceof IWorkspaceRoot) {
+			// delta is at the workspace root so keep going
+			return true;
+		} else if (resource instanceof IProject) {
+			processProjectDelta((IProject) resource, delta);
+		}
+		return false;
+	}
+
+	/*
+	 * Process the project delta in a sync block.
+	 */
+	private synchronized void processProjectDelta(final IProject project, final IResourceDelta delta) throws CoreException {
+		final int kind = delta.getKind();
+		final int flags = delta.getFlags();
+
+		if (kind == IResourceDelta.REMOVED) {
+			if (flags == 0) {
+				// Remove all entries int the project dependency cache
+				//cache.removeProject(project);
+				// if the kind is REMOVED and there are no special flags, the project was deleted
+				ProjectRefactorMetadata metadata = (ProjectRefactorMetadata) deletedProjectMetadata.remove(project.getName()); 
+				// note: only projects with ModuleCoreNature will have cached metadata
+				if (metadata != null) {
+					processDelete(metadata);
+				} else {
+					// likely due to missing the pre-delete event, ignore for now
+					//Logger.getLogger().logWarning(RefactorResourceHandler.getString("pre_delete_not_received_for_removed",  
+					//new Object[]{project.getName()}));
+				}
+			} 
+		} else if (kind == IResourceDelta.ADDED && wasRenamed(flags)) { // was renamed
+			// get the original name
+			final String originalName = delta.getMovedFromPath().lastSegment();
+			//Logger.getLogger().logInfo("Added event for " + originalName + " with flags " + flags);
+			// we get PRE_DELETE events on rename so retrieve this
+			ProjectRefactorMetadata originalMetadata = (ProjectRefactorMetadata) deletedProjectMetadata.remove(originalName);
+			// get the metadata for the new project
+			final ProjectRefactorMetadata newMetadata = new ProjectRefactorMetadata(project);
+			// note: only projects with ModuleCoreNature will have cached metadata
+			if (originalMetadata != null) {
+				processRename(originalMetadata, newMetadata);
+				// Rename all entries in the project dependency cache
+				//cache.replaceProject(originalProject, project);
+			} else {
+				// likely due to missing the pre-delete event, so set the original to a metadata based on new project
+				// and reset project to one based on original name
+				//Logger.getLogger().logWarning(RefactorResourceHandler.getString("pre_delete_not_received_for_renamed", new Object[]{originalName + " " + flags}));
+			}
+		} 
+		//else if (kind == IResourceDelta.CHANGED || kind == IResourceDelta.ADDED) { 
+		// (re)compute the dependencies
+		//cache.refreshDependencies(project);
+		//}		
+	}
+	
+	/*
+	 * Determines if the project was renamed based on the IResourceDelta flags 
+	 */
+	private boolean wasRenamed(final int flags) {
+		if ((flags & IResourceDelta.DESCRIPTION) > 0
+			&& (flags & IResourceDelta.MOVED_FROM) > 0) {
+			return true;
+		}
+		return false;
+	}
+	
+	/*
+	 * Processes the renaming of a project.
+	 */
+	private void processRename(final ProjectRefactorMetadata originalMetadata, final ProjectRefactorMetadata newMetadata ) {
+		WorkspaceJob job = new WorkspaceJob("J2EEProjectRenameJob") {
+			public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
+				final IDataModel dataModel = DataModelFactory.createDataModel(new ProjectRenameDataModelProvider());
+				dataModel.setProperty(ProjectRefactoringDataModelProvider.PROJECT_METADATA, newMetadata);
+				dataModel.setProperty(ProjectRenameDataModelProvider.ORIGINAL_PROJECT_METADATA, originalMetadata);
+				try {
+					dataModel.getDefaultOperation().execute(monitor, null);
+				} catch (Exception e) {
+					final String msg = RefactorResourceHandler.getString("error_updating_project_on_rename", new Object[]{originalMetadata.getProjectName()});
+					Logger.getLogger().logError(msg);
+					Logger.getLogger().logError(e);
+					return new Status(Status.ERROR, J2EEPlugin.PLUGIN_ID, 0, msg, e);
+				}				
+				return Status.OK_STATUS;
+			}
+		};
+		// XXX note: might want to consider switching to a MultiRule for optimization
+		job.setRule(ResourcesPlugin.getWorkspace().getRoot());
+		job.schedule();
+	}
+	
+	/*
+	 * Processes the deletion of a project.
+	 */
+	private void processDelete(final ProjectRefactorMetadata metadata) {
+		WorkspaceJob job = new WorkspaceJob("J2EEProjectDeleteJob") {
+			public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
+				final IDataModel dataModel = DataModelFactory.createDataModel(new ProjectDeleteDataModelProvider());
+				dataModel.setProperty(ProjectRefactoringDataModelProvider.PROJECT_METADATA, metadata);
+				try {
+					dataModel.getDefaultOperation().execute(monitor, null);
+				} catch (Exception e) {
+					final String msg = RefactorResourceHandler.getString("error_updating_project_on_delete", new Object[]{metadata.getProjectName()});
+					Logger.getLogger().logError(msg);
+					Logger.getLogger().logError(e);
+					return new Status(Status.ERROR, J2EEPlugin.PLUGIN_ID, 0, msg, e);
+				}
+				return Status.OK_STATUS;
+			}
+		};
+		// XXX note: might want to consider switching to a MultiRule for optimization
+		job.setRule(ResourcesPlugin.getWorkspace().getRoot());
+		job.schedule();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.resources.ISaveParticipant#doneSaving(org.eclipse.core.resources.ISaveContext)
+	 */
+//	public void doneSaving(ISaveContext context) {
+//	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.resources.ISaveParticipant#prepareToSave(org.eclipse.core.resources.ISaveContext)
+	 */
+//	public void prepareToSave(ISaveContext context) throws CoreException {
+//	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.resources.ISaveParticipant#rollback(org.eclipse.core.resources.ISaveContext)
+	 */
+//	public void rollback(ISaveContext context) {
+//	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.resources.ISaveParticipant#saving(org.eclipse.core.resources.ISaveContext)
+	 */
+//	public void saving(ISaveContext context) throws CoreException {
+//		// no state to be saved by the plug-in, but request a
+//		// resource delta to be used on next activation.
+//	    context.needDelta();
+//	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/CreateOptionalReferenceOp.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/CreateOptionalReferenceOp.java
new file mode 100644
index 0000000..5746dac
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/CreateOptionalReferenceOp.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.wst.common.componentcore.internal.operation.CreateReferenceComponentsOp;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Extension of <code>CreateReferenceComponentsOp</code> that supports the optional creation of
+ * the .component reference. 
+ */
+public class CreateOptionalReferenceOp extends CreateReferenceComponentsOp {
+
+	private final boolean _createReferences;
+	
+	public CreateOptionalReferenceOp(IDataModel model, boolean createReferences) {
+		super(model);
+		_createReferences = createReferences;
+	}
+	
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		if (_createReferences) {
+			addReferencedComponents(monitor);
+		}
+		addProjectReferences();
+		return OK_STATUS;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectDeleteDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectDeleteDataModelProvider.java
new file mode 100644
index 0000000..d06abee
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectDeleteDataModelProvider.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+public class ProjectDeleteDataModelProvider extends	ProjectRefactoringDataModelProvider {
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getDefaultOperation()
+	 */
+	public IDataModelOperation getDefaultOperation() {
+		return new ProjectDeleteOperation(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectDeleteOperation.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectDeleteOperation.java
new file mode 100644
index 0000000..4aa5f21
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectDeleteOperation.java
@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Subclass of <code>ProjectRefactorOperation</code> that contains deletion-specific logic.
+ */
+public class ProjectDeleteOperation extends ProjectRefactorOperation {
+
+	public ProjectDeleteOperation(final IDataModel model) {
+		super(model);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorOperation#updateProject(org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorMetadata)
+	 */
+	protected void updateProject(final ProjectRefactorMetadata refactoredMetadata) 
+		throws ExecutionException {
+		// update any server instance refs to the refactored project
+		super.updateServerRefs(refactoredMetadata, null);
+	}
+
+	/**
+	 * Updates the metadata for dependent projects
+	 * @throws ExecutionException
+	 */
+	protected void updateDependentProjects(final ProjectRefactorMetadata refactoredMetadata,
+			final IProgressMonitor monitor) throws ExecutionException {
+		super.updateDependentProjects(refactoredMetadata, monitor);
+		// update any server instance refs to the refactored project
+		super.updateServerRefs(refactoredMetadata, null);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorOperation#updateDependentEARProject(org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorMetadata, org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorMetadata)
+	 */
+	protected void updateDependentEARProject(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata) throws ExecutionException {
+		final IDataModel dataModel = createDataModel(dependentMetadata, refactoredMetadata,
+				new UpdateDependentEARonDeleteProvider());
+		dataModel.getDefaultOperation().execute(null, null);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorOperation#updateDependentModuleProject(org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorMetadata, org.eclipse.jst.j2ee.internal.refactor.operations.ProjectRefactorMetadata)
+	 */
+	protected void updateDependentModuleProject(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata) throws ExecutionException {
+		final IDataModel dataModel = createDataModel(dependentMetadata, refactoredMetadata,
+				new UpdateDependentModuleonDeleteProvider());
+		dataModel.getDefaultOperation().execute(null, null);
+	}
+
+	private IDataModel createDataModel(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata,
+			final AbstractDataModelProvider provider) {
+		final IDataModel dataModel = DataModelFactory.createDataModel(provider);
+		dataModel.setProperty(PROJECT_METADATA, refactoredMetadata);
+		dataModel.setProperty(DEPENDENT_PROJECT_METADATA, dependentMetadata);
+		return dataModel;
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactorMetadata.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactorMetadata.java
new file mode 100644
index 0000000..2f9ae86
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactorMetadata.java
@@ -0,0 +1,336 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.ModuleCoreNature;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+import org.eclipse.wst.server.core.IModule;
+import org.eclipse.wst.server.core.IServer;
+import org.eclipse.wst.server.core.ServerUtil;
+
+/**
+ * IDataModel object property stored under the property name 
+ * {@link ProjectRefactoringDataModelProvider#PROJECT_METADATA}.
+ * 
+ *  Note: this class is not multi-thread safe.
+ */
+public class ProjectRefactorMetadata {
+	
+	public static int NON_CACHING = 0;
+	public static int REF_CACHING = 1;
+	public static int REFERER_CACHING = 2;
+	
+	private int _virtualCompCaching = NON_CACHING;
+	private final IProject _project;
+	private IServer[] servers;
+	private IVirtualComponent virtualComp = null;
+	private final List dependentMetadata = new ArrayList();
+	private boolean computed = false;
+	private boolean javaNature;
+	private boolean moduleCoreNature;
+	private IModule module;
+	private boolean isEAR = false;
+	private boolean isEJB = false;
+	private boolean isWeb = false;
+	private boolean isAppClient = false;
+	private boolean isConnector = false;
+	private boolean isUtility = false;
+	
+	public ProjectRefactorMetadata(final IProject project) {
+		_project = project;
+	}
+	
+	public ProjectRefactorMetadata(final IProject project, final int virtualCompCaching) {
+		this(project);
+		_virtualCompCaching = virtualCompCaching;
+	}
+	
+	public void computeMetadata() {
+		try {
+			javaNature = _project.hasNature("org.eclipse.jdt.core.javanature"); //$NON-NLS-1$
+			moduleCoreNature = ModuleCoreNature.getModuleCoreNature(_project) != null;
+			if (moduleCoreNature) {
+				if (_virtualCompCaching == REF_CACHING) {
+					virtualComp = new RefCachingVirtualComponent(ComponentCore.createComponent(_project));
+				} else if (_virtualCompCaching == REFERER_CACHING) {
+					virtualComp = new RefererCachingVirtualComponent(ComponentCore.createComponent(_project));
+				} else {
+					virtualComp = ComponentCore.createComponent(_project);			
+				}
+				final IFacetedProject facetedProject = ProjectFacetsManager.create(_project);
+				module = ServerUtil.getModule(_project);
+				isEAR = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EAR_MODULE)); 
+				isEJB = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_EJB_MODULE)); 
+				isWeb = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_WEB_MODULE));
+				isAppClient = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_APPCLIENT_MODULE)); 
+				isConnector = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_CONNECTOR_MODULE));  
+				isUtility = facetedProject.hasProjectFacet(ProjectFacetsManager.getProjectFacet(IModuleConstants.JST_UTILITY_MODULE)); 
+			}
+		} catch (CoreException ce) {
+			Logger.getLogger().logError(ce);
+		} finally {
+			computed = true;
+		}
+	}
+
+	public void computeServers() {
+		if (!computed) {
+			computeMetadata();
+		}
+		servers = ServerUtil.getServersByModule(module, null);
+	}
+	
+	public IServer[] getServers() {
+		return servers;
+	}
+	
+	public void computeDependentMetadata(final int virtualComponentCaching, final IProject[] dependentProjects) {
+		// get all referencing projects and execute the appropriate update operation for each one
+		ProjectRefactorMetadata metadata;
+		for (int i = 0; i < dependentProjects.length; i++) {
+			metadata = new ProjectRefactorMetadata(dependentProjects[i], virtualComponentCaching);
+			metadata.computeMetadata();
+			dependentMetadata.add(metadata);
+		}
+	}
+	
+	/**
+	 * Retrieves the IProject that represents the referenced project.
+	 */
+	public IProject getProject() {
+		return _project;
+	}
+	
+	/**
+	 * Retrieves the IModule for the project, or null if no IModule representation
+	 * exists.
+	 */
+	public IModule getModule() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return module;
+	}
+	
+	/**
+	 * Retrieves the project name.
+	 */
+	public String getProjectName() {
+		return _project.getName();
+	}
+	
+	/**
+	 * Retrieves all ProjectRefactorMetadata for dependent projects.
+	 * Will be empty if not computed.
+	 */
+	public ProjectRefactorMetadata[] getDependentMetadata() {
+		return (ProjectRefactorMetadata[]) dependentMetadata.toArray(new ProjectRefactorMetadata[dependentMetadata.size()]);
+	}
+	
+	/**
+	 * Returns the IVirtualComponent for the project.
+	 */
+	public IVirtualComponent getVirtualComponent() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return virtualComp;
+	}
+	
+	public boolean hasJavaNature() { 
+		if (!computed) {
+			computeMetadata();
+		}
+		return javaNature;
+	}
+	
+	public boolean hasModuleCoreNature() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return moduleCoreNature;
+	}
+	
+	public boolean isEAR() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return isEAR;
+	}
+
+	public boolean isEJB() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return isEJB; 
+		
+	}
+	
+	public boolean isWeb() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return isWeb;
+	}
+	
+	public boolean isAppClient() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return isAppClient;
+	}
+	
+	public boolean isConnector() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return isConnector;
+	}
+	
+	public boolean isUtility() {
+		if (!computed) {
+			computeMetadata();
+		}
+		return isUtility;
+	}
+	
+	public class CachingVirtualComponent implements IVirtualComponent {
+		protected final IVirtualComponent _comp;
+		protected boolean _caching = true;
+		public CachingVirtualComponent(final IVirtualComponent comp) {
+			_comp = comp;
+		}
+		public void addReferences(IVirtualReference[] references) {
+			_comp.addReferences(references);
+		}
+		public void create(int updateFlags, IProgressMonitor aMonitor) throws CoreException {
+			_comp.create(updateFlags, aMonitor);
+		}
+		public boolean exists() {
+			return _comp.exists();
+		}
+		public IVirtualComponent getComponent() {
+			return _comp.getComponent();
+		}
+		public Properties getMetaProperties() {
+			return _comp.getMetaProperties();
+		}
+		public IPath[] getMetaResources() {
+			return _comp.getMetaResources();
+		}
+		public String getName() {
+			return _comp.getName();
+		}
+		public IProject getProject() {
+			return _comp.getProject();
+		}
+		public IVirtualReference getReference(String aComponentName) {
+			return _comp.getReference(aComponentName);
+		}
+		public IVirtualReference[] getReferences() {
+			return _comp.getReferences();
+		}
+		public void setCaching(boolean caching) {
+			_caching = caching;
+		}
+		public IVirtualComponent[] getReferencingComponents() {
+			return _comp.getReferencingComponents();
+		}
+		public IVirtualFolder getRootFolder() {
+			return _comp.getRootFolder();
+		}
+		public boolean isBinary() {
+			return _comp.isBinary();
+		}
+		public void setMetaProperties(Properties properties) {
+			_comp.setMetaProperties(properties);
+		}
+		public void setMetaProperty(String name, String value) {
+			_comp.setMetaProperty(name, value);
+		}
+		public void setMetaResources(IPath[] theMetaResourcePaths) {
+			_comp.setMetaResources(theMetaResourcePaths);
+		}
+		public void setReferences(IVirtualReference[] theReferences) {
+			_comp.setReferences(theReferences);
+		}
+		public Object getAdapter(Class adapter) {
+			return _comp.getAdapter(adapter);
+		}
+		
+		public boolean equals(Object o) {
+			return _comp.equals(o);
+		}
+		
+		public int hashCode() {
+			return _comp.hashCode();
+		}
+		
+		public String toString() {
+			return _comp.toString();
+		}
+	}
+	
+	public class RefCachingVirtualComponent extends CachingVirtualComponent {
+		private IVirtualReference[] cachedRefs;
+		public RefCachingVirtualComponent(final IVirtualComponent comp) {
+			super(comp);
+			cachedRefs = comp.getReferences();
+		}
+
+		public IVirtualReference getReference(String aComponentName) {
+			IVirtualReference[] refs = getReferences();
+			for (int i = 0; i < refs.length; i++) {
+				IVirtualReference reference = refs[i];
+				if (reference.getReferencedComponent().getName().equals(aComponentName))
+					return reference;
+			}
+			return null;
+		}
+		public IVirtualReference[] getReferences() {
+			if (_caching) {
+				return cachedRefs;
+			}
+			return super.getReferences();
+		}
+	}
+
+	public class RefererCachingVirtualComponent extends CachingVirtualComponent {
+		private IVirtualComponent[] cachedReferers;
+		public RefererCachingVirtualComponent(final IVirtualComponent comp) {
+			super(comp);
+			cachedReferers = comp.getReferencingComponents();
+		}
+
+		public IVirtualComponent[] getReferencingComponents() {
+			if (_caching) {
+				return cachedReferers;
+			}
+			return _comp.getReferencingComponents();
+		}
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactorOperation.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactorOperation.java
new file mode 100644
index 0000000..040bfbd
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactorOperation.java
@@ -0,0 +1,186 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jst.j2ee.refactor.RefactorResourceHandler;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.server.core.IModule;
+import org.eclipse.wst.server.core.IServer;
+import org.eclipse.wst.server.core.IServerWorkingCopy;
+import org.eclipse.wst.server.core.ServerUtil;
+
+/**
+ * Abstract base class for project refactoring operations.
+ */
+public abstract class ProjectRefactorOperation extends AbstractDataModelOperation 
+	implements ProjectRefactoringProperties {
+
+	/**
+	 * Creates a new refactoring operation for the specified data model.
+	 * @param model The data model.
+	 */
+	public ProjectRefactorOperation(final IDataModel model) {
+		super(model);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
+	 */
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		try {
+			final ProjectRefactorMetadata refactoredMetadata = (ProjectRefactorMetadata) getProjectMetadata();
+
+			// Update this project's metadata
+			if (refactoredMetadata.hasModuleCoreNature()) {
+				updateProject(refactoredMetadata);
+			}
+			
+			// Update metadata for dependent projects
+			updateDependentProjects(refactoredMetadata, monitor);
+			
+		} finally {
+			if (monitor != null) {
+				monitor.done();
+			}
+		}
+
+		return Status.OK_STATUS;
+	}
+
+	/**
+	 * Updates the project's own metadata.
+	 */
+	protected abstract void updateProject(final ProjectRefactorMetadata refactoredMetadata) 
+	throws ExecutionException;
+	
+	/**
+	 * Updates the metadata for dependent projects
+	 * @throws ExecutionException
+	 */
+	protected void updateDependentProjects(final ProjectRefactorMetadata refactoredMetadata,
+			final IProgressMonitor monitor) throws ExecutionException {
+		// get the metadata for all dependent projects
+		final ProjectRefactorMetadata[] dependentMetadata = refactoredMetadata.getDependentMetadata();
+		if (monitor != null) {
+			monitor.beginTask(RefactorResourceHandler.getString("task_name"), dependentMetadata.length); 
+		}
+		ProjectRefactorMetadata metadata;
+		for (int i = 0; i < dependentMetadata.length; i++) {
+			metadata = dependentMetadata[i];
+			// if the project is an EAR, execute the update operation created by the
+			// DependentEARUpdateProvider; if the project is a non-EAR project with the
+			// module core nature, execute the appropriate update
+			if (metadata.isEAR()) {
+				updateDependentEARProject(metadata, refactoredMetadata);
+			} else if (metadata.hasModuleCoreNature()) { 
+				updateDependentModuleProject(metadata, refactoredMetadata);
+			}
+			if (monitor != null) {
+				monitor.worked(1);
+			}
+		}
+	}
+	
+	/**
+	 * Updates any server references.
+	 */
+	protected void updateServerRefs(final ProjectRefactorMetadata originalMetadata, 
+			final ProjectRefactorMetadata newMetadata)
+		throws ExecutionException {
+		final IModule originalModule = originalMetadata.getModule();
+		if (originalModule == null) {
+			// no module for the original project, so return
+			return;
+		}
+		final IModule[] toRemove = new IModule[]{originalModule};
+		
+		IModule newModule = null;
+		IModule[] toAdd = new IModule[0];
+		if (newMetadata != null) {
+			newModule = newMetadata.getModule();
+			if (newModule == null) {
+				// no module for the new project, so return
+				return;
+			}
+			toAdd = new IModule[]{newModule};
+		}
+		
+		final IServer[] server = originalMetadata.getServers();
+		IServerWorkingCopy wc = null;
+		for (int i = 0; i < server.length; i++) {
+			try {
+				wc = server[i].createWorkingCopy();
+				List list = Arrays.asList(server[i].getModules());
+				if (list.contains(originalModule)) {
+					// remove the original and potentially add a new
+					ServerUtil.modifyModules(wc, toAdd, toRemove, null);
+				}
+			} catch (CoreException ce) {
+				throw new ExecutionException(RefactorResourceHandler.getString("error_updating_server", 
+						new Object[]{server[i].getId(), originalMetadata.getProjectName()}), ce);
+			} finally {
+				try {
+					wc.saveAll(true, null);
+				} catch (CoreException ce) {
+					throw new ExecutionException(RefactorResourceHandler.getString("error_updating_server", 
+							new Object[]{server[i].getId(), originalMetadata.getProjectName()}), ce);					
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Updates the dependent EAR project to account for the refactoring of the referenced project.
+	 */
+	protected abstract void updateDependentEARProject(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata) throws ExecutionException;
+	
+	/**
+	 * Updates the dependent module project to account for the refactoring of the referenced project.
+	 */
+	protected abstract void updateDependentModuleProject(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata) throws ExecutionException;
+
+	/**
+	 * Retrieves the ProjectRefactorMetadata property.
+	 */
+	protected ProjectRefactorMetadata getProjectMetadata() {
+		return (ProjectRefactorMetadata) model.getProperty(PROJECT_METADATA);
+	}
+	
+	/**
+	 * Override to disable redo support
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canRedo()
+	 */
+	public boolean canRedo() {
+		return false;
+	}
+
+	/**
+	 * Override to disable undo support.
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canUndo()
+	 */
+	public boolean canUndo() {
+		return false;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactoringDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactoringDataModelProvider.java
new file mode 100644
index 0000000..53673ab
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactoringDataModelProvider.java
@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.Iterator;
+import java.util.Set;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
+import org.eclipse.jst.j2ee.refactor.RefactorResourceHandler;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
+
+public abstract class ProjectRefactoringDataModelProvider extends
+		AbstractDataModelProvider implements ProjectRefactoringProperties {
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getPropertyNames()
+	 */
+	public Set getPropertyNames() {
+		Set propertyNames = super.getPropertyNames();
+		propertyNames.add(PROJECT_METADATA);
+		return propertyNames;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#validate(java.lang.String)
+	 */
+	public IStatus validate(String propertyName) {
+		Iterator i = getPropertyNames().iterator();
+		boolean valid = false;
+		while (i.hasNext()) {
+			if (i.next().equals(propertyName)) {
+				valid = true;
+				break;
+			}
+		}
+		if (!valid) {
+			return new Status(IStatus.ERROR, J2EEPlugin.PLUGIN_ID, IStatus.OK, 
+					RefactorResourceHandler.getString("invalid_property_name", new Object[]{propertyName}), null);
+		}
+		return OK_STATUS;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactoringProperties.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactoringProperties.java
new file mode 100644
index 0000000..ddedb99
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRefactoringProperties.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+public interface ProjectRefactoringProperties {
+
+	/**
+	 * Name of the property that holds an instance of ProjectRefactorMetadata for the
+	 * refactored project.
+	 */
+	public static final String PROJECT_METADATA = "ProjectRefactoringProperties.PROJECT_METADATA"; //$NON-NLS-1$
+	
+	/**
+	 * Name of the property that holds an instance of ProjectRefactorMetadata for the original version of
+	 * the refactored project.
+	 */
+	public static final String ORIGINAL_PROJECT_METADATA = "ProjectRefactoringProperties.ORIGINAL_PROJECT_METADATA"; //$NON-NLS-1$
+	
+	/**
+	 * Name of the property that holds an instance of ProjectRefactorMetadata for the
+	 * dependent project.
+	 */
+	public static final String DEPENDENT_PROJECT_METADATA = "ProjectRefactoringProperties.DEPENDENT_PROJECT_METADATA"; //$NON-NLS-1$
+		
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRenameDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRenameDataModelProvider.java
new file mode 100644
index 0000000..a485c04
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRenameDataModelProvider.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.Set;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+public class ProjectRenameDataModelProvider extends	ProjectRefactoringDataModelProvider 
+	implements ProjectRefactoringProperties {
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getPropertyNames()
+	 */
+	public Set getPropertyNames() {
+		Set propertyNames = super.getPropertyNames();
+		propertyNames.add(ORIGINAL_PROJECT_METADATA);
+		return propertyNames;
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getDefaultOperation()
+	 */
+	public IDataModelOperation getDefaultOperation() {
+		return new ProjectRenameOperation(model);
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRenameOperation.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRenameOperation.java
new file mode 100644
index 0000000..00bbca7
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/ProjectRenameOperation.java
@@ -0,0 +1,121 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.wst.common.componentcore.internal.ComponentcoreFactory;
+import org.eclipse.wst.common.componentcore.internal.Property;
+import org.eclipse.wst.common.componentcore.internal.StructureEdit;
+import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class ProjectRenameOperation extends ProjectRefactorOperation {
+
+	public ProjectRenameOperation(final IDataModel model) {
+		super(model);
+	}
+	
+	/**
+	 * Override to return the pre-rename metadata.
+	 */
+	protected ProjectRefactorMetadata getProjectMetadata() {
+		return (ProjectRefactorMetadata) model.getProperty(ProjectRenameDataModelProvider.ORIGINAL_PROJECT_METADATA);
+	}
+	
+	/**
+	 * Updates the project's own metadata.
+	 */
+	protected void updateProject(final ProjectRefactorMetadata originalMetadata) 
+		throws ExecutionException {
+		
+		// Update the project's .component file
+		final ProjectRefactorMetadata refactoredMetadata = super.getProjectMetadata();
+		StructureEdit core = null;
+		try {
+			core = StructureEdit.getStructureEditForWrite(refactoredMetadata.getProject());
+			WorkbenchComponent component = core.getComponent();
+			// if the deploy-name had been set to the old project name, update it to 
+			// the new project name
+			if (component.getName().equals(originalMetadata.getProjectName())) {
+				component.setName(refactoredMetadata.getProjectName());
+			}
+			// if there is a context-root property that had been set to the old project name, update it to 
+			// the new project name
+			List propList = component.getProperties();
+            for (int i = 0; i < propList.size(); i++) {
+            	final Property prop = (Property) propList.get(i);
+            	if (prop.getName().equals("context-root") && prop.getValue().equals(originalMetadata.getProjectName())) {
+            		propList.remove(i);
+            		final Property newProp = ComponentcoreFactory.eINSTANCE.createProperty();
+				    newProp.setName("context-root");
+				    newProp.setValue(refactoredMetadata.getProjectName());
+				    propList.add(newProp);
+				    break;
+            	}
+            }
+		} finally {
+			if(core != null) {
+				core.saveIfNecessary(null);
+				core.dispose();
+			}
+		}	
+	}
+	
+	/**
+	 * Updates the metadata for dependent projects
+	 * @throws ExecutionException
+	 */
+	protected void updateDependentProjects(final ProjectRefactorMetadata originalMetadata,
+			final IProgressMonitor monitor) throws ExecutionException {
+		super.updateDependentProjects(originalMetadata, monitor);
+		// update any server instance refs to the refactored project
+		final ProjectRefactorMetadata refactoredMetadata = super.getProjectMetadata();
+		super.updateServerRefs(originalMetadata, refactoredMetadata);
+	}
+	
+	/**
+	 * Updates the dependent EAR project to account for the renaming of the referenced project.
+	 */
+	protected void updateDependentEARProject(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata originalMetadata) throws ExecutionException {
+		final IDataModel dataModel = createDataModel(dependentMetadata, originalMetadata,
+				new UpdateDependentEARonRenameProvider());
+		dataModel.getDefaultOperation().execute(null, null);
+	}
+	
+	/**
+	 * Updates the dependent module project to account for the renaming of the referenced project.
+	 */
+	protected void updateDependentModuleProject(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata originalMetadata) throws ExecutionException {
+		final IDataModel dataModel = createDataModel(dependentMetadata, originalMetadata,
+				new UpdateDependentModuleonRenameProvider());
+		dataModel.getDefaultOperation().execute(null, null);
+	}
+	
+	private IDataModel createDataModel(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata originalMetadata,
+			final AbstractDataModelProvider provider) {
+		final ProjectRefactorMetadata refactoredMetadata = super.getProjectMetadata();
+		final IDataModel dataModel = DataModelFactory.createDataModel(provider);
+		dataModel.setProperty(PROJECT_METADATA, refactoredMetadata);
+		dataModel.setProperty(DEPENDENT_PROJECT_METADATA, dependentMetadata);
+		dataModel.setProperty(ORIGINAL_PROJECT_METADATA, originalMetadata);
+		return dataModel;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/RemoveDeletedComponentFromEAROperation.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/RemoveDeletedComponentFromEAROperation.java
new file mode 100644
index 0000000..db55940
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/RemoveDeletedComponentFromEAROperation.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.jst.j2ee.application.Application;
+import org.eclipse.jst.j2ee.application.Module;
+import org.eclipse.jst.j2ee.application.internal.operations.RemoveComponentFromEnterpriseApplicationOperation;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class RemoveDeletedComponentFromEAROperation extends
+		RemoveComponentFromEnterpriseApplicationOperation {
+
+	private final ProjectRefactorMetadata refactoredMetadata;
+	
+	public RemoveDeletedComponentFromEAROperation(final IDataModel model, 
+			final ProjectRefactorMetadata metadata) {
+		super(model);
+		refactoredMetadata = metadata;
+	}
+	
+	/**
+	 * Override to use cached metadata to determine project type.
+	 */
+	protected void removeModule(Application application, IVirtualComponent wc) {
+		Application dd = application;
+		String name = wc.getName();
+		if (refactoredMetadata.isWeb()) {
+			name += ".war"; //$NON-NLS-1$			
+		} else if (refactoredMetadata.isEJB()) {
+			name += ".jar"; //$NON-NLS-1$			
+		} else if (refactoredMetadata.isAppClient()) {
+			name += ".jar"; //$NON-NLS-1$			
+		} else if (refactoredMetadata.isConnector()) {
+			name += ".rar"; //$NON-NLS-1$			
+		}
+		Module existingModule = dd.getFirstModule(name);
+		dd.getModules().remove(existingModule);
+
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonDeleteOp.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonDeleteOp.java
new file mode 100644
index 0000000..2a8bb6d
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonDeleteOp.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
+import org.eclipse.wst.common.componentcore.internal.operation.RemoveReferenceComponentsDataModelProvider;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Subclass of <code>UpdateDependentProjectOp</code> that updates a dependent
+ * EAR project when one of the referenced projects has been deleted.
+ */
+public class UpdateDependentEARonDeleteOp extends UpdateDependentProjectOp {
+
+	/**
+	 * Creates a new refactoring operation for the specified data model.
+	 * @param model The data model.
+	 */
+	public UpdateDependentEARonDeleteOp(final IDataModel model) {
+		super(model);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
+	 */
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		final ProjectRefactorMetadata dependentMetadata = (ProjectRefactorMetadata) model.getProperty(DEPENDENT_PROJECT_METADATA);
+		final ProjectRefactorMetadata refactoredMetadata = (ProjectRefactorMetadata) model.getProperty(PROJECT_METADATA);
+		removeEARDependency(dependentMetadata, refactoredMetadata);
+		return Status.OK_STATUS;
+	}
+	
+	/**
+	 * Updates the dependent EAR project to account for the deletion of the referenced project.
+	 */	
+	protected static void removeEARDependency(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata) throws ExecutionException {
+
+		// create IVirtualComponents for the EAR and the refactored project
+		final IVirtualComponent earComp = dependentMetadata.getVirtualComponent();
+		final IVirtualComponent refactoredComp = refactoredMetadata.getVirtualComponent();
+		final IProgressMonitor monitor = new NullProgressMonitor();
+		
+		// remove the dependency on the deleted project
+		if (refactoredComp != null) {
+			final IDataModel model = DataModelFactory.createDataModel(new RemoveReferenceComponentsDataModelProvider());
+			model.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp);
+			final List modHandlesList = (List) model.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+			modHandlesList.add(refactoredComp);
+			model.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modHandlesList);
+			RemoveDeletedComponentFromEAROperation op = new RemoveDeletedComponentFromEAROperation(model, refactoredMetadata);
+			op.execute(monitor, null);
+		}
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonDeleteProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonDeleteProvider.java
new file mode 100644
index 0000000..1a4f0ca
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonDeleteProvider.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+public class UpdateDependentEARonDeleteProvider extends UpdateDependentProjectDataModelProvider 
+	implements ProjectRefactoringProperties {
+	
+	public IDataModelOperation getDefaultOperation() {
+		return new UpdateDependentEARonDeleteOp(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonRenameOp.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonRenameOp.java
new file mode 100644
index 0000000..cb9fc99
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonRenameOp.java
@@ -0,0 +1,97 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jst.j2ee.application.internal.operations.AddComponentToEnterpriseApplicationDataModelProvider;
+import org.eclipse.jst.j2ee.project.facet.IJavaProjectMigrationDataModelProperties;
+import org.eclipse.jst.j2ee.project.facet.JavaProjectMigrationDataModelProvider;
+import org.eclipse.jst.j2ee.refactor.RefactorResourceHandler;
+import org.eclipse.jst.j2ee.refactor.operations.ProjectRefactorMetadata.RefCachingVirtualComponent;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
+import org.eclipse.wst.common.componentcore.internal.operation.CreateReferenceComponentsDataModelProvider;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Subclass of <code>UpdateDependentProjectOp</code> that updates a dependent
+ * EAR project when a referenced project has been renamed.
+ */
+public class UpdateDependentEARonRenameOp extends UpdateDependentProjectOp {
+
+	public UpdateDependentEARonRenameOp(final IDataModel model) {
+		super(model);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
+	 */
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		
+		final ProjectRefactorMetadata dependentMetadata = (ProjectRefactorMetadata) model.getProperty(DEPENDENT_PROJECT_METADATA);
+		final ProjectRefactorMetadata originalMetadata = (ProjectRefactorMetadata) model.getProperty(ORIGINAL_PROJECT_METADATA);
+		final ProjectRefactorMetadata refactoredMetadata = (ProjectRefactorMetadata) model.getProperty(PROJECT_METADATA);
+		
+		// create IVirtualComponents for the EAR and the refactored project
+		final RefCachingVirtualComponent earComp = (RefCachingVirtualComponent) dependentMetadata.getVirtualComponent();
+		final IVirtualComponent refactoredComp = refactoredMetadata.getVirtualComponent();
+
+		if (refactoredComp == null) {
+			return Status.OK_STATUS;
+		}
+		
+		boolean hadReference = hadReference(dependentMetadata, originalMetadata);
+		
+		// first, remove the dependency on the old project name via the 
+		// ProjectDeleteOperation
+		UpdateDependentEARonDeleteOp.removeEARDependency(dependentMetadata, originalMetadata);
+		
+		// change to use not use caching
+		earComp.setCaching(false);
+		
+		// add back a dependency on the renamed project
+		if (refactoredMetadata.hasModuleCoreNature()) {
+			// the refactored project was a module project
+			final IDataModel dm = DataModelFactory.createDataModel(new AddComponentToEnterpriseApplicationDataModelProvider());
+			dm.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp); 
+			final List depList = new ArrayList();
+			depList.add(refactoredComp);
+			dm.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, depList);
+			dm.getDefaultOperation().execute(monitor, null);
+		} else if (refactoredMetadata.hasJavaNature()) {
+			// the refactored project was a plain java project
+			final IDataModel migrationdm = DataModelFactory.createDataModel(new JavaProjectMigrationDataModelProvider());
+			migrationdm.setProperty(IJavaProjectMigrationDataModelProperties.PROJECT_NAME, refactoredMetadata.getProjectName());
+			migrationdm.getDefaultOperation().execute(new NullProgressMonitor(), null);
+			final IDataModel refdm = DataModelFactory.createDataModel(new CreateReferenceComponentsDataModelProvider());
+			final List targetCompList = (List) refdm.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+			targetCompList.add(refactoredComp);
+			refdm.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, earComp);
+			refdm.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, targetCompList);
+			CreateOptionalReferenceOp op = new CreateOptionalReferenceOp(refdm, hadReference);
+			op.execute(monitor, null);
+		} else {
+			throw new ExecutionException(RefactorResourceHandler.getString("missing_natures"), null);
+		}
+		return Status.OK_STATUS;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonRenameProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonRenameProvider.java
new file mode 100644
index 0000000..e9abc1b
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentEARonRenameProvider.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+public class UpdateDependentEARonRenameProvider extends UpdateDependentProjectRenameDataModelProvider 
+	implements ProjectRefactoringProperties {
+
+	public IDataModelOperation getDefaultOperation() {
+		return new UpdateDependentEARonRenameOp(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonDeleteOp.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonDeleteOp.java
new file mode 100644
index 0000000..d558a2f
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonDeleteOp.java
@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.jar.Manifest;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProperties;
+import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProvider;
+import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
+import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifestImpl;
+import org.eclipse.jst.j2ee.internal.J2EEConstants;
+import org.eclipse.jst.j2ee.internal.common.operations.JARDependencyDataModelProperties;
+import org.eclipse.jst.j2ee.internal.common.operations.JARDependencyDataModelProvider;
+import org.eclipse.jst.j2ee.refactor.RefactorResourceHandler;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
+import org.eclipse.wst.common.componentcore.internal.operation.RemoveReferenceComponentsDataModelProvider;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Subclass of <code>UpdateDependentProjectOp</code> that updates a dependent
+ * module project when one of the referenced projects has been deleted.
+ */
+public class UpdateDependentModuleonDeleteOp extends UpdateDependentProjectOp {
+	
+	/**
+	 * Creates a new refactoring operation for the specified data model.
+	 * @param model The data model.
+	 */
+	public UpdateDependentModuleonDeleteOp(final IDataModel model) {
+		super(model);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
+	 */
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		final ProjectRefactorMetadata dependentMetadata = (ProjectRefactorMetadata) model.getProperty(DEPENDENT_PROJECT_METADATA);
+		final ProjectRefactorMetadata refactoredMetadata = (ProjectRefactorMetadata) model.getProperty(PROJECT_METADATA);
+		removeModuleDependency(dependentMetadata, refactoredMetadata);
+		return Status.OK_STATUS;
+	}
+	
+	/**
+	 * Updates the dependent module project to account for the deletion of the referenced project.
+	 */
+	protected static void removeModuleDependency(final ProjectRefactorMetadata dependentMetadata, 
+			final ProjectRefactorMetadata refactoredMetadata) throws ExecutionException {
+		
+		// create IVirtualComponents for the dependent and the refactored project
+		final IVirtualComponent dependentComp = dependentMetadata.getVirtualComponent();
+		final IVirtualComponent refactoredComp = refactoredMetadata.getVirtualComponent();
+		final IProgressMonitor monitor = new NullProgressMonitor();
+
+		// remove the component reference on the deleted project
+		if (refactoredComp != null) {
+			final IDataModel model = DataModelFactory.createDataModel(new RemoveReferenceComponentsDataModelProvider());
+			model.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, dependentComp);
+			final List modHandlesList = (List) model.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+			modHandlesList.add(refactoredComp);
+			model.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, modHandlesList);
+			model.getDefaultOperation().execute(monitor, null);
+		}
+		
+		// update the manifest
+		updateManifestDependency(refactoredMetadata, dependentMetadata, true);
+		
+		// update the JAR dependency data
+		IDataModel dataModel = DataModelFactory.createDataModel(new JARDependencyDataModelProvider());
+		dataModel.setProperty(JARDependencyDataModelProperties.PROJECT_NAME, dependentMetadata.getProjectName());
+		dataModel.setProperty(JARDependencyDataModelProperties.REFERENCED_PROJECT_NAME, refactoredMetadata.getProjectName());
+		dataModel.setIntProperty(JARDependencyDataModelProperties.JAR_MANIPULATION_TYPE, JARDependencyDataModelProperties.JAR_MANIPULATION_REMOVE);
+		dataModel.getDefaultOperation().execute(monitor, null );
+		
+	}
+	
+	protected static void updateManifestDependency(final ProjectRefactorMetadata refactoredMetadata,
+			final ProjectRefactorMetadata dependentMetadata, final boolean remove) throws ExecutionException {
+		final IVirtualComponent dependentComp = dependentMetadata.getVirtualComponent();
+		final String dependentProjName = dependentMetadata.getProjectName();
+		final String refactoredProjName = refactoredMetadata.getProjectName();
+		final IVirtualFile vf = dependentComp.getRootFolder().getFile(new Path(J2EEConstants.MANIFEST_URI) );
+		final IFile manifestmf = vf.getUnderlyingFile();
+		final IProgressMonitor monitor = new NullProgressMonitor();
+		final IDataModel updateManifestDataModel = DataModelFactory.createDataModel(new UpdateManifestDataModelProvider());
+		updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.PROJECT_NAME, dependentProjName);
+		updateManifestDataModel.setBooleanProperty(UpdateManifestDataModelProperties.MERGE, false);
+		updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.MANIFEST_FILE, manifestmf);
+		final ArchiveManifest manifest = getArchiveManifest(manifestmf);
+		String[] cp = manifest.getClassPathTokenized();
+		List cpList = new ArrayList();
+		String newCp = refactoredProjName + ".jar";//$NON-NLS-1$
+		for (int i = 0; i < cp.length; i++) {
+			if (!cp[i].equals(newCp)) {
+				cpList.add(cp[i]);
+			}
+		}
+		if (!remove) {
+			cpList.add(newCp);
+		}
+		updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.JAR_LIST, cpList);
+		updateManifestDataModel.getDefaultOperation().execute(monitor, null );
+	}
+	
+	private static ArchiveManifest getArchiveManifest(final IFile manifestFile) throws ExecutionException {
+		InputStream in = null;
+		try {
+			in = manifestFile.getContents();
+			ArchiveManifest mf = new ArchiveManifestImpl(new Manifest(in));
+			return mf;
+		} catch (CoreException ce) {
+			throw new ExecutionException(RefactorResourceHandler.getString("error_reading_manifest"), ce);
+		} catch (IOException io) {
+			throw new ExecutionException(RefactorResourceHandler.getString("error_reading_manifest"), io);
+		} finally {
+			if (in != null) {
+				try {
+					in.close();
+				} catch (IOException weTried) {
+					//Ignore
+				}
+			}
+		}
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonDeleteProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonDeleteProvider.java
new file mode 100644
index 0000000..c3365c6
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonDeleteProvider.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+public class UpdateDependentModuleonDeleteProvider extends UpdateDependentProjectDataModelProvider 
+	implements ProjectRefactoringProperties {
+	
+	public IDataModelOperation getDefaultOperation() {
+		return new UpdateDependentModuleonDeleteOp(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonRenameOp.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonRenameOp.java
new file mode 100644
index 0000000..f29d8d2
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonRenameOp.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.List;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jst.j2ee.internal.common.operations.JARDependencyDataModelProperties;
+import org.eclipse.jst.j2ee.internal.common.operations.JARDependencyDataModelProvider;
+import org.eclipse.jst.j2ee.refactor.operations.ProjectRefactorMetadata.RefCachingVirtualComponent;
+import org.eclipse.wst.common.componentcore.datamodel.properties.ICreateReferenceComponentsDataModelProperties;
+import org.eclipse.wst.common.componentcore.internal.operation.CreateReferenceComponentsDataModelProvider;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Subclass of <code>UpdateDependentProjectOp</code> that updates a dependent
+ * module project when a referenced project has been renamed.
+ */
+public class UpdateDependentModuleonRenameOp extends UpdateDependentProjectOp {
+
+	public UpdateDependentModuleonRenameOp(final IDataModel model) {
+		super(model);
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)
+	 */
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
+		
+		final ProjectRefactorMetadata dependentMetadata = (ProjectRefactorMetadata) model.getProperty(DEPENDENT_PROJECT_METADATA);
+		final ProjectRefactorMetadata originalMetadata = (ProjectRefactorMetadata) model.getProperty(ORIGINAL_PROJECT_METADATA);
+		final ProjectRefactorMetadata refactoredMetadata = (ProjectRefactorMetadata) model.getProperty(PROJECT_METADATA);
+		
+		// create IVirtualComponents for the dependent project and the refactored project
+		final RefCachingVirtualComponent dependentComp = (RefCachingVirtualComponent) dependentMetadata.getVirtualComponent();
+		final IVirtualComponent refactoredComp = refactoredMetadata.getVirtualComponent();
+		
+		// Does the dependent project have a .component reference on the refactored project?
+		boolean hadReference = hadReference(dependentMetadata, originalMetadata);
+		
+		// first, remove the dependency on the old project name via the 
+		// ProjectDeleteOperation
+		UpdateDependentModuleonDeleteOp.removeModuleDependency(dependentMetadata, originalMetadata);
+		
+		// change to use not use caching
+		dependentComp.setCaching(false);
+		
+		// add a reference to the renamed project
+		if (refactoredComp != null) {
+			final IDataModel refdm = DataModelFactory.createDataModel(new CreateReferenceComponentsDataModelProvider());
+			final List targetCompList = (List) refdm.getProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST);
+			targetCompList.add(refactoredComp);
+			refdm.setProperty(ICreateReferenceComponentsDataModelProperties.SOURCE_COMPONENT, dependentComp);
+			refdm.setProperty(ICreateReferenceComponentsDataModelProperties.TARGET_COMPONENT_LIST, targetCompList);
+			CreateOptionalReferenceOp op = new CreateOptionalReferenceOp(refdm,hadReference); 
+			op.execute(monitor, null);
+		}
+	
+		// update the manifest
+		UpdateDependentModuleonDeleteOp.updateManifestDependency(refactoredMetadata, dependentMetadata, false);
+        
+        // update the JAR dependency data
+        IDataModel dataModel = DataModelFactory.createDataModel(new JARDependencyDataModelProvider());
+        dataModel.setProperty(JARDependencyDataModelProperties.PROJECT_NAME, dependentMetadata.getProjectName());
+        dataModel.setProperty(JARDependencyDataModelProperties.REFERENCED_PROJECT_NAME, refactoredMetadata.getProjectName());
+        dataModel.setIntProperty(JARDependencyDataModelProperties.JAR_MANIPULATION_TYPE, JARDependencyDataModelProperties.JAR_MANIPULATION_ADD);
+        dataModel.getDefaultOperation().execute(monitor, null );
+		return Status.OK_STATUS;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonRenameProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonRenameProvider.java
new file mode 100644
index 0000000..291b40c
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentModuleonRenameProvider.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+
+public class UpdateDependentModuleonRenameProvider extends UpdateDependentProjectRenameDataModelProvider 
+	implements ProjectRefactoringProperties {
+	
+	public IDataModelOperation getDefaultOperation() {
+		return new UpdateDependentModuleonRenameOp(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectDataModelProvider.java
new file mode 100644
index 0000000..574fd40
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectDataModelProvider.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.Set;
+
+public abstract class UpdateDependentProjectDataModelProvider extends ProjectRefactoringDataModelProvider 
+	implements ProjectRefactoringProperties {
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getPropertyNames()
+	 */
+	public Set getPropertyNames() {
+		Set propertyNames = super.getPropertyNames();
+		propertyNames.add(DEPENDENT_PROJECT_METADATA);
+		return propertyNames;
+	}
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectOp.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectOp.java
new file mode 100644
index 0000000..d1fac94
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectOp.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * Abstract base class for operations that update dependent projects when a 
+ * referenced project is refactored.
+ */
+public abstract class UpdateDependentProjectOp extends AbstractDataModelOperation 
+	implements ProjectRefactoringProperties {
+
+	/**
+	 * Creates a new refactoring operation for the specified data model.
+	 * @param model The data model.
+	 */
+	public UpdateDependentProjectOp(final IDataModel model) {
+		super(model);
+	}
+	
+	/**
+	 * Does the dependent project have a .component reference on the refactored project?
+	 */
+	protected boolean hadReference(final ProjectRefactorMetadata dependentMetadata,
+			final ProjectRefactorMetadata refactoredMetadata) {
+		final IVirtualComponent refactoredComp = refactoredMetadata.getVirtualComponent();
+		if (refactoredComp == null) {
+			return false;
+		}
+		final IVirtualReference[] refs = dependentMetadata.getVirtualComponent().getReferences();
+		boolean hadReference = false;
+		for (int i = 0; i < refs.length; i++) {
+			if (refs[i].getReferencedComponent().equals(refactoredComp)) {
+				hadReference = true;
+				break;
+			}
+		}
+		return hadReference;
+	}
+	
+	/**
+	 * Override to disable redo support
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canRedo()
+	 */
+	public boolean canRedo() {
+		return false;
+	}
+
+	/**
+	 * Override to disable undo support.
+	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canUndo()
+	 */
+	public boolean canUndo() {
+		return false;
+	}
+	
+}
diff --git a/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectRenameDataModelProvider.java b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectRenameDataModelProvider.java
new file mode 100644
index 0000000..fe9d4fe
--- /dev/null
+++ b/plugins/org.eclipse.jst.j2ee/refactor/org/eclipse/jst/j2ee/refactor/operations/UpdateDependentProjectRenameDataModelProvider.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2005 BEA Systems, Inc.
+ * 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:
+ * rfrost@bea.com - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.j2ee.refactor.operations;
+
+import java.util.Set;
+
+public abstract class UpdateDependentProjectRenameDataModelProvider extends ProjectRenameDataModelProvider 
+	implements ProjectRefactoringProperties {
+	
+	/* (non-Javadoc)
+	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getPropertyNames()
+	 */
+	public Set getPropertyNames() {
+		Set propertyNames = super.getPropertyNames();
+		propertyNames.add(DEPENDENT_PROJECT_METADATA);
+		return propertyNames;
+	}
+
+}
diff --git a/plugins/org.eclipse.jst.j2ee/schema/DeployerExtension.exsd b/plugins/org.eclipse.jst.j2ee/schema/DeployerExtension.exsd
index 186fbb4..d9d3c61 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/DeployerExtension.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/DeployerExtension.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="DeployerExtension" name="J2EEDeployerExtension"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="DeployerExtension" name="J2EE Deployer Extension"/>
       </appInfo>
       <documentation>
          The extension point gives the ability to extend deployer operations on J2EE artifacts, for eg, EJB deployment and Webservices deployment. Registration of the deployer is based on module type and server target.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -99,7 +99,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -108,7 +108,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -117,7 +117,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -126,7 +126,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -135,7 +135,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/EARModuleExtension.exsd b/plugins/org.eclipse.jst.j2ee/schema/EARModuleExtension.exsd
index 25025cc..cd9206d 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/EARModuleExtension.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/EARModuleExtension.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="EARModuleExtension" name="EARModuleExtension"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="EARModuleExtension" name="EAR Module Extension"/>
       </appInfo>
       <documentation>
          The api&apos;s for EJB, JCA and Web modules are defined in plugins separate from J2EE plugin. Those plugins have dependencies on the J2EE plugin, but not vice versa. In order for code defined within the J2EE plugin to access api&apos;s in these modules we need this extension point.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -56,7 +56,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -65,7 +65,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -74,7 +74,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -83,7 +83,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -92,7 +92,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/EJBCommandExtension.exsd b/plugins/org.eclipse.jst.j2ee/schema/EJBCommandExtension.exsd
index 31933ab..26ffe68 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/EJBCommandExtension.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/EJBCommandExtension.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="EJBCommandExtension" name="EJBCommandExtension"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="EJBCommandExtension" name="EJB Command Extension"/>
       </appInfo>
       <documentation>
          Mainly used to overwrite delete and update commands for ejb&apos;s. For eg the extension was used to overwrite delete bean command.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -71,7 +71,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -80,7 +80,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -89,7 +89,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -98,7 +98,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -107,7 +107,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/ExtendedModuleImport.exsd b/plugins/org.eclipse.jst.j2ee/schema/ExtendedModuleImport.exsd
index 7023464..5c4b01a 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/ExtendedModuleImport.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/ExtendedModuleImport.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="SpecializedModuleImport" name="SpecializedModuleImport"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="SpecializedModuleImport" name="Specialized Module Import"/>
       </appInfo>
       <documentation>
          This extension point gives the ability to treat a jar file which is not an ejb jar file as an ejb jar file during ejb jar import.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -63,7 +63,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -72,7 +72,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -81,7 +81,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -90,7 +90,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -99,7 +99,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/GeneratorDictionaryExtension.exsd b/plugins/org.eclipse.jst.j2ee/schema/GeneratorDictionaryExtension.exsd
deleted file mode 100644
index 9afbf62..0000000
--- a/plugins/org.eclipse.jst.j2ee/schema/GeneratorDictionaryExtension.exsd
+++ /dev/null
@@ -1,108 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="com.ibm.etools.j2ee">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="com.ibm.etools.j2ee" id="GeneratorDictionaryExtension" name="GeneratorDictionaryExtension"/>
-      </appInfo>
-      <documentation>
-         This extension point gives the ability to create an extended Enterprise Bean creation commands dictionary. The core dictionary provides core EJB creation commands as per the J2EE specification.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="dictionaryExtension"/>
-         </sequence>
-         <attribute name="point" type="string" use="default" value="org.eclipse.jst.j2ee.GeneratorDictionaryExtension">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="default" value="GeneratorDictionaryExtension">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="dictionaryExtension">
-      <complexType>
-         <sequence>
-         </sequence>
-         <attribute name="baseDictionary" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="extensionDictionary" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         [Enter the first release in which this extension point appears.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         [Enter extension point usage example here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         [Enter API information here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         [Enter information about supplied implementation of this extension point.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/plugins/org.eclipse.jst.j2ee/schema/J2EEModulePostImport.exsd b/plugins/org.eclipse.jst.j2ee/schema/J2EEModulePostImport.exsd
index 3460a2e..c343716 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/J2EEModulePostImport.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/J2EEModulePostImport.exsd
@@ -3,13 +3,13 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="J2EEModulePostImport" name="J2EEModulePostImport"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="J2EEModulePostImport" name="J2EE Module Post Import"/>
       </appInfo>
       <documentation>
          This extension-point sends notification to all extensions when J2EEModules are imported. Each extension can specify a set of different module types to listen for or listen to them all.  The default is to receive notification for all module types.  Notification is sent
 to the specified class implementing com.ibm.etools.j2ee.J2EEModulePostImportHandler.
 
-Both of the following examples register for notification for all J2EEModule types, the first	uses the defaults, while the second specifies each module type.  To listen for only specific module types, use the second example and specify only the types to listen to.
+Both of the following examples register for notification for all J2EEModule types, the first uses the defaults, while the second specifies each module type.  To listen for only specific module types, use the second example and specify only the types to listen to.
       </documentation>
    </annotation>
 
@@ -21,21 +21,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -74,7 +74,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -83,7 +83,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -92,7 +92,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -101,7 +101,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -110,7 +110,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/TargetRuntimeExtension.exsd b/plugins/org.eclipse.jst.j2ee/schema/TargetRuntimeExtension.exsd
deleted file mode 100644
index 24606ac..0000000
--- a/plugins/org.eclipse.jst.j2ee/schema/TargetRuntimeExtension.exsd
+++ /dev/null
@@ -1,126 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jst.j2ee">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="TargetRuntimeExtHandler" name="TargetRuntimeExtensionHandler"/>
-      </appInfo>
-      <documentation>
-         Here is a sample of this extension
-
-&lt;extension
-         id=&quot;TargetRuntimeExtension&quot;
-         name=&quot;TargetRuntimeExtensionHandler&quot;
-         point=&quot;org.eclipse.jst.j2ee.TargetRuntimeExtension&quot;&gt;
-      &lt;targetRuntimeExtensionHandler
-            groupID=&quot;IBM&quot;&gt;
-         &lt;run
-           class=&quot;com.ibm.etools.ejb.ws.ext.helpers.TargetRuntimeExtHandler&quot;&gt;
-         &lt;/run&gt;
-      &lt;/targetRuntimeExtensionHandler&gt;
-&lt;/extension&gt;
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="targetRuntimeExtensionHandler"/>
-         </sequence>
-         <attribute name="point" type="string" use="default" value="org.eclipse.jst.j2ee.TargetRuntimeExtension">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="default" value="TargetRuntimeExtension">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="default" value="TargetRuntimeExtensionHandler">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="targetRuntimeExtensionHandler">
-      <complexType>
-         <sequence>
-            <element ref="run"/>
-         </sequence>
-         <attribute name="groupID" type="string" use="default" value="IBM">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="run">
-      <complexType>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         [Enter the first release in which this extension point appears.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         [Enter extension point usage example here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         [Enter API information here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         [Enter information about supplied implementation of this extension point.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/plugins/org.eclipse.jst.j2ee/schema/WSDLServiceHelper.exsd b/plugins/org.eclipse.jst.j2ee/schema/WSDLServiceHelper.exsd
index e924b75..3954682 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/WSDLServiceHelper.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/WSDLServiceHelper.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="SpecializedModuleImport" name="SpecializedModuleImport"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="SpecializedModuleImport" name="Specialized Module Import"/>
       </appInfo>
       <documentation>
          This extension point gives the ability to treat a jar file which is not an ejb jar file as an ejb jar file during ejb jar import.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -56,7 +56,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -65,7 +65,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -74,7 +74,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -83,7 +83,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -92,7 +92,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/WebServiceClientGenerator.exsd b/plugins/org.eclipse.jst.j2ee/schema/WebServiceClientGenerator.exsd
index 99c2fed..0864a5c 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/WebServiceClientGenerator.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/WebServiceClientGenerator.exsd
@@ -3,7 +3,7 @@
 <schema targetNamespace="org.eclipse.jst.j2ee">
 <annotation>
       <appInfo>
-         <meta.schema plugin="org.eclipse.jst.j2ee" id="WebServiceClientGenerator" name="WebServiceClientGenerator"/>
+         <meta.schema plugin="org.eclipse.jst.j2ee" id="WebServiceClientGenerator" name="Web Service Client Generator"/>
       </appInfo>
       <documentation>
          Extended by WAS or axis in generating web service client specific artifacts.
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -71,7 +71,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         [Enter the first release in which this extension point appears.]
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -80,7 +80,7 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         
       </documentation>
    </annotation>
 
@@ -89,7 +89,7 @@
          <meta.section type="apiInfo"/>
       </appInfo>
       <documentation>
-         [Enter API information here.]
+         
       </documentation>
    </annotation>
 
@@ -98,7 +98,7 @@
          <meta.section type="implementation"/>
       </appInfo>
       <documentation>
-         [Enter information about supplied implementation of this extension point.]
+         
       </documentation>
    </annotation>
 
@@ -107,7 +107,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/resourceEnvRefType.exsd b/plugins/org.eclipse.jst.j2ee/schema/resourceEnvRefType.exsd
index 8885826..2155bcb 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/resourceEnvRefType.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/resourceEnvRefType.exsd
@@ -18,21 +18,21 @@
          <attribute name="point" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  a fully qualified identifier of the target extension point
                </documentation>
             </annotation>
          </attribute>
          <attribute name="id" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional identifier of the extension instance
                </documentation>
             </annotation>
          </attribute>
          <attribute name="name" type="string">
             <annotation>
                <documentation>
-                  
+                  an optional name of the extension instance
                </documentation>
             </annotation>
          </attribute>
@@ -51,8 +51,8 @@
          <attribute name="usage" use="required">
             <annotation>
                <documentation>
-                  The usage field is required.  Valid types are Common, EJB Jar. 
-A usage tag with the value Common indicates that the corresponding value will be avilable for all J2EE projects.
+                  The usage field is required.  Valid types are Common, EJB Jar. 
+A usage tag with the value Common indicates that the corresponding value will be avilable for all J2EE projects.
 A usage tag with the value EJB Jar indicates that the value is only applicable to EJB projects.
                </documentation>
             </annotation>
@@ -82,7 +82,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -91,10 +91,13 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         The following is an example of the extension:&lt;pre&gt;&lt;extension point=&quot;com.ibm.etools.j2ee.ui.resourceEnvRefType&quot;&gt;
-  &lt;reference usage=&quot;Common&quot; type=&quot;javax.sql.DataSource&quot;/&gt;
-  &lt;reference usage=&quot;EJB Jar&quot; type=&quot;javax.jms.Topic&quot;/&gt;
-&lt;/extension&gt;
+         The following is an example of the extension:
+&lt;pre&gt;
+   &lt;extension
+         point=&quot;org.eclipse.jst.j2ee.ui.resourceEnvRefType&quot;&gt;
+      &lt;reference usage=&quot;Common&quot; type=&quot;javax.sql.DataSource&quot;/&gt;
+      &lt;reference usage=&quot;EJB Jar&quot; type=&quot;javax.jms.Topic&quot;/&gt;
+   &lt;/extension&gt;
 &lt;/pre&gt;
       </documentation>
    </annotation>
@@ -122,7 +125,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         * Copyright (c) 2003 IBM Corporation. * All rights reserved.
+         Copyright (c) 2003, 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.j2ee/schema/resourceRefType.exsd b/plugins/org.eclipse.jst.j2ee/schema/resourceRefType.exsd
index dde9cb7..4101126 100644
--- a/plugins/org.eclipse.jst.j2ee/schema/resourceRefType.exsd
+++ b/plugins/org.eclipse.jst.j2ee/schema/resourceRefType.exsd
@@ -51,8 +51,8 @@
          <attribute name="usage" use="required">
             <annotation>
                <documentation>
-                  The usage field is required.  Valid types are Common, EJB Jar. 
-A usage tag with the value Common indicates that the corresponding value will be avilable for all J2EE projects.
+                  The usage field is required.  Valid types are Common, EJB Jar. 
+A usage tag with the value Common indicates that the corresponding value will be avilable for all J2EE projects.
 A usage tag with the value EJB Jar indicates that the value is only applicable to EJB projects.
                </documentation>
             </annotation>
@@ -82,7 +82,7 @@
          <meta.section type="since"/>
       </appInfo>
       <documentation>
-         
+         &lt;b&gt;This extension point is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made 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.&lt;/b&gt;
       </documentation>
    </annotation>
 
@@ -91,10 +91,14 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         The following is an example of the extension:&lt;pre&gt;&lt;extension point=&quot;com.ibm.etools.j2ee.ui.resourceRefType&quot;&gt;
-  &lt;reference usage=&quot;Common&quot; type=&quot;javax.jms.Queue&quot;/&gt;    
-  &lt;reference usage=&quot;EJB Jar&quot; type=&quot;javax.resource.cci.ConnectionFactory&quot;/&gt;
-&lt;/extension&gt; &lt;/pre&gt;
+         The following is an example of the extension:
+&lt;pre&gt;
+   &lt;extension
+         point=&quot;org.eclipse.jst.j2ee.ui.resourceRefType&quot;&gt;
+      &lt;reference usage=&quot;Common&quot; type=&quot;javax.jms.Queue&quot;/&gt;    
+      &lt;reference usage=&quot;EJB Jar&quot; type=&quot;javax.resource.cci.ConnectionFactory&quot;/&gt;
+   &lt;/extension&gt; 
+&lt;/pre&gt;
       </documentation>
    </annotation>
 
@@ -121,7 +125,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         * Copyright (c) 2003 IBM Corporation. * All rights reserved.
+         Copyright (c) 2003, 2005 IBM Corporation and others.&lt;br&gt;
+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 &lt;a
+href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/plugins/org.eclipse.jst.servlet.ui/.cvsignore b/plugins/org.eclipse.jst.servlet.ui/.cvsignore
index c8ac111..50d757c 100644
--- a/plugins/org.eclipse.jst.servlet.ui/.cvsignore
+++ b/plugins/org.eclipse.jst.servlet.ui/.cvsignore
@@ -3,3 +3,4 @@
 build.xml
 servletui.jar
 @dot
+src.zip
diff --git a/plugins/org.eclipse.jst.servlet.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.jst.servlet.ui/META-INF/MANIFEST.MF
index 33d78ba..9aa8bd7 100644
--- a/plugins/org.eclipse.jst.servlet.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.jst.servlet.ui/META-INF/MANIFEST.MF
@@ -37,5 +37,6 @@
  org.eclipse.wst.server.core,
  org.eclipse.jst.server.core,
  org.eclipse.wst.common.project.facet.core,
- org.eclipse.wst.common.project.facet.ui
+ org.eclipse.wst.common.project.facet.ui,
+ org.eclipse.wst.web.ui
 Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.jst.servlet.ui/icons/war.gif b/plugins/org.eclipse.jst.servlet.ui/icons/war.gif
new file mode 100644
index 0000000..31ecb7a
--- /dev/null
+++ b/plugins/org.eclipse.jst.servlet.ui/icons/war.gif
Binary files differ
diff --git a/plugins/org.eclipse.jst.servlet.ui/plugin.xml b/plugins/org.eclipse.jst.servlet.ui/plugin.xml
index 55fb4ad..1b76c01 100644
--- a/plugins/org.eclipse.jst.servlet.ui/plugin.xml
+++ b/plugins/org.eclipse.jst.servlet.ui/plugin.xml
@@ -53,10 +53,10 @@
             name="%web.project_ui_"
             icon="icons/full/ctool16/newwar_wiz.gif"
             category="org.eclipse.wst.web.ui"
-            class="org.eclipse.jst.servlet.ui.internal.wizard.WebComponentCreationWizard"
+            class="org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard"
             project="true"
             finalPerspective="org.eclipse.jst.j2ee.J2EEPerspective"
-            id="org.eclipse.jst.servlet.ui.WebComponentCreationWizard">
+            id="org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard">
          <description>
             %new.web.project.description_ui_
          </description>
@@ -134,7 +134,7 @@
           <!-- Web New -->
         <commonWizard
             type="new"
-            wizardId="org.eclipse.jst.servlet.ui.WebComponentCreationWizard">
+            wizardId="org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard">
          <enablement>
            <or>
                <objectClass
@@ -427,7 +427,7 @@
       </decorator>
     </extension> 
     
-    <extension point="org.eclipse.wst.common.project.facet.ui.wizard">
+  <extension point="org.eclipse.wst.common.project.facet.ui.wizard">
   
     <wizard-pages facet="jst.web" version="2.2">
       <install>
@@ -449,18 +449,8 @@
     
   </extension>
   
-    <extension point="org.eclipse.ui.newWizards">
-
-    <wizard
-      name="%web-project-wizard-name"
-      icon="icons/full/ctool16/web-wiz-icon.gif"
-      category="org.eclipse.jst.newprojects"
-      class="org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard"
-      project="true"
-      id="org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard">
-      <description>%web-project-wizard-description</description>
-    </wizard>
-    
+  <extension point="org.eclipse.wst.common.project.facet.ui.images">
+    <image facet="jst.web" path="icons/war.gif"/>
   </extension>
-	
+  
 </plugin>
diff --git a/plugins/org.eclipse.jst.servlet.ui/property_files/web_ui.properties b/plugins/org.eclipse.jst.servlet.ui/property_files/web_ui.properties
index 8ed7bc8..2c22a8a 100644
--- a/plugins/org.eclipse.jst.servlet.ui/property_files/web_ui.properties
+++ b/plugins/org.eclipse.jst.servlet.ui/property_files/web_ui.properties
@@ -8,24 +8,24 @@
 # Contributors:
 # IBM Corporation - initial API and implementation
 ###############################################################################
-0=Failed to find the image "{0}".
-1=New Dynamic Web Project
-2=Servlet version:
-3=Dynamic Web Project
-4=Create a standalone Dynamic Web project or add it to a new or existing Enterprise Application.
-5=Web project:
-6=WAR file:
-7=Import a WAR file from the file system
-8=WAR Import
-9=WAR Export
-10=Export Web project to the local file system.
-11=Context Root:
-12=Convert Simple Web to Web Module
-13=Convert Simple Web to Web Module.
-14=WAR Import: Web libraries
-15=Select the web library jars from the list below to be imported as web library projects.  Unselected web libraries will be imported as jars in the WEB-INF/lib directory.
-16=Select All
-17=Deselect All
+_0=Failed to find the image "{0}".
+_1=New Dynamic Web Project
+_2=Servlet version:
+_3=Dynamic Web Project
+_4=Create a standalone Dynamic Web project or add it to a new or existing Enterprise Application.
+_5=Web project:
+_6=WAR file:
+_7=Import a WAR file from the file system
+_8=WAR Import
+_9=WAR Export
+_10=Export Web project to the local file system.
+_11=Context Root:
+_12=Convert Simple Web to Web Module
+_13=Convert Simple Web to Web Module.
+_14=WAR Import: Web libraries
+_15=Select the web library jars from the list below to be imported as web library projects.  Unselected web libraries will be imported as jars in the WEB-INF/lib directory.
+_16=Select All
+_17=Deselect All
 
 ADD_SERVLET_WIZARD_WINDOW_TITLE=Create Servlet
 ADD_SERVLET_WIZARD_PAGE_TITLE=Create Servlet
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/actions/NewWebComponentAction.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/actions/NewWebComponentAction.java
index 8005dd2..d8ff4d8 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/actions/NewWebComponentAction.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/actions/NewWebComponentAction.java
@@ -14,7 +14,7 @@
 import org.eclipse.jst.j2ee.internal.actions.AbstractOpenWizardWorkbenchAction;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
 import org.eclipse.jst.servlet.ui.internal.plugin.WEBUIMessages;
-import org.eclipse.jst.servlet.ui.internal.wizard.WebComponentCreationWizard;
+import org.eclipse.jst.servlet.ui.project.facet.WebProjectWizard;
 import org.eclipse.ui.IWorkbench;
 
 public class NewWebComponentAction extends AbstractOpenWizardWorkbenchAction {
@@ -39,7 +39,7 @@
 	}
 
 	protected Wizard createWizard() {
-		return new WebComponentCreationWizard();
+		return new WebProjectWizard();
 	}
 	
 	protected boolean shouldAcceptElement(Object obj) { 
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/classpath/WebAppContainerPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/classpath/WebAppContainerPage.java
index 2cdb7b0..bd13a69 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/classpath/WebAppContainerPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/classpath/WebAppContainerPage.java
@@ -50,10 +50,10 @@
     
     public WebAppContainerPage() 
     {
-        super( resource( "WEB_CONT_NAME" ) ); //$NON-NLS-1$
+        super( WEBUIMessages.WEB_CONT_NAME ); //$NON-NLS-1$
         
-        setTitle( resource( "WEB_CONT_PAGE_TITLE" ) ); //$NON-NLS-1$
-        setDescription( resource( "WEB_CONT_PAGE_DESCRIPTION" ) ); //$NON-NLS-1$
+        setTitle( WEBUIMessages.WEB_CONT_PAGE_TITLE ); //$NON-NLS-1$
+        setDescription( WEBUIMessages.WEB_CONT_PAGE_DESCRIPTION ); //$NON-NLS-1$
         
         // TODO: Replace with a custom image.
         setImageDescriptor( JavaPluginImages.DESC_WIZBAN_ADD_LIBRARY ); //$NON-NLS-1$
@@ -90,7 +90,7 @@
         composite.setLayout( new GridLayout( 1, false ) );
         
         this.componentLabel = new Label( composite, SWT.NONE );
-        this.componentLabel.setText( resource( "WEB_CONT_PAGE_COMP_LABEL" ) ); //$NON-NLS-1$
+        this.componentLabel.setText( WEBUIMessages.WEB_CONT_PAGE_COMP_LABEL ); //$NON-NLS-1$
         
         this.componentCombo = new Combo( composite, SWT.READ_ONLY );
         
@@ -157,10 +157,4 @@
         
         return res;
     }
-    
-    private static String resource( final String key )
-    {
-        return WEBUIMessages.getResourceString( key );
-    }
-
 }
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/plugin/WEBUIMessages.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/plugin/WEBUIMessages.java
index 8656495..3477f07 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/plugin/WEBUIMessages.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/plugin/WEBUIMessages.java
@@ -8,63 +8,119 @@
  **************************************************************************************************/
 package org.eclipse.jst.servlet.ui.internal.plugin;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.wst.common.frameworks.internal.Messages;
+import org.eclipse.osgi.util.NLS;
 
 
-public class WEBUIMessages extends Messages {
+public class WEBUIMessages extends NLS {
 
-	public static final String IMAGE_LOAD_ERROR = "0"; //$NON-NLS-1$
-	public static final String WEB_MODULE_WIZ_TITLE = "1"; //$NON-NLS-1$
-	public static final String WEB_VERSION_LBL = "2"; //$NON-NLS-1$
-	public static final String WEB_PROJECT_MAIN_PG_TITLE = "3"; //$NON-NLS-1$
-	public static final String WEB_PROJECT_MAIN_PG_DESC = "4"; //$NON-NLS-1$
-	public static final String EJB_PROJECT_LBL = "5"; //$NON-NLS-1$
-	public static final String WEB_FILE_LBL = "6"; //$NON-NLS-1$
-	public static final String WEB_IMPORT_MAIN_PG_DESC = "7"; //$NON-NLS-1$
-	public static final String WEB_IMPORT_MAIN_PG_TITLE = "8"; //$NON-NLS-1$
-	public static final String WEB_EXPORT_MAIN_PG_TITLE = "9"; //$NON-NLS-1$
-	public static final String WEB_EXPORT_MAIN_PG_DESC = "10"; //$NON-NLS-1$
-	public static final String WEB_IMPORT_CONTEXT_ROOT = "11"; //$NON-NLS-1$
-	public static final String WEB_CONVERT_MAIN_PG_DESC = "12"; //$NON-NLS-1$
-	public static final String WEB_CONVERT_MAIN_PG_TITLE = "13"; //$NON-NLS-1$
-	public static final String WEB_IMPORT_WEB_LIB_PG_TITLE = "14"; //$NON-NLS-1$
-	public static final String WEB_IMPORT_WEB_LIB_PG_DESC = "15"; //$NON-NLS-1$
-	public static final String WAR_IMPORT_SELECT_ALL_LIBS_BUTTON = "16"; //$NON-NLS-1$
-	public static final String WAR_IMPORT_DESELECT_ALL_LIBS_BUTTON = "17"; //$NON-NLS-1$
-	public static final String WEBCONTENT="WEBCONTENT";//$NON-NLS-1$
-
-	private static final WEBUIMessages INSTANCE = new WEBUIMessages();
-
+	private static final String BUNDLE_NAME = "web_ui";//$NON-NLS-1$
 
 	private WEBUIMessages() {
-		super();
+		// Do not instantiate
 	}
 
-	/**
-	 * Returns the string from the resource bundle, or 'key' if not found.
-	 */
-	public static String getResourceString(String key) {
-		return INSTANCE.doGetResourceString(key);
+	public static String NEW_SERVLET_WIZARD_PAGE_TITLE;
+	public static String FOLDER_LABEL;
+	public static String URL_MAPPINGS_LABEL;
+	public static String JAVA_CLASS_MODIFIERS_LABEL;
+	public static String SUPERCLASS_LABEL;
+	public static String WEB_CONT_PAGE_TITLE;
+	public static String SERVLET_PACKAGE_LABEL;
+	public static String PACKAGE_SELECTION_DIALOG_MSG_NONE;
+	public static String JAVA_CLASS_ABSTRACT_CHECKBOX_LABEL;
+	public static String ADD_SERVLET_WIZARD_WINDOW_TITLE;
+	public static String ADD_SERVLET_WIZARD_PAGE_TITLE;
+	public static String JAVA_CLASS_MAIN_CHECKBOX_LABEL;
+	public static String EMPTY_LIST_MSG;
+	public static String ExportWARAction_UI_;
+	public static String NO_WEB_PROJECTS;
+	public static String INTERFACE_SELECTION_DIALOG_MSG_NONE;
+	public static String SUPERCLASS_SELECTION_DIALOG_TITLE;
+	public static String PACKAGE_SELECTION_DIALOG_DESC;
+	public static String JAVA_CLASS_BROWER_DIALOG_TITLE;
+	public static String CONTAINER_SELECTION_DIALOG_DESC;
+	public static String NEW_JAVA_CLASS_DESTINATION_WIZARD_PAGE_DESC;
+	public static String JAVA_CLASS_PUBLIC_CHECKBOX_LABEL;
+	public static String URL_PATTERN_LABEL;
+	public static String CONTAINER_SELECTION_DIALOG_TITLE;
+	public static String WEB_CONT_NAME;
+	public static String URL_PATTERN_TITLE;
+	public static String CONTAINER_SELECTION_DIALOG_VALIDATOR_MESG;
+	public static String DESCRIPTION_LABEL;
+	public static String USE_EXISTING_SERVLET_CLASS;
+	public static String JAVA_CLASS_FINAL_CHECKBOX_LABEL;
+	public static String INTERFACE_SELECTION_DIALOG_DESC;
+	public static String ADD_LABEL;
+	public static String ADD_SERVLET_WIZARD_PAGE_DESC;
+	public static String SELECT_CLASS_TITLE;
+	public static String JAVA_CLASS_BROWER_DIALOG_MESSAGE;
+	public static String ImportWARAction_UI_;
+	public static String _9;
+	public static String JAVA_CLASS_METHOD_STUBS_LABEL;
+	public static String _8;
+	public static String JAVA_CLASS_CONSTRUCTOR_CHECKBOX_LABEL;
+	public static String _7;
+	public static String SERVLETS;
+	public static String _6;
+	public static String DEFAULT_PACKAGE;
+	public static String _5;
+	public static String MAP_CLASS_NAME_TO_CLASS_ERROR_MSG;
+	public static String BROWSE_BUTTON_LABEL;
+	public static String _4;
+	public static String REMOVE_BUTTON;
+	public static String _3;
+	public static String _2;
+	public static String _1;
+	public static String INIT_PARAM_LABEL;
+	public static String SERVLET_NAME_LABEL;
+	public static String _0;
+	public static String CLASS_NAME_LABEL;
+	public static String _17;
+	public static String _16;
+	public static String JAVA_PACKAGE_LABEL;
+	public static String _15;
+	public static String _14;
+	public static String _13;
+	public static String PACKAGE_SELECTION_DIALOG_TITLE;
+	public static String _12;
+	public static String ADD_BUTTON_LABEL;
+	public static String _11;
+	public static String _10;
+	public static String SUPERCLASS_SELECTION_DIALOG_DESC;
+	public static String NEW_JAVA_CLASS_OPTIONS_WIZARD_PAGE_DESC;
+	public static String REMOVE_BUTTON_LABEL;
+	public static String NEW_SERVLET_WIZARD_WINDOW_TITLE;
+	public static String INTERFACE_SELECTION_DIALOG_TITLE;
+	public static String NAME_LABEL;
+	public static String VALUE_LABEL;
+	public static String WEB_CONT_PAGE_COMP_LABEL;
+	public static String CHOOSE_SERVLET_CLASS;
+	public static String NEW_SERVLET_WIZARD_PAGE_DESC;
+	public static String JAVA_CLASS_INHERIT_CHECKBOX_LABEL;
+	public static String WEB_CONT_PAGE_DESCRIPTION;
+	public static String JAVA_CLASS_INTERFACES_LABEL;
+	public static String WEBCONTENT;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, WEBUIMessages.class);
 	}
 
-	public static String getResourceString(String key, Object[] args) {
-		return INSTANCE.doGetResourceString(key, args);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.common.frameworks.internal.Messages#initializeBundle()
-	 */
-	protected void initializeBundle() {
-		try {
-			resourceBundle = ResourceBundle.getBundle("web_ui"); //$NON-NLS-1$
-		} catch (MissingResourceException x) {
-			// Do nothing
-		}
-	}
-
+	public static final String IMAGE_LOAD_ERROR = _0;
+	public static final String WEB_MODULE_WIZ_TITLE = _1;
+	public static final String WEB_VERSION_LBL = _2;
+	public static final String WEB_PROJECT_MAIN_PG_TITLE = _3;
+	public static final String WEB_PROJECT_MAIN_PG_DESC = _4;
+	public static final String EJB_PROJECT_LBL = _5;
+	public static final String WEB_FILE_LBL = _6;
+	public static final String WEB_IMPORT_MAIN_PG_DESC = _7;
+	public static final String WEB_IMPORT_MAIN_PG_TITLE = _8;
+	public static final String WEB_EXPORT_MAIN_PG_TITLE = _9;
+	public static final String WEB_EXPORT_MAIN_PG_DESC = _10;
+	public static final String WEB_IMPORT_CONTEXT_ROOT = _11;
+	public static final String WEB_CONVERT_MAIN_PG_DESC = _12;
+	public static final String WEB_CONVERT_MAIN_PG_TITLE = _13;
+	public static final String WEB_IMPORT_WEB_LIB_PG_TITLE = _14;
+	public static final String WEB_IMPORT_WEB_LIB_PG_DESC = _15;
+	public static final String WAR_IMPORT_SELECT_ALL_LIBS_BUTTON = _16;
+	public static final String WAR_IMPORT_DESELECT_ALL_LIBS_BUTTON = _17;
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizard.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizard.java
index e810916..40f2735 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizard.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizard.java
@@ -51,7 +51,7 @@
 	 *      org.eclipse.jface.viewers.IStructuredSelection)
 	 */
 	public void doInit(IWorkbench workbench, IStructuredSelection selection) {
-		setWindowTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_CONVERT_MAIN_PG_TITLE)); //$NON-NLS-1$
+		setWindowTitle(WEBUIMessages.WEB_CONVERT_MAIN_PG_TITLE); //$NON-NLS-1$
 	}
 
 	/*
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizardPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizardPage.java
index f63892d..4277492 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizardPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/ConvertToWebComponentTypeWizardPage.java
@@ -24,8 +24,8 @@
 		// TODO use flexible project
 		//super(model, pageName);
 		super(model, pageName);
-		setDescription(WEBUIMessages.getResourceString(WEBUIMessages.WEB_CONVERT_MAIN_PG_DESC)); //$NON-NLS-1$
-		setTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_CONVERT_MAIN_PG_TITLE)); //$NON-NLS-1$
+		setDescription(WEBUIMessages.WEB_CONVERT_MAIN_PG_DESC); //$NON-NLS-1$
+		setTitle(WEBUIMessages.WEB_CONVERT_MAIN_PG_TITLE); //$NON-NLS-1$
 	}
 
 	/*
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/IWebWizardConstants.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/IWebWizardConstants.java
index 9e445a6..fceda44 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/IWebWizardConstants.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/IWebWizardConstants.java
@@ -15,74 +15,74 @@
 public interface IWebWizardConstants {
 	
 	// AddServletWizard
-	public final static String ADD_SERVLET_WIZARD_WINDOW_TITLE = WEBUIMessages.getResourceString("ADD_SERVLET_WIZARD_WINDOW_TITLE"); //$NON-NLS-1$
-	public final static String ADD_SERVLET_WIZARD_PAGE_TITLE = WEBUIMessages.getResourceString("ADD_SERVLET_WIZARD_PAGE_TITLE"); //$NON-NLS-1$
-	public final static String ADD_SERVLET_WIZARD_PAGE_DESC = WEBUIMessages.getResourceString("ADD_SERVLET_WIZARD_PAGE_DESC"); //$NON-NLS-1$
+	public final static String ADD_SERVLET_WIZARD_WINDOW_TITLE = WEBUIMessages.ADD_SERVLET_WIZARD_WINDOW_TITLE;
+	public final static String ADD_SERVLET_WIZARD_PAGE_TITLE = WEBUIMessages.ADD_SERVLET_WIZARD_PAGE_TITLE;
+	public final static String ADD_SERVLET_WIZARD_PAGE_DESC = WEBUIMessages.ADD_SERVLET_WIZARD_PAGE_DESC;
 
-	public final static String DEFAULT_PACKAGE = WEBUIMessages.getResourceString("DEFAULT_PACKAGE"); //$NON-NLS-1$
-	public final static String SELECT_CLASS_TITLE = WEBUIMessages.getResourceString("SELECT_CLASS_TITLE"); //$NON-NLS-1$
-	public final static String MAP_CLASS_NAME_TO_CLASS_ERROR_MSG = WEBUIMessages.getResourceString("MAP_CLASS_NAME_TO_CLASS_ERROR_MSG"); //$NON-NLS-1$
-	public final static String EMPTY_LIST_MSG = WEBUIMessages.getResourceString("EMPTY_LIST_MSG"); //$NON-NLS-1$
-	public final static String ADD_LABEL = WEBUIMessages.getResourceString("ADD_LABEL"); //$NON-NLS-1$
-	public final static String USE_EXISTING_SERVLET_CLASS = WEBUIMessages.getResourceString("USE_EXISTING_SERVLET_CLASS"); //$NON-NLS-1$
-	public final static String INIT_PARAM_LABEL = WEBUIMessages.getResourceString("INIT_PARAM_LABEL"); //$NON-NLS-1$
-	public final static String URL_MAPPINGS_LABEL = WEBUIMessages.getResourceString("URL_MAPPINGS_LABEL"); //$NON-NLS-1$
-	public final static String CHOOSE_SERVLET_CLASS = WEBUIMessages.getResourceString("CHOOSE_SERVLET_CLASS"); //$NON-NLS-1$
+	public final static String DEFAULT_PACKAGE = WEBUIMessages.DEFAULT_PACKAGE;
+	public final static String SELECT_CLASS_TITLE = WEBUIMessages.SELECT_CLASS_TITLE;
+	public final static String MAP_CLASS_NAME_TO_CLASS_ERROR_MSG = WEBUIMessages.MAP_CLASS_NAME_TO_CLASS_ERROR_MSG;
+	public final static String EMPTY_LIST_MSG = WEBUIMessages.EMPTY_LIST_MSG;
+	public final static String ADD_LABEL = WEBUIMessages.ADD_LABEL;
+	public final static String USE_EXISTING_SERVLET_CLASS = WEBUIMessages.USE_EXISTING_SERVLET_CLASS;
+	public final static String INIT_PARAM_LABEL = WEBUIMessages.INIT_PARAM_LABEL;
+	public final static String URL_MAPPINGS_LABEL = WEBUIMessages.URL_MAPPINGS_LABEL;
+	public final static String CHOOSE_SERVLET_CLASS = WEBUIMessages.CHOOSE_SERVLET_CLASS;
 	
 	// NewServletWizard
-	public final static String NEW_SERVLET_WIZARD_WINDOW_TITLE = WEBUIMessages.getResourceString("NEW_SERVLET_WIZARD_WINDOW_TITLE"); //$NON-NLS-1$
-	public final static String NEW_SERVLET_WIZARD_PAGE_TITLE = WEBUIMessages.getResourceString("NEW_SERVLET_WIZARD_PAGE_TITLE"); //$NON-NLS-1$
-	public final static String NEW_SERVLET_WIZARD_PAGE_DESC = WEBUIMessages.getResourceString("NEW_SERVLET_WIZARD_PAGE_DESC"); //$NON-NLS-1$
-	public final static String SERVLET_PACKAGE_LABEL = WEBUIMessages.getResourceString("SERVLET_PACKAGE_LABEL"); //$NON-NLS-1$
-	public final static String SERVLET_NAME_LABEL = WEBUIMessages.getResourceString("SERVLET_NAME_LABEL"); //$NON-NLS-1$
+	public final static String NEW_SERVLET_WIZARD_WINDOW_TITLE = WEBUIMessages.NEW_SERVLET_WIZARD_WINDOW_TITLE;
+	public final static String NEW_SERVLET_WIZARD_PAGE_TITLE = WEBUIMessages.NEW_SERVLET_WIZARD_PAGE_TITLE;
+	public final static String NEW_SERVLET_WIZARD_PAGE_DESC = WEBUIMessages.NEW_SERVLET_WIZARD_PAGE_DESC;
+	public final static String SERVLET_PACKAGE_LABEL = WEBUIMessages.SERVLET_PACKAGE_LABEL;
+	public final static String SERVLET_NAME_LABEL = WEBUIMessages.SERVLET_NAME_LABEL;
 
 	
 	// common
-	public final static String ADD_BUTTON_LABEL = WEBUIMessages.getResourceString("ADD_BUTTON_LABEL"); //$NON-NLS-1$
-	public final static String REMOVE_BUTTON_LABEL = WEBUIMessages.getResourceString("REMOVE_BUTTON_LABEL"); //$NON-NLS-1$
-	public final static String URL_PATTERN_TITLE = WEBUIMessages.getResourceString("URL_PATTERN_TITLE"); //$NON-NLS-1$
-	public final static String URL_PATTERN_LABEL = WEBUIMessages.getResourceString("URL_PATTERN_LABEL"); //$NON-NLS-1$
-	public final static String FOLDER_LABEL = WEBUIMessages.getResourceString("FOLDER_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_PACKAGE_LABEL = WEBUIMessages.getResourceString("JAVA_PACKAGE_LABEL"); //$NON-NLS-1$
-	public final static String CLASS_NAME_LABEL = WEBUIMessages.getResourceString("CLASS_NAME_LABEL"); //$NON-NLS-1$
-	public final static String SUPERCLASS_LABEL = WEBUIMessages.getResourceString("SUPERCLASS_LABEL"); //$NON-NLS-1$
-	public final static String CONTAINER_SELECTION_DIALOG_TITLE = WEBUIMessages.getResourceString("CONTAINER_SELECTION_DIALOG_TITLE"); //$NON-NLS-1$
-	public final static String CONTAINER_SELECTION_DIALOG_DESC = WEBUIMessages.getResourceString("CONTAINER_SELECTION_DIALOG_DESC"); //$NON-NLS-1$
-	public final static String CONTAINER_SELECTION_DIALOG_VALIDATOR_MESG = WEBUIMessages.getResourceString("CONTAINER_SELECTION_DIALOG_VALIDATOR_MESG"); //$NON-NLS-1$
-	public final static String PACKAGE_SELECTION_DIALOG_TITLE = WEBUIMessages.getResourceString("PACKAGE_SELECTION_DIALOG_TITLE"); //$NON-NLS-1$
-	public final static String PACKAGE_SELECTION_DIALOG_DESC = WEBUIMessages.getResourceString("PACKAGE_SELECTION_DIALOG_DESC"); //$NON-NLS-1$
-	public final static String PACKAGE_SELECTION_DIALOG_MSG_NONE = WEBUIMessages.getResourceString("PACKAGE_SELECTION_DIALOG_MSG_NONE"); //$NON-NLS-1$
-	public final static String SUPERCLASS_SELECTION_DIALOG_TITLE = WEBUIMessages.getResourceString("SUPERCLASS_SELECTION_DIALOG_TITLE"); //$NON-NLS-1$
-	public final static String SUPERCLASS_SELECTION_DIALOG_DESC = WEBUIMessages.getResourceString("SUPERCLASS_SELECTION_DIALOG_DESC"); //$NON-NLS-1$
-	public final static String INTERFACE_SELECTION_DIALOG_TITLE = WEBUIMessages.getResourceString("INTERFACE_SELECTION_DIALOG_TITLE"); //$NON-NLS-1$
-	public final static String INTERFACE_SELECTION_DIALOG_DESC = WEBUIMessages.getResourceString("INTERFACE_SELECTION_DIALOG_DESC"); //$NON-NLS-1$
-	public final static String INTERFACE_SELECTION_DIALOG_MSG_NONE = WEBUIMessages.getResourceString("INTERFACE_SELECTION_DIALOG_MSG_NONE"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_MODIFIERS_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_MODIFIERS_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_INTERFACES_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_INTERFACES_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_METHOD_STUBS_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_METHOD_STUBS_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_PUBLIC_CHECKBOX_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_PUBLIC_CHECKBOX_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_ABSTRACT_CHECKBOX_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_ABSTRACT_CHECKBOX_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_FINAL_CHECKBOX_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_FINAL_CHECKBOX_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_CONSTRUCTOR_CHECKBOX_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_CONSTRUCTOR_CHECKBOX_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_MAIN_CHECKBOX_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_MAIN_CHECKBOX_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_INHERIT_CHECKBOX_LABEL = WEBUIMessages.getResourceString("JAVA_CLASS_INHERIT_CHECKBOX_LABEL"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_BROWER_DIALOG_TITLE = WEBUIMessages.getResourceString("JAVA_CLASS_BROWER_DIALOG_TITLE"); //$NON-NLS-1$
-	public final static String JAVA_CLASS_BROWER_DIALOG_MESSAGE = WEBUIMessages.getResourceString("JAVA_CLASS_BROWER_DIALOG_MESSAGE"); //$NON-NLS-1$
+	public final static String ADD_BUTTON_LABEL = WEBUIMessages.ADD_BUTTON_LABEL;
+	public final static String REMOVE_BUTTON_LABEL = WEBUIMessages.REMOVE_BUTTON_LABEL;
+	public final static String URL_PATTERN_TITLE = WEBUIMessages.URL_PATTERN_TITLE;
+	public final static String URL_PATTERN_LABEL = WEBUIMessages.URL_PATTERN_LABEL;
+	public final static String FOLDER_LABEL = WEBUIMessages.FOLDER_LABEL;
+	public final static String JAVA_PACKAGE_LABEL = WEBUIMessages.JAVA_PACKAGE_LABEL;
+	public final static String CLASS_NAME_LABEL = WEBUIMessages.CLASS_NAME_LABEL;
+	public final static String SUPERCLASS_LABEL = WEBUIMessages.SUPERCLASS_LABEL;
+	public final static String CONTAINER_SELECTION_DIALOG_TITLE = WEBUIMessages.CONTAINER_SELECTION_DIALOG_TITLE;
+	public final static String CONTAINER_SELECTION_DIALOG_DESC = WEBUIMessages.CONTAINER_SELECTION_DIALOG_DESC;
+	public final static String CONTAINER_SELECTION_DIALOG_VALIDATOR_MESG = WEBUIMessages.CONTAINER_SELECTION_DIALOG_VALIDATOR_MESG;
+	public final static String PACKAGE_SELECTION_DIALOG_TITLE = WEBUIMessages.PACKAGE_SELECTION_DIALOG_TITLE;
+	public final static String PACKAGE_SELECTION_DIALOG_DESC = WEBUIMessages.PACKAGE_SELECTION_DIALOG_DESC;
+	public final static String PACKAGE_SELECTION_DIALOG_MSG_NONE = WEBUIMessages.PACKAGE_SELECTION_DIALOG_MSG_NONE;
+	public final static String SUPERCLASS_SELECTION_DIALOG_TITLE = WEBUIMessages.SUPERCLASS_SELECTION_DIALOG_TITLE;
+	public final static String SUPERCLASS_SELECTION_DIALOG_DESC = WEBUIMessages.SUPERCLASS_SELECTION_DIALOG_DESC;
+	public final static String INTERFACE_SELECTION_DIALOG_TITLE = WEBUIMessages.INTERFACE_SELECTION_DIALOG_TITLE;
+	public final static String INTERFACE_SELECTION_DIALOG_DESC = WEBUIMessages.INTERFACE_SELECTION_DIALOG_DESC;
+	public final static String INTERFACE_SELECTION_DIALOG_MSG_NONE = WEBUIMessages.INTERFACE_SELECTION_DIALOG_MSG_NONE;
+	public final static String JAVA_CLASS_MODIFIERS_LABEL = WEBUIMessages.JAVA_CLASS_MODIFIERS_LABEL;
+	public final static String JAVA_CLASS_INTERFACES_LABEL = WEBUIMessages.JAVA_CLASS_INTERFACES_LABEL;
+	public final static String JAVA_CLASS_METHOD_STUBS_LABEL = WEBUIMessages.JAVA_CLASS_METHOD_STUBS_LABEL;
+	public final static String JAVA_CLASS_PUBLIC_CHECKBOX_LABEL = WEBUIMessages.JAVA_CLASS_PUBLIC_CHECKBOX_LABEL;
+	public final static String JAVA_CLASS_ABSTRACT_CHECKBOX_LABEL = WEBUIMessages.JAVA_CLASS_ABSTRACT_CHECKBOX_LABEL;
+	public final static String JAVA_CLASS_FINAL_CHECKBOX_LABEL = WEBUIMessages.JAVA_CLASS_FINAL_CHECKBOX_LABEL;
+	public final static String JAVA_CLASS_CONSTRUCTOR_CHECKBOX_LABEL = WEBUIMessages.JAVA_CLASS_CONSTRUCTOR_CHECKBOX_LABEL;
+	public final static String JAVA_CLASS_MAIN_CHECKBOX_LABEL = WEBUIMessages.JAVA_CLASS_MAIN_CHECKBOX_LABEL;
+	public final static String JAVA_CLASS_INHERIT_CHECKBOX_LABEL = WEBUIMessages.JAVA_CLASS_INHERIT_CHECKBOX_LABEL;
+	public final static String JAVA_CLASS_BROWER_DIALOG_TITLE = WEBUIMessages.JAVA_CLASS_BROWER_DIALOG_TITLE;
+	public final static String JAVA_CLASS_BROWER_DIALOG_MESSAGE = WEBUIMessages.JAVA_CLASS_BROWER_DIALOG_MESSAGE;
 	
-	public final static String NAME_LABEL = WEBUIMessages.getResourceString("NAME_LABEL"); //$NON-NLS-1$
-	public final static String DESCRIPTION_LABEL = WEBUIMessages.getResourceString("DESCRIPTION_LABEL"); //$NON-NLS-1$
-	public final static String VALUE_LABEL = WEBUIMessages.getResourceString("VALUE_LABEL"); //$NON-NLS-1$
+	public final static String NAME_LABEL = WEBUIMessages.NAME_LABEL;
+	public final static String DESCRIPTION_LABEL = WEBUIMessages.DESCRIPTION_LABEL;
+	public final static String VALUE_LABEL = WEBUIMessages.VALUE_LABEL;
 	public final static String EMPTY_STRING = ""; //$NON-NLS-1$
-	public final static String BROWSE_BUTTON_LABEL = WEBUIMessages.getResourceString("BROWSE_BUTTON_LABEL"); //$NON-NLS-1$
-	public static final String REMOVE_BUTTON = WEBUIMessages.getResourceString("REMOVE_BUTTON"); //$NON-NLS-1$
+	public final static String BROWSE_BUTTON_LABEL = WEBUIMessages.BROWSE_BUTTON_LABEL;
+	public static final String REMOVE_BUTTON = WEBUIMessages.REMOVE_BUTTON;
     
-	public final static String NEW_JAVA_CLASS_DESTINATION_WIZARD_PAGE_DESC = WEBUIMessages.getResourceString("NEW_JAVA_CLASS_DESTINATION_WIZARD_PAGE_DESC"); //$NON-NLS-1$
-	public final static String NEW_JAVA_CLASS_OPTIONS_WIZARD_PAGE_DESC = WEBUIMessages.getResourceString("NEW_JAVA_CLASS_OPTIONS_WIZARD_PAGE_DESC"); //$NON-NLS-1$
+	public final static String NEW_JAVA_CLASS_DESTINATION_WIZARD_PAGE_DESC = WEBUIMessages.NEW_JAVA_CLASS_DESTINATION_WIZARD_PAGE_DESC;
+	public final static String NEW_JAVA_CLASS_OPTIONS_WIZARD_PAGE_DESC = WEBUIMessages.NEW_JAVA_CLASS_OPTIONS_WIZARD_PAGE_DESC;
 	
-	public final static String ImportWARAction_UI_ = WEBUIMessages.getResourceString("ImportWARAction_UI_"); //$NON-NLS-1$
-	public final static String ExportWARAction_UI_ = WEBUIMessages.getResourceString("ExportWARAction_UI_"); //$NON-NLS-1$
+	public final static String ImportWARAction_UI_ = WEBUIMessages.ImportWARAction_UI_;
+	public final static String ExportWARAction_UI_ = WEBUIMessages.ExportWARAction_UI_;
 	
-	public final static String NO_WEB_PROJECTS = WEBUIMessages.getResourceString("NO_WEB_PROJECTS"); //$NON-NLS-1$
+	public final static String NO_WEB_PROJECTS = WEBUIMessages.NO_WEB_PROJECTS;
 	
-	public static final String SERVLETS = WEBUIMessages.getResourceString("SERVLETS"); //$NON-NLS-1$
+	public static final String SERVLETS = WEBUIMessages.SERVLETS;
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizard.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizard.java
index 4961a00..5d448cf 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizard.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizard.java
@@ -28,6 +28,11 @@
  * This wizard is not exposed as API to be extended.
  * </p>
  */
+
+/**
+ * @deprecated
+ * @see WebProjectWizard
+ */
 public class WebComponentCreationWizard extends J2EEComponentCreationWizard implements IExecutableExtension, INewWizard {
 	
 	/**
@@ -69,7 +74,7 @@
 	 * 
 	 */
 	protected void doInit() {
-		setWindowTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_MODULE_WIZ_TITLE));
+		setWindowTitle(WEBUIMessages.WEB_MODULE_WIZ_TITLE);
 		setDefaultPageImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.WEB_PROJECT_WIZARD_BANNER));
 		preFillSelectedEARProject();
 	} 
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizardPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizardPage.java
index 76c089f..88e831b 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizardPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentCreationWizardPage.java
@@ -44,8 +44,8 @@
 	 */
 	public WebComponentCreationWizardPage(IDataModel model, String pageName) {
 		super(model, pageName);
-		setTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_PROJECT_MAIN_PG_TITLE));
-		setDescription(WEBUIMessages.getResourceString(WEBUIMessages.WEB_PROJECT_MAIN_PG_DESC));
+		setTitle(WEBUIMessages.WEB_PROJECT_MAIN_PG_TITLE);
+		setDescription(WEBUIMessages.WEB_PROJECT_MAIN_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.WEB_PROJECT_WIZARD_BANNER));
 	}
 
@@ -57,7 +57,7 @@
 	protected void addToAdvancedComposite(Composite advanced) {
 		super.addToAdvancedComposite(advanced);
 		contextRootLabel = new Label(advanced, SWT.NULL);
-		contextRootLabel.setText(WEBUIMessages.getResourceString(WEBUIMessages.WEB_IMPORT_CONTEXT_ROOT));
+		contextRootLabel.setText(WEBUIMessages.WEB_IMPORT_CONTEXT_ROOT);
 		GridData data = new GridData();
 		contextRootLabel.setLayoutData(data);
 		// set up context root entry field
@@ -76,7 +76,7 @@
     protected void createWebContentFolderComposite(Composite parent) {
 		
         Label label = new Label(parent, SWT.NONE);
-        label.setText(WEBUIMessages.getResourceString(WEBUIMessages.WEBCONTENT));
+        label.setText(WEBUIMessages.WEBCONTENT);
         GridData data = new GridData();      
         label.setLayoutData(data);
         // set up project name entry field
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentExportPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentExportPage.java
index bbe1151..814ffe4 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentExportPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentExportPage.java
@@ -25,8 +25,8 @@
 	 */
 	public WebComponentExportPage(IDataModel model, String pageName, IStructuredSelection selection) {
 		super(model, pageName, selection);
-		setTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_EXPORT_MAIN_PG_TITLE));
-		setDescription(WEBUIMessages.getResourceString(WEBUIMessages.WEB_EXPORT_MAIN_PG_DESC));
+		setTitle(WEBUIMessages.WEB_EXPORT_MAIN_PG_TITLE);
+		setDescription(WEBUIMessages.WEB_EXPORT_MAIN_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.WEB_EXPORT_WIZARD_BANNER));
 
 	}
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportPage.java
index 01401fb..c762280 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportPage.java
@@ -37,14 +37,14 @@
 	 */
 	public WebComponentImportPage(IDataModel model, String pageName) {
 		super(model, pageName);
-		setTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_IMPORT_MAIN_PG_TITLE));
-		setDescription(WEBUIMessages.getResourceString(WEBUIMessages.WEB_IMPORT_MAIN_PG_DESC));
+		setTitle(WEBUIMessages.WEB_IMPORT_MAIN_PG_TITLE);
+		setDescription(WEBUIMessages.WEB_IMPORT_MAIN_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.WEB_IMPORT_WIZARD_BANNER));
 
 	}
 
 	protected String getFileImportLabel() {
-		return WEBUIMessages.getResourceString(WEBUIMessages.WEB_FILE_LBL);
+		return WEBUIMessages.WEB_FILE_LBL;
 	}
 
 	protected String[] getFilterExpression() {
@@ -52,7 +52,7 @@
 	}
 
 	protected String getProjectImportLabel() {
-		return WEBUIMessages.getResourceString(WEBUIMessages.EJB_PROJECT_LBL);
+		return WEBUIMessages.EJB_PROJECT_LBL;
 	}
 
 	protected void createAnnotationsStandaloneGroup(Composite composite) {
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWebLibsPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWebLibsPage.java
index 4deb430..a3a0857 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWebLibsPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWebLibsPage.java
@@ -57,8 +57,8 @@
 	 */
 	public WebComponentImportWebLibsPage(IDataModel model, String pageName) {
 		super(model, pageName);
-		setTitle(WEBUIMessages.getResourceString(WEBUIMessages.WEB_IMPORT_WEB_LIB_PG_TITLE));
-		setDescription(WEBUIMessages.getResourceString(WEBUIMessages.WEB_IMPORT_WEB_LIB_PG_DESC));
+		setTitle(WEBUIMessages.WEB_IMPORT_WEB_LIB_PG_TITLE);
+		setDescription(WEBUIMessages.WEB_IMPORT_WEB_LIB_PG_DESC);
 		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.WEB_IMPORT_WIZARD_BANNER));
 	}
 
@@ -144,7 +144,7 @@
 		buttonGroup.setLayoutData(new GridData(GridData.FILL_BOTH));
 
 		selectAllButton = new Button(buttonGroup, SWT.PUSH);
-		selectAllButton.setText(WEBUIMessages.getResourceString(WEBUIMessages.WAR_IMPORT_SELECT_ALL_LIBS_BUTTON));
+		selectAllButton.setText(WEBUIMessages.WAR_IMPORT_SELECT_ALL_LIBS_BUTTON);
 		GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
 		gd.horizontalSpan = 1;
 		gd.heightHint = 22;
@@ -157,7 +157,7 @@
 		});
 
 		deselectAllButton = new Button(buttonGroup, SWT.PUSH);
-		deselectAllButton.setText(WEBUIMessages.getResourceString(WEBUIMessages.WAR_IMPORT_DESELECT_ALL_LIBS_BUTTON));
+		deselectAllButton.setText(WEBUIMessages.WAR_IMPORT_DESELECT_ALL_LIBS_BUTTON);
 		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
 		gd.horizontalSpan = 2;
 		gd.heightHint = 22;
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWizard.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWizard.java
index 1e90680..60ab7c7 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWizard.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/wizard/WebComponentImportWizard.java
@@ -58,7 +58,7 @@
 	 */
 	public void doAddPages() {
 		addPage(new WebComponentImportPage(getDataModel(), MAIN_PG));
-		addPage(new WebComponentImportWebLibsPage(getDataModel(), MAIN_PG));
+		addPage(new WebComponentImportWebLibsPage(getDataModel(), WEB_LIBS_PG));
 	}
 
 	/**
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.java
index 81a3200..6dff9e3 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.java
@@ -11,222 +11,86 @@
 
 package org.eclipse.jst.servlet.ui.project.facet;
 
-import org.eclipse.jst.j2ee.ui.project.facet.EarSelectionPanel;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEModuleFacetInstallPage;
 import org.eclipse.jst.j2ee.web.project.facet.IWebFacetInstallDataModelProperties;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.ModifyEvent;
-import org.eclipse.swt.events.ModifyListener;
-import org.eclipse.swt.graphics.Color;
-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.Event;
+import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Listener;
 import org.eclipse.swt.widgets.Text;
-import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
-import org.eclipse.wst.common.project.facet.ui.AbstractFacetWizardPage;
 
 /**
  * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
  */
+public final class WebFacetInstallPage extends J2EEModuleFacetInstallPage implements IWebFacetInstallDataModelProperties {
+	private Label contextRootLabel;
+	private Text contextRoot;
+	private Label contentDirLabel;
+	private Text contentDir;
+	private Text sourceDir;
+	private Label sourceDirLabel;
 
-public final class WebFacetInstallPage 
+	public WebFacetInstallPage() {
+		super("web.facet.install.page"); //$NON-NLS-1$
+		setTitle(Resources.pageTitle);
+		setDescription(Resources.pageDescription);
+	}
 
-    extends AbstractFacetWizardPage
-    
-{
-    private IDataModel config;
-    private EarSelectionPanel earPanel;
-    private Label contextRootLabel;
-    private Text contextRoot;
-    private boolean contextRootModified; 
-    private Label contentDirLabel;
-    private Text contentDir;
-    private Button createWebInfSrc;
-    
-    public WebFacetInstallPage() 
-    {
-        super( "web.facet.install.page" );
-        
-        setTitle( Resources.pageTitle );
-        setDescription( Resources.pageDescription );
-    }
-    
-    public void createControl( final Composite parent ) 
-    {
-        final Composite composite = new Composite( parent, SWT.NONE );
-        composite.setLayout( new GridLayout( 1, false ) );
-        
-        this.earPanel = new EarSelectionPanel( composite, SWT.NONE );
-        this.earPanel.setLayoutData( gdhfill() );
-        
-        this.earPanel.addListener( new Listener()
-        {
-            public void handleEvent( final Event event ) 
-            {
-                config.setStringProperty(IWebFacetInstallDataModelProperties.EAR_PROJECT_NAME,earPanel.getEarProjectName() );
-                validate();
-            }
-        } );
-        
-        this.contextRootLabel = new Label( composite, SWT.NONE );
-        this.contextRootLabel.setText( Resources.contextRootLabel );
-        this.contextRootLabel.setLayoutData( gdhfill() );
-        
-        this.contextRoot = new Text( composite, SWT.BORDER );
-        this.contextRoot.setText( "" );
-        this.contextRoot.setLayoutData( gdhfill() );
-        this.contextRoot.setData( "label", this.contextRootLabel );
+	protected Composite createTopLevelComposite(final Composite parent) {
+		final Composite composite = new Composite(parent, SWT.NONE);
+		composite.setLayout(new GridLayout(1, false));
 
-        this.contextRoot.addModifyListener( new ModifyListener()
-        {
-            public void modifyText( final ModifyEvent event ) 
-            {
-                WebFacetInstallPage.this.contextRootModified = true;
-                validate();
-            }
-        } );
-        
-        this.contentDirLabel = new Label( composite, SWT.NONE );
-        this.contentDirLabel.setText( Resources.contentDirLabel );
-        this.contentDirLabel.setLayoutData( gdhfill() );
-        
-        this.contentDir = new Text( composite, SWT.BORDER );
-        this.contentDir.setText( config.getStringProperty(IWebFacetInstallDataModelProperties.CONTENT_DIR));
-        this.contentDir.setLayoutData( gdhfill() );
-        this.contentDir.setData( "label", this.contentDirLabel );
+		//setupEarControl(composite);
 
-        this.contentDir.addModifyListener( new ModifyListener()
-        {
-            public void modifyText( final ModifyEvent event ) 
-            {
-                validate();
-            }
-        } );
-        
-        this.createWebInfSrc = new Button( composite, SWT.CHECK );
-        this.createWebInfSrc.setText( Resources.createWebinfSrcLabel );
-        
-        setControl( composite );
-    }
-    
-    public void setConfig( final Object config ) 
-    {
-        this.config = (IDataModel) config;
-    }
+		this.contextRootLabel = new Label(composite, SWT.NONE);
+		this.contextRootLabel.setText(Resources.contextRootLabel);
+		this.contextRootLabel.setLayoutData(gdhfill());
 
-    public void transferStateToConfig() 
-    {
-        if( this.earPanel.getAddToEar() )
-        {
-            this.config.setStringProperty(IWebFacetInstallDataModelProperties.EAR_PROJECT_NAME, this.earPanel.getEarProjectName() );
-        }
-        
-        
-        if( this.contextRootModified )
-        {
-        	this.config.setStringProperty(IWebFacetInstallDataModelProperties.CONTEXT_ROOT, this.contextRoot.getText() );
-        }
-        else
-        {
-        	this.config.setStringProperty(IWebFacetInstallDataModelProperties.CONTEXT_ROOT, this.context.getProjectName() );
-        }
-        
-        this.config.setStringProperty(IWebFacetInstallDataModelProperties.CONTENT_DIR, this.contentDir.getText() );
-        this.config.setBooleanProperty(IWebFacetInstallDataModelProperties.CREATE_WEB_INF_SRC,this.createWebInfSrc.getSelection() );
-    }
-    
-    public void setVisible( final boolean visible )
-    {
-        if( visible )
-        {
-            if( ! this.contextRootModified )
-            {
-                this.contextRoot.setText( this.context.getProjectName() );
-                this.contextRootModified = false;
-            }
-        }
-        
-        super.setVisible( visible );
-    }
-    
-    private void validate()
-    {
-        boolean valid = true;
-        
-        if( ! validateNotEmpty( this.contextRoot, Resources.contextRootLabel, Resources.contentDirLabelInvalid ) ||
-            ! validateNotEmpty( this.contentDir, Resources.contentDirLabel, Resources.contentDirLabelInvalid ) )
-        {
-            valid = false;
-        }
-        
-        if( this.earPanel.getAddToEar() && 
-            this.earPanel.getEarProjectName() == null )
-        {
-            valid = false;
-        }
-        
-        this.setPageComplete( valid );
-    }
-    
-    private static boolean validateNotEmpty( final Text textbox,
-                                             final String validLabel,
-                                             final String invalidLabel )
-    {
-        final Label label = (Label) textbox.getData( "label" );
-        
-        final boolean valid;
-        final String text;
-        final Color color;
-        
-        if( textbox.getText().trim().length() == 0 )
-        {
-            text = invalidLabel;
-            color = label.getDisplay().getSystemColor( SWT.COLOR_RED );
-            
-            valid = false;
-        }
-        else
-        {
-            text = validLabel;
-            color = null;
-            
-            valid = true;
-        }
-        
-        label.setText( text );
-        label.setForeground( color );
-        
-        return valid;
-    }
-    
-    private static GridData gdhfill()
-    {
-        return new GridData( GridData.FILL_HORIZONTAL );
-    }
+		this.contextRoot = new Text(composite, SWT.BORDER);
+		this.contextRoot.setLayoutData(gdhfill());
+		this.contextRoot.setData("label", this.contextRootLabel); //$NON-NLS-1$
+		synchHelper.synchText(contextRoot, CONTEXT_ROOT, new Control[]{contextRootLabel});
 
-    private static final class Resources
-    
-        extends NLS
-        
-    {
-        public static String pageTitle;
-        public static String pageDescription;
-        public static String contextRootLabel;
-        public static String contextRootLabelInvalid;
-        public static String contentDirLabel;
-        public static String contentDirLabelInvalid;
-        public static String createWebinfSrcLabel;
-        
-        static
-        {
-            initializeMessages( WebFacetInstallPage.class.getName(), 
-                                Resources.class );
-        }
-    }
-    
-}
+		this.contentDirLabel = new Label(composite, SWT.NONE);
+		this.contentDirLabel.setText(Resources.contentDirLabel);
+		this.contentDirLabel.setLayoutData(gdhfill());
 
+		this.contentDir = new Text(composite, SWT.BORDER);
+		this.contentDir.setLayoutData(gdhfill());
+		this.contentDir.setData("label", this.contentDirLabel); //$NON-NLS-1$
+		synchHelper.synchText(contentDir, CONFIG_FOLDER, null);
+		
+		this.sourceDirLabel = new Label(composite, SWT.NONE);
+		this.sourceDirLabel.setText(Resources.sourceDirLabel);
+		this.sourceDirLabel.setLayoutData(gdhfill());
+		
+		this.sourceDir = new Text(composite, SWT.BORDER);
+		this.sourceDir.setLayoutData(gdhfill());
+		this.sourceDir.setData("label", this.sourceDirLabel); //$NON-NLS-1$
+		synchHelper.synchText(sourceDir, SOURCE_FOLDER, null);
+
+		return composite;
+	}
+
+	protected String[] getValidationPropertyNames() {
+		return new String[]{EAR_PROJECT_NAME, CONTEXT_ROOT, CONFIG_FOLDER, SOURCE_FOLDER};
+	}
+
+	private static final class Resources extends NLS {
+		public static String pageTitle;
+		public static String pageDescription;
+		public static String contextRootLabel;
+		public static String contextRootLabelInvalid;
+		public static String contentDirLabel;
+		public static String contentDirLabelInvalid;
+		public static String sourceDirLabel;
+
+		static {
+			initializeMessages(WebFacetInstallPage.class.getName(), Resources.class);
+		}
+	}
+
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.properties b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.properties
index 151173c..997fa4d 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.properties
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebFacetInstallPage.properties
@@ -1,7 +1,7 @@
 pageTitle = Web Module
 pageDescription = Configure web module settings.
-contextRootLabel = Context Root\:
-contextRootLabelInvalid = Context Root (invalid)\:
-contentDirLabel = Content Directory\:
-contentDirLabelInvalid = Content Directory (invalid)\:
-createWebinfSrcLabel = Add WEB-INF/src directory to source path.
+contextRootLabel = Context Root:
+contextRootLabelInvalid = Context Root (invalid):
+contentDirLabel = Content Directory:
+contentDirLabelInvalid = Content Directory (invalid):
+sourceDirLabel = Java Source Directory:
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectFirstPage.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectFirstPage.java
new file mode 100644
index 0000000..35ad4c6
--- /dev/null
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectFirstPage.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jst.servlet.ui.project.facet;
+
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPlugin;
+import org.eclipse.jst.j2ee.internal.plugin.J2EEUIPluginIcons;
+import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
+import org.eclipse.jst.j2ee.internal.wizard.J2EEComponentFacetCreationWizardPage;
+import org.eclipse.jst.servlet.ui.internal.plugin.WEBUIMessages;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class WebProjectFirstPage extends J2EEComponentFacetCreationWizardPage {
+
+	public WebProjectFirstPage(IDataModel model, String pageName) {
+		super(model, pageName);
+		setTitle(WEBUIMessages.WEB_PROJECT_MAIN_PG_TITLE);
+		setDescription(WEBUIMessages.WEB_PROJECT_MAIN_PG_DESC);
+		setImageDescriptor(J2EEUIPlugin.getDefault().getImageDescriptor(J2EEUIPluginIcons.WEB_PROJECT_WIZARD_BANNER));
+		setInfopopID("org.eclipse.jst.j2ee.ui.webw1000"); //$NON-NLS-1$
+	}
+
+	protected String getModuleFacetID() {
+		return J2EEProjectUtilities.DYNAMIC_WEB;
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectWizard.java b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectWizard.java
index 2acf733..6596678 100644
--- a/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectWizard.java
+++ b/plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/project/facet/WebProjectWizard.java
@@ -1,50 +1,56 @@
-/******************************************************************************
- * Copyright (c) 2005 BEA Systems, Inc.
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- *
+ * 
  * Contributors:
- *    Konstantin Komissarchik - initial API and implementation
- ******************************************************************************/
-
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.jst.servlet.ui.project.facet;
 
 import java.net.URL;
 
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.jst.j2ee.internal.web.archive.operations.WebFacetProjectCreationDataModelProvider;
+import org.eclipse.jst.servlet.ui.internal.plugin.WEBUIMessages;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
 import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
-import org.eclipse.wst.common.project.facet.ui.FacetedProjectWizard;
+import org.eclipse.wst.web.ui.internal.wizards.NewProjectDataModelFacetWizard;
 import org.osgi.framework.Bundle;
 
-/**
- * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
- */
+public class WebProjectWizard extends NewProjectDataModelFacetWizard {
 
-public final class WebProjectWizard 
+	public WebProjectWizard(IDataModel model) {
+		super(model);
+		setWindowTitle(WEBUIMessages.WEB_MODULE_WIZ_TITLE);
+	}
+	
+	public WebProjectWizard() {
+		super();
+		setWindowTitle(WEBUIMessages.WEB_MODULE_WIZ_TITLE);
+	}
+	
+	protected IDataModel createDataModel() {
+		return DataModelFactory.createDataModel(new WebFacetProjectCreationDataModelProvider());
+	}
 
-    extends FacetedProjectWizard 
-    
-{
-    protected IFacetedProjectTemplate getTemplate()
-    {
-        return ProjectFacetsManager.getTemplate( "template.jst.web" );
-    }
+	protected IFacetedProjectTemplate getTemplate() {
+		return ProjectFacetsManager.getTemplate("template.jst.web"); //$NON-NLS-1$
+	}
 
-    protected String getPageDescription()
-    {
-        return "Create a Web project in the workspace or at an external location.";
-    }
-    
-    protected ImageDescriptor getDefaultPageImageDescriptor()
-    {
-        final Bundle bundle = Platform.getBundle( "org.eclipse.jst.servlet.ui" );
-        final URL url = bundle.getEntry( "icons/full/ctool16/web-wiz-banner.gif" );
-
-        return ImageDescriptor.createFromURL( url );
-    }
-    
+	protected IWizardPage createFirstPage() {
+		return new WebProjectFirstPage(model, "first.page"); //$NON-NLS-1$
+	}
+	
+	protected ImageDescriptor getDefaultPageImageDescriptor() {
+		final Bundle bundle = Platform.getBundle("org.eclipse.jst.servlet.ui"); //$NON-NLS-1$
+		final URL url = bundle.getEntry("icons/full/ctool16/web-wiz-banner.gif"); //$NON-NLS-1$
+		return ImageDescriptor.createFromURL(url);
+	}
 }
diff --git a/plugins/org.eclipse.wst.web.ui/.cvsignore b/plugins/org.eclipse.wst.web.ui/.cvsignore
index 6dffab5..fedbeef 100644
--- a/plugins/org.eclipse.wst.web.ui/.cvsignore
+++ b/plugins/org.eclipse.wst.web.ui/.cvsignore
@@ -3,3 +3,5 @@
 build.xml
 ui.jar
 uisrc.zip
+@dot
+src.zip
diff --git a/plugins/org.eclipse.wst.web.ui/META-INF/MANIFEST.MF b/plugins/org.eclipse.wst.web.ui/META-INF/MANIFEST.MF
index 8bfedf2..1381546 100644
--- a/plugins/org.eclipse.wst.web.ui/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.wst.web.ui/META-INF/MANIFEST.MF
@@ -3,7 +3,6 @@
 Bundle-Name: Simple Web UI Plug-in
 Bundle-SymbolicName: org.eclipse.wst.web.ui; singleton:=true
 Bundle-Version: 1.0.0
-Bundle-ClassPath: ui.jar
 Bundle-Activator: org.eclipse.wst.web.ui.internal.WSTWebUIPlugin
 Bundle-Vendor: Eclipse.org
 Bundle-Localization: plugin
@@ -17,5 +16,8 @@
  org.eclipse.wst.common.frameworks.ui,
  org.eclipse.wst.web,
  org.eclipse.jem.util,
- org.eclipse.wst.common.modulecore
+ org.eclipse.wst.common.modulecore,
+ org.eclipse.wst.common.project.facet.ui,
+ org.eclipse.wst.common.project.facet.core,
+ org.eclipse.wst.server.ui
 Eclipse-AutoStart: true
diff --git a/plugins/org.eclipse.wst.web.ui/build.properties b/plugins/org.eclipse.wst.web.ui/build.properties
index c267e9b..2b7383e 100644
--- a/plugins/org.eclipse.wst.web.ui/build.properties
+++ b/plugins/org.eclipse.wst.web.ui/build.properties
@@ -1,8 +1,9 @@
-source.ui.jar = static_web_ui/
-output.ui.jar = bin/
 bin.includes = plugin.xml,\
-               ui.jar,\
                icons/,\
                plugin.properties,\
                META-INF/,\
-               about.html
+               about.html,\
+               .
+jars.compile.order = .
+source.. = static_web_ui/
+output.. = bin/
diff --git a/plugins/org.eclipse.wst.web.ui/plugin.xml b/plugins/org.eclipse.wst.web.ui/plugin.xml
index c196a6c..78e53f7 100644
--- a/plugins/org.eclipse.wst.web.ui/plugin.xml
+++ b/plugins/org.eclipse.wst.web.ui/plugin.xml
@@ -13,9 +13,9 @@
             name="%StaticWebProject.name"
             icon="icons/full/ctool16/newwebprj_wiz.gif"
             category="org.eclipse.wst.web.ui"
-            class="org.eclipse.wst.web.ui.internal.wizards.SimpleWebModuleCreationWizard"
+            class="org.eclipse.wst.web.ui.internal.wizards.SimpleWebProjectWizard"
             project="true"
-            id="org.eclipse.wst.web.ui.internal.wizards.SimpleWebModuleCreation">
+            id="org.eclipse.wst.web.ui.internal.wizards.SimpleWebProjectWizard">
          <description>
             %StaticWebProject.description
          </description>
@@ -92,4 +92,12 @@
             id="org.eclipse.ui.simpleWebProjectNatureImage">
       </image>
    </extension>
+   
+   <extension point="org.eclipse.wst.common.project.facet.ui.wizard">
+    <wizard-pages facet="wst.web" version="1.0">
+      <install>
+        <page class="org.eclipse.wst.web.ui.internal.wizards.SimpleWebFacetInstallPage"/>
+      </install>
+    </wizard-pages>
+  </extension>
 </plugin>
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/DataModelFacetCreationWizardPage.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/DataModelFacetCreationWizardPage.java
new file mode 100644
index 0000000..160d8d9
--- /dev/null
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/DataModelFacetCreationWizardPage.java
@@ -0,0 +1,122 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.wst.web.ui.internal.wizards;
+
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+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.Label;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelPropertyDescriptor;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizardPage;
+import org.eclipse.wst.common.frameworks.internal.operations.IProjectCreationPropertiesNew;
+import org.eclipse.wst.common.frameworks.internal.ui.NewProjectGroup;
+import org.eclipse.wst.server.ui.ServerUIUtil;
+import org.eclipse.wst.web.internal.ResourceHandler;
+
+public class DataModelFacetCreationWizardPage extends DataModelWizardPage implements IFacetProjectCreationDataModelProperties {
+
+	protected static GridData gdhfill() {
+		return new GridData(GridData.FILL_HORIZONTAL);
+	}
+
+	protected Composite createTopLevelComposite(Composite parent) {
+		Composite top = new Composite(parent, SWT.NONE);
+		PlatformUI.getWorkbench().getHelpSystem().setHelp(top, getInfopopID());
+		top.setLayout(new GridLayout());
+		top.setLayoutData(new GridData(GridData.FILL_BOTH));
+		createProjectGroup(top);
+		Composite composite = new Composite(top, SWT.NONE);
+		composite.setLayoutData(gdhfill());
+		GridLayout layout = new GridLayout(3, false);
+		composite.setLayout(layout);
+		createServerTargetComposite(composite);
+		return top;
+	}
+
+	public static boolean launchNewRuntimeWizard(Shell shell, IDataModel model) {
+		DataModelPropertyDescriptor[] preAdditionDescriptors = model.getValidPropertyDescriptors(FACET_RUNTIME);
+		boolean isOK = ServerUIUtil.showNewRuntimeWizard(shell, "", ""); //$NON-NLS-1$  //$NON-NLS-2$
+		if (isOK && model != null) {
+
+			DataModelPropertyDescriptor[] postAdditionDescriptors = model.getValidPropertyDescriptors(FACET_RUNTIME);
+			Object[] preAddition = new Object[preAdditionDescriptors.length];
+			for (int i = 0; i < preAddition.length; i++) {
+				preAddition[i] = preAdditionDescriptors[i].getPropertyValue();
+			}
+			Object[] postAddition = new Object[postAdditionDescriptors.length];
+			for (int i = 0; i < postAddition.length; i++) {
+				postAddition[i] = postAdditionDescriptors[i].getPropertyValue();
+			}
+			Object newAddition = ProjectUtilities.getNewObject(preAddition, postAddition);
+
+			model.notifyPropertyChange(FACET_RUNTIME, IDataModel.VALID_VALUES_CHG);
+			if (newAddition != null)
+				model.setProperty(FACET_RUNTIME, newAddition);
+			else
+				return false;
+		}
+		return isOK;
+	}
+
+	protected Combo serverTargetCombo;
+	protected NewProjectGroup projectNameGroup;
+
+	public DataModelFacetCreationWizardPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+	}
+
+	protected void createServerTargetComposite(Composite parent) {
+		Label label = new Label(parent, SWT.NONE);
+		label.setText(ResourceHandler.TargetRuntime);
+		serverTargetCombo = new Combo(parent, SWT.BORDER | SWT.READ_ONLY);
+		serverTargetCombo.setLayoutData(gdhfill());
+		Button newServerTargetButton = new Button(parent, SWT.NONE);
+		newServerTargetButton.setText(ResourceHandler.NewDotDotDot);
+		newServerTargetButton.addSelectionListener(new SelectionAdapter() {
+			public void widgetSelected(SelectionEvent e) {
+				if (!launchNewRuntimeWizard(getShell(), model)) {
+					setErrorMessage(ResourceHandler.InvalidServerTarget);
+				}
+			}
+		});
+		Control[] deps = new Control[]{label, newServerTargetButton};
+		synchHelper.synchCombo(serverTargetCombo, FACET_RUNTIME, deps);
+		if (serverTargetCombo.getSelectionIndex() == -1 && serverTargetCombo.getVisibleItemCount() != 0)
+			serverTargetCombo.select(0);
+	}
+
+	protected void createProjectGroup(Composite parent) {
+		IDataModel nestedProjectDM = model.getNestedModel(NESTED_PROJECT_DM);
+		nestedProjectDM.addListener(this);
+		projectNameGroup = new NewProjectGroup(parent, nestedProjectDM);
+	}
+
+	protected String[] getValidationPropertyNames() {
+		return new String[]{IProjectCreationPropertiesNew.PROJECT_NAME, IProjectCreationPropertiesNew.PROJECT_LOCATION, FACET_RUNTIME};
+	}
+
+	public void dispose() {
+		super.dispose();
+		if (projectNameGroup != null)
+			projectNameGroup.dispose();
+	}
+}
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/DataModelFacetInstallPage.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/DataModelFacetInstallPage.java
new file mode 100644
index 0000000..da031f5
--- /dev/null
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/DataModelFacetInstallPage.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.wst.web.ui.internal.wizards;
+
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetInstallDataModelProperties;
+import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizardPage;
+import org.eclipse.wst.common.project.facet.ui.IFacetWizardPage;
+import org.eclipse.wst.common.project.facet.ui.IWizardContext;
+
+public abstract class DataModelFacetInstallPage extends DataModelWizardPage implements IFacetWizardPage, IFacetInstallDataModelProperties {
+
+	public DataModelFacetInstallPage(String pageName) {
+		// TODO figure out a better way to do this without compromising the IDataModelWizard
+		// framework.
+		super(DataModelFactory.createDataModel(new AbstractDataModelProvider() {
+		}), pageName);
+	}
+
+	protected static GridData gdhfill() {
+		return new GridData(GridData.FILL_HORIZONTAL);
+	}
+
+	public void setWizardContext(IWizardContext context) {
+		// Intentionally empty
+	}
+
+	public void transferStateToConfig() {
+		// Intentionally empty
+	}
+
+	public void setConfig(final Object config) {
+		model.removeListener(this);
+		synchHelper.dispose();
+
+		model = (IDataModel) config;
+		model.addListener(this);
+		synchHelper = initializeSynchHelper(model);
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/NewProjectDataModelFacetWizard.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/NewProjectDataModelFacetWizard.java
new file mode 100644
index 0000000..d28e689
--- /dev/null
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/NewProjectDataModelFacetWizard.java
@@ -0,0 +1,283 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.wst.web.ui.internal.wizards;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Set;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.ui.INewWizard;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.wizards.newresource.BasicNewProjectResourceWizard;
+import org.eclipse.ui.wizards.newresource.BasicNewResourceWizard;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.internal.operation.FacetProjectCreationOperation;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelEvent;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelListener;
+import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject.Action.Type;
+import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
+import org.eclipse.wst.common.project.facet.ui.AddRemoveFacetsWizard;
+import org.eclipse.wst.common.project.facet.ui.internal.ConflictingFacetsFilter;
+import org.eclipse.wst.common.project.facet.ui.internal.FacetsSelectionPanel;
+import org.eclipse.wst.web.internal.DelegateConfigurationElement;
+import org.eclipse.wst.web.ui.internal.WSTWebUIPlugin;
+
+public abstract class NewProjectDataModelFacetWizard extends AddRemoveFacetsWizard implements INewWizard, IFacetProjectCreationDataModelProperties {
+
+	protected IDataModel model = null;
+	private final IFacetedProjectTemplate template;
+	private IWizardPage firstPage;
+	private IConfigurationElement configurationElement;
+
+	public NewProjectDataModelFacetWizard(IDataModel model){
+		super(null);
+		this.model = model;
+		template = getTemplate();
+		this.setDefaultPageImageDescriptor(getDefaultPageImageDescriptor());
+	}
+	
+	public NewProjectDataModelFacetWizard() {
+		super(null);
+		model = createDataModel();
+		template = getTemplate();
+		this.setDefaultPageImageDescriptor(getDefaultPageImageDescriptor());
+	}
+	
+	public IDataModel getDataModel(){
+		return model;
+	}
+
+	protected abstract IDataModel createDataModel();
+
+	protected abstract ImageDescriptor getDefaultPageImageDescriptor();
+
+	protected abstract IFacetedProjectTemplate getTemplate();
+
+	protected abstract IWizardPage createFirstPage();
+
+	public void addPages() {
+		firstPage = createFirstPage();
+		addPage(firstPage);
+
+		super.addPages();
+		final Set fixed = this.template.getFixedProjectFacets();
+
+		this.facetsSelectionPage.setFixedProjectFacets(fixed);
+
+        // Disabling this as it interfers with the facet selection based on the
+        // runtime.
+        
+		/*Set facetVersions = new HashSet();
+		FacetDataModelMap map = (FacetDataModelMap) model.getProperty(FACET_DM_MAP);
+		for (Iterator iterator = map.values().iterator(); iterator.hasNext();) {
+			IDataModel model = (IDataModel) iterator.next();
+			facetVersions.add(model.getProperty(IFacetDataModelProperties.FACET_VERSION));
+		}
+		this.facetsSelectionPage.setInitialSelection(facetVersions);*/
+
+
+		final ConflictingFacetsFilter filter = new ConflictingFacetsFilter(fixed);
+
+		this.facetsSelectionPage.setFilters(new FacetsSelectionPanel.IFilter[]{filter});
+
+		synchRuntimes();
+	}
+
+	public IWizardPage[] getPages() {
+		final IWizardPage[] base = super.getPages();
+		final IWizardPage[] pages = new IWizardPage[base.length + 1];
+
+		pages[0] = this.firstPage;
+		System.arraycopy(base, 0, pages, 1, base.length);
+
+		return pages;
+	}
+
+	public void init(IWorkbench workbench, IStructuredSelection selection) {
+	}
+
+	protected void synchRuntimes() {
+		model.addListener(new IDataModelListener() {
+			public void propertyChanged(DataModelEvent event) {
+				if (FACET_RUNTIME.equals(event.getPropertyName())) {
+					IRuntime runtime = (IRuntime) event.getProperty();
+					if(runtime != getRuntime()){
+						setRuntime(runtime);
+					}
+				}
+			}
+		});
+
+		addRuntimeListener(new Listener() {
+			public void handleEvent(final Event event) {
+				model.setProperty(FACET_RUNTIME, getRuntime());
+			}
+		});
+	}
+
+	public String getProjectName() {
+		return model.getStringProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME);
+	}
+
+    protected void performFinish( final IProgressMonitor monitor )
+    
+        throws CoreException
+        
+    {
+        monitor.beginTask( "", 10 );
+        
+        try
+        {
+            FacetProjectCreationOperation operation = new FacetProjectCreationOperation(model);
+            this.fproj = operation.createProject(new SubProgressMonitor(monitor, 2));
+
+            super.performFinish( new SubProgressMonitor( monitor, 8 ) );
+            
+            final Set fixed = this.template.getFixedProjectFacets();
+            this.fproj.setFixedProjectFacets( fixed );
+            
+            try {
+                postPerformFinish();
+            } catch (InvocationTargetException e) {
+                Logger.getLogger().logError(e);
+            }
+        }
+        finally
+        {
+            monitor.done();
+        }
+    }
+    
+	/**
+	 * <p>
+	 * Override to return the final perspective ID (if any). The final perspective ID can be
+	 * hardcoded by the subclass or determined programmatically (possibly using the value of a field
+	 * on the Wizard's WTP Operation Data Model).
+	 * </p>
+	 * <p>
+	 * Default return value is <b>null </b>.
+	 * </p>
+	 * 
+	 * @return Returns the ID of the Perspective which is preferred by this wizard upon completion.
+	 */
+	protected String getFinalPerspectiveID() {
+		return "org.eclipse.jst.j2ee.J2EEPerspective";
+	}
+	/**
+	 * {@inheritDoc}
+	 * 
+	 * <p>
+	 * The configuration element is saved to use when the wizard completes in order to change the
+	 * current perspective using either (1) the value specified by {@link #getFinalPerspectiveID()}
+	 * or (2) the value specified by the finalPerspective attribute in the Wizard's configuration
+	 * element.
+	 * </p>
+	 * 
+	 * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
+	 *      java.lang.String, java.lang.Object)
+	 */
+	public final void setInitializationData(IConfigurationElement aConfigurationElement, String aPropertyName, Object theData) throws CoreException {
+		configurationElement = aConfigurationElement;
+		doSetInitializeData(aConfigurationElement, aPropertyName, theData);
+
+	}
+	/**
+	 * <p>
+	 * Override method for clients that wish to take advantage of the information provided by
+	 * {@see #setInitializationData(IConfigurationElement, String, Object)}.
+	 * </p>
+	 * 
+	 * @param aConfigurationElement
+	 *            The configuration element provided from the templated method.
+	 * @param aPropertyName
+	 *            The property name provided from the templated method.
+	 * @param theData
+	 *            The data provided from the templated method.
+	 */
+	protected void doSetInitializeData(IConfigurationElement aConfigurationElement, String aPropertyName, Object theData) {
+		// Default do nothing
+	}
+
+	/**
+	 * <p>
+	 * Returns the an id component used for Activity filtering.
+	 * </p>
+	 * 
+	 * <p>
+	 * The Plugin ID is determined from the configuration element specified in
+	 * {@see #setInitializationData(IConfigurationElement, String, Object)}.
+	 * </p>
+	 * 
+	 * @return Returns the plugin id associated with this wizard
+	 */
+	public final String getPluginId() {
+		return (configurationElement != null) ? configurationElement.getDeclaringExtension().getDeclaringPluginDescriptor().getUniqueIdentifier() : ""; //$NON-NLS-1$
+	}
+	/**
+	 * 
+	 * <p>
+	 * Invoked after the user has clicked the "Finish" button of the wizard. The default
+	 * implementation will attempt to update the final perspective to the value specified by
+	 * {@link #getFinalPerspectiveID() }
+	 * </p>
+	 * 
+	 * @throws InvocationTargetException
+	 * 
+	 * @see org.eclipse.wst.common.frameworks.internal.ui.wizard.WTPWizard#postPerformFinish()
+	 */
+	protected void postPerformFinish() throws InvocationTargetException {
+		
+		if (getFinalPerspectiveID() != null && getFinalPerspectiveID().length() > 0) {
+
+			IConfigurationElement element = new DelegateConfigurationElement(configurationElement) {
+				public String getAttribute(String aName) {
+					if (aName.equals("finalPerspective")) { //$NON-NLS-1$
+						return getFinalPerspectiveID();
+					}
+					return super.getAttribute(aName);
+				}
+			};
+			BasicNewProjectResourceWizard.updatePerspective(element);
+		} else
+			BasicNewProjectResourceWizard.updatePerspective(configurationElement);
+		String projName = getProjectName();
+		BasicNewResourceWizard.selectAndReveal(ProjectUtilities.getProject(projName), WSTWebUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow());
+	}
+
+	public Object getConfig(IProjectFacetVersion fv, Type type, String pjname) throws CoreException {
+		FacetDataModelMap map = (FacetDataModelMap) model.getProperty(FACET_DM_MAP);
+		IDataModel configDM = (IDataModel) map.get(fv.getProjectFacet().getId());
+		if (configDM == null) {
+            final Object config = fv.createActionConfig(type,pjname);
+            if( config == null || ! ( config instanceof IDataModel ) )
+                return null;
+			configDM = (IDataModel) config;
+			map.add(configDM);
+		}
+		configDM.setProperty(IFacetDataModelProperties.FACET_VERSION, fv);
+		return configDM;
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleContextRootComposite.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleContextRootComposite.java
index 5b2fca5..73d857e 100644
--- a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleContextRootComposite.java
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleContextRootComposite.java
@@ -56,7 +56,7 @@
 
 		// New Context Root Label
 		Label contextRootLabel = new Label(this, SWT.CHECK);
-		contextRootLabel.setText(ResourceHandler.getString("StaticContextRootComposite.Context_Root_Label")); //$NON-NLS-1$
+		contextRootLabel.setText(ResourceHandler.StaticContextRootComposite_Context_Root_Label); 
 
 		// New Context Root Entryfield
 		contextRootField = new Text(this, SWT.BORDER);
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebFacetInstallPage.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebFacetInstallPage.java
new file mode 100644
index 0000000..781ad1a
--- /dev/null
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebFacetInstallPage.java
@@ -0,0 +1,42 @@
+package org.eclipse.wst.web.ui.internal.wizards;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.wst.project.facet.ISimpleWebFacetInstallDataModelProperties;
+import org.eclipse.wst.web.internal.ResourceHandler;
+
+public class SimpleWebFacetInstallPage extends DataModelFacetInstallPage implements ISimpleWebFacetInstallDataModelProperties {
+
+	private Label configFolderLabel;
+	private Text configFolder;
+	
+	public SimpleWebFacetInstallPage() {
+		super("simpleweb.facet.install.page"); //$NON-NLS-1$
+		setTitle(ResourceHandler.StaticWebProjectWizardBasePage_Page_Title);
+		setDescription(ResourceHandler.ConfigureSettings);
+	}
+
+	protected String[] getValidationPropertyNames() {
+		return new String[]{CONTENT_DIR};
+	}
+
+	protected Composite createTopLevelComposite(Composite parent) {
+		final Composite composite = new Composite(parent, SWT.NONE);
+		composite.setLayout(new GridLayout(1, false));
+		
+		configFolderLabel = new Label(composite, SWT.NONE);
+		configFolderLabel.setText(ResourceHandler.StaticWebSettingsPropertiesPage_Web_Content_Label);
+		configFolderLabel.setLayoutData(gdhfill());
+
+		configFolder = new Text(composite, SWT.BORDER);
+		configFolder.setLayoutData(gdhfill());
+		configFolder.setData("label", configFolderLabel); //$NON-NLS-1$
+		synchHelper.synchText(configFolder, CONTENT_DIR, null);
+		
+		return composite;
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleCreationWizard.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleCreationWizard.java
index f4d7ed7..fd27c5a 100644
--- a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleCreationWizard.java
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleCreationWizard.java
@@ -49,7 +49,7 @@
     }
 
     public void init(IWorkbench workbench, IStructuredSelection selection) {
-        setWindowTitle(ResourceHandler.getString("StaticWebProjectCreationWizard.Wizard_Title")); //$NON-NLS-1$
+        setWindowTitle(ResourceHandler.StaticWebProjectCreationWizard_Wizard_Title); 
         setDefaultPageImageDescriptor(WSTWebUIPlugin.getDefault().getImageDescriptor("newwprj_wiz")); //$NON-NLS-1$
     }
 
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleWizardBasePage.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleWizardBasePage.java
index 46b98b3..9b3e972 100644
--- a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleWizardBasePage.java
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebModuleWizardBasePage.java
@@ -29,28 +29,26 @@
 import org.eclipse.ui.plugin.AbstractUIPlugin;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
 import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizardPage;
-import org.eclipse.wst.common.frameworks.internal.ui.NewProjectGroup;
 import org.eclipse.wst.common.frameworks.internal.ui.WTPCommonUIResourceHandler;
 import org.eclipse.wst.web.internal.ResourceHandler;
 import org.eclipse.wst.web.internal.WSTWebPlugin;
 import org.eclipse.wst.web.internal.operation.ISimpleWebModuleCreationDataModelProperties;
 
 class SimpleWebModuleWizardBasePage extends DataModelWizardPage implements ISimpleWebModuleCreationDataModelProperties{
-	protected NewProjectGroup projectNameGroup;
 	public Text projectNameField = null;
 	protected Text locationPathField = null;
 	protected Button browseButton = null;
 	//	constants
 	private static final int SIZING_TEXT_FIELD_WIDTH = 305;
 	//	default values
-	private String defProjectNameLabel = WTPCommonUIResourceHandler.getString("Name_"); //$NON-NLS-1$
-	private String defBrowseButtonLabel = WTPCommonUIResourceHandler.getString("Browse_");//$NON-NLS-1$
+	private String defProjectNameLabel = WTPCommonUIResourceHandler.Name_; //$NON-NLS-1$
+	private String defBrowseButtonLabel = WTPCommonUIResourceHandler.Browse_;//$NON-NLS-1$
 	private static final String defDirDialogLabel = "Directory"; //$NON-NLS-1$
 
 	public SimpleWebModuleWizardBasePage(IDataModel dataModel, String pageName) {
 		super(dataModel, pageName);
-		setDescription(ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Description")); //$NON-NLS-1$
-		setTitle(ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Title")); //$NON-NLS-1$
+		setDescription(ResourceHandler.StaticWebProjectWizardBasePage_Page_Description); 
+		setTitle(ResourceHandler.StaticWebProjectWizardBasePage_Page_Title); 
 		ImageDescriptor desc = AbstractUIPlugin.imageDescriptorFromPlugin(WSTWebPlugin.PLUGIN_ID, "icons/full/wizban/newwprj_wiz.gif"); //$NON-NLS-1$
 		setImageDescriptor(desc);
 		setPageComplete(false);
@@ -112,7 +110,7 @@
 	private void createProjectLocationGroup(Composite parent) {
 		//		set up location path label
 		Label locationPathLabel = new Label(parent, SWT.NONE);
-		locationPathLabel.setText(WTPCommonUIResourceHandler.getString("Project_location_"));//$NON-NLS-1$
+		locationPathLabel.setText(WTPCommonUIResourceHandler.Project_location_);//$NON-NLS-1$
 		GridData data = new GridData();
 		locationPathLabel.setLayoutData(data);
 		// set up location path entry field
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebProjectFirstPage.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebProjectFirstPage.java
new file mode 100644
index 0000000..84e1564
--- /dev/null
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebProjectFirstPage.java
@@ -0,0 +1,16 @@
+package org.eclipse.wst.web.ui.internal.wizards;
+
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.web.internal.ResourceHandler;
+import org.eclipse.wst.web.ui.internal.WSTWebUIPlugin;
+
+public class SimpleWebProjectFirstPage extends DataModelFacetCreationWizardPage {
+
+	public SimpleWebProjectFirstPage(IDataModel dataModel, String pageName) {
+		super(dataModel, pageName);
+		setDescription(ResourceHandler.StaticWebProjectWizardBasePage_Page_Description); 
+		setTitle(ResourceHandler.StaticWebProjectWizardBasePage_Page_Title); 
+		setImageDescriptor(WSTWebUIPlugin.getDefault().getImageDescriptor("newwprj_wiz")); //$NON-NLS-1$
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebProjectWizard.java b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebProjectWizard.java
new file mode 100644
index 0000000..3184a38
--- /dev/null
+++ b/plugins/org.eclipse.wst.web.ui/static_web_ui/org/eclipse/wst/web/ui/internal/wizards/SimpleWebProjectWizard.java
@@ -0,0 +1,41 @@
+package org.eclipse.wst.web.ui.internal.wizards;
+
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.wizard.IWizardPage;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+import org.eclipse.wst.project.facet.SimpleWebFacetProjectCreationDataModelProvider;
+import org.eclipse.wst.web.internal.ResourceHandler;
+import org.eclipse.wst.web.ui.internal.WSTWebUIPlugin;
+
+public class SimpleWebProjectWizard extends NewProjectDataModelFacetWizard {
+
+	public SimpleWebProjectWizard(IDataModel model) {
+		super(model);
+		setWindowTitle(ResourceHandler.StaticWebProjectCreationWizard_Wizard_Title);
+	}
+
+	public SimpleWebProjectWizard() {
+		super();
+		setWindowTitle(ResourceHandler.StaticWebProjectCreationWizard_Wizard_Title);
+	}
+
+	protected IDataModel createDataModel() {
+		return DataModelFactory.createDataModel(new SimpleWebFacetProjectCreationDataModelProvider());
+	}
+
+	protected ImageDescriptor getDefaultPageImageDescriptor() {
+		return WSTWebUIPlugin.getDefault().getImageDescriptor("newwprj_wiz"); //$NON-NLS-1$
+	}
+
+	protected IFacetedProjectTemplate getTemplate() {
+		return ProjectFacetsManager.getTemplate("template.wst.web"); //$NON-NLS-1$
+	}
+
+	protected IWizardPage createFirstPage() {
+		return new SimpleWebProjectFirstPage(model, "first.page"); //$NON-NLS-1$
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web/.cvsignore b/plugins/org.eclipse.wst.web/.cvsignore
index 21c0734..c57b639 100644
--- a/plugins/org.eclipse.wst.web/.cvsignore
+++ b/plugins/org.eclipse.wst.web/.cvsignore
@@ -2,3 +2,5 @@
 runtime
 temp.folder
 build.xml
+@dot
+src.zip
diff --git a/plugins/org.eclipse.wst.web/META-INF/MANIFEST.MF b/plugins/org.eclipse.wst.web/META-INF/MANIFEST.MF
index e01c2bc..4f72c98 100644
--- a/plugins/org.eclipse.wst.web/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.wst.web/META-INF/MANIFEST.MF
@@ -3,11 +3,11 @@
 Bundle-Name: Simple Web Plug-in
 Bundle-SymbolicName: org.eclipse.wst.web; singleton:=true
 Bundle-Version: 1.0.0
-Bundle-ClassPath: runtime/staticweb.jar
 Bundle-Activator: org.eclipse.wst.web.internal.WSTWebPlugin
 Bundle-Vendor: Eclipse.org
 Bundle-Localization: plugin
 Export-Package: .,
+ org.eclipse.wst.project.facet,
  org.eclipse.wst.web.internal,
  org.eclipse.wst.web.internal.deployables,
  org.eclipse.wst.web.internal.operation
diff --git a/plugins/org.eclipse.wst.web/build.properties b/plugins/org.eclipse.wst.web/build.properties
index 1fbf7e0..7058501 100644
--- a/plugins/org.eclipse.wst.web/build.properties
+++ b/plugins/org.eclipse.wst.web/build.properties
@@ -1,14 +1,14 @@
 bin.includes = plugin.xml,\
                plugin.properties,\
-               runtime/staticweb.jar,\
                icons/,\
                META-INF/,\
-               about.html
-jars.compile.order = runtime/staticweb.jar
-source.runtime/staticweb.jar = static_web_project/,\
-                               property_files/
-output.runtime/staticweb.jar = bin/
+               about.html,\
+               .
+jars.compile.order = .
 src.includes = component.xml,\
                property_files/,\
                plugin.xml,\
                plugin.properties
+output.. = bin/
+source.. = static_web_project/,\
+           property_files/
diff --git a/plugins/org.eclipse.wst.web/plugin.xml b/plugins/org.eclipse.wst.web/plugin.xml
index c33513d..f3a4d0a 100644
--- a/plugins/org.eclipse.wst.web/plugin.xml
+++ b/plugins/org.eclipse.wst.web/plugin.xml
@@ -53,22 +53,28 @@
     <project-facet id="wst.web">
       <label>Static Web Module</label>
       <description>Enables the project to be deployed as a static web module.</description>
-      <icon>icons/full/obj16/webstatic-deploy.gif</icon>
+      <icon>icons/full/obj16/webstatic_deploy.gif</icon>
     </project-facet>
 
     <project-facet-version facet="wst.web" version="1.0">
-      <delegate type="install" class="org.eclipse.wst.project.facet.StaticWebFacetInstallDelegate"/>
+    
+      <action type="install">
+        <delegate class="org.eclipse.wst.project.facet.SimpleWebFacetInstallDelegate"/>
+        <config-factory class="org.eclipse.wst.project.facet.SimpleWebFacetInstallDataModelProvider"/>
+      </action>
       <constraint>
         <and>
           <conflicts group="modules"/>
+          <conflicts group="java"/>
         </and>
       </constraint>
       <group-member id="modules"/>
+      <group-member id="java"/>
     </project-facet-version>
 
-    
+        
     <template id="template.wst.web">
-      <label>Dynamic Web Project</label>
+      <label>Simple Web Project</label>
       <fixed facet="wst.web"/>
     </template>
 
diff --git a/plugins/org.eclipse.wst.web/property_files/staticwebproject.properties b/plugins/org.eclipse.wst.web/property_files/staticwebproject.properties
index bfe239e..b270142 100644
--- a/plugins/org.eclipse.wst.web/property_files/staticwebproject.properties
+++ b/plugins/org.eclipse.wst.web/property_files/staticwebproject.properties
@@ -1,6 +1,10 @@
-StaticWebProjectCreationWizard.Wizard_Title=New Static Web Project
-StaticWebProjectWizardBasePage.Page_Description=Create a Web project for simple content (HTML files) only.
-StaticWebSettingsPropertiesPage.Web_Content_Label=Web content folder name:
-StaticContextRootComposite.Context_Root_Label=Context root
-StaticWebProjectWizardBasePage.Page_Title=Static Web Project
-StaticWebSettingsPropertiesPage.Not_available_for_closed_projects=Web settings are not available for a closed project.
+StaticWebProjectCreationWizard_Wizard_Title=New Static Web Project
+StaticWebProjectWizardBasePage_Page_Description=Create a Web project for simple content (HTML files) only.
+StaticWebSettingsPropertiesPage_Web_Content_Label=Web content folder name:
+StaticContextRootComposite_Context_Root_Label=Context root
+StaticWebProjectWizardBasePage_Page_Title=Static Web Project
+StaticWebSettingsPropertiesPage_Not_available_for_closed_projects=Web settings are not available for a closed project.
+TargetRuntime=Target runtime:
+NewDotDotDot=N&ew...
+InvalidServerTarget=Invalid target server selected.
+ConfigureSettings=Configure Static Web module settings.
\ No newline at end of file
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/ISimpleWebFacetInstallDataModelProperties.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/ISimpleWebFacetInstallDataModelProperties.java
new file mode 100644
index 0000000..6c39651
--- /dev/null
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/ISimpleWebFacetInstallDataModelProperties.java
@@ -0,0 +1,6 @@
+package org.eclipse.wst.project.facet;
+
+public interface ISimpleWebFacetInstallDataModelProperties {
+
+	public static final String CONTENT_DIR = "IStaticWebFacetInstallDataModelProperties.CONTENT_DIR"; //$NON-NLS-1$
+}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/IStaticWebFacetInstallDataModelProperties.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/IStaticWebFacetInstallDataModelProperties.java
deleted file mode 100644
index d754140..0000000
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/IStaticWebFacetInstallDataModelProperties.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package org.eclipse.wst.project.facet;
-
-public interface IStaticWebFacetInstallDataModelProperties {
-
-	public static final String CONTENT_DIR = "IStaticWebFacetInstallDataModelProperties.CONTENT_DIR"; //$NON-NLS-1$
-}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetInstallDataModelProvider.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetInstallDataModelProvider.java
new file mode 100644
index 0000000..c71c6d1
--- /dev/null
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetInstallDataModelProvider.java
@@ -0,0 +1,28 @@
+package org.eclipse.wst.project.facet;
+
+import java.util.Set;
+
+import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+
+public class SimpleWebFacetInstallDataModelProvider extends FacetInstallDataModelProvider implements ISimpleWebFacetInstallDataModelProperties {
+
+	public SimpleWebFacetInstallDataModelProvider() {
+		super();
+	}
+
+	public Set getPropertyNames() {
+		Set names = super.getPropertyNames();
+		names.add(CONTENT_DIR);
+		return names;
+	}
+
+	public Object getDefaultProperty(String propertyName) {
+		if (propertyName.equals(CONTENT_DIR)) {
+			return "WebContent"; //$NON-NLS-1$
+		} else if (propertyName.equals(FACET_ID)) {
+			return IModuleConstants.WST_WEB_MODULE;
+		}
+		return super.getDefaultProperty(propertyName);
+	}
+}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetInstallDelegate.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetInstallDelegate.java
new file mode 100644
index 0000000..8c03353
--- /dev/null
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetInstallDelegate.java
@@ -0,0 +1,48 @@
+package org.eclipse.wst.project.facet;
+
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jem.util.logger.proxy.Logger;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.datamodel.FacetDataModelProvider;
+import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
+import org.eclipse.wst.common.project.facet.core.IDelegate;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+
+public class SimpleWebFacetInstallDelegate implements IDelegate {
+
+	public void execute(IProject project, IProjectFacetVersion fv, Object config, IProgressMonitor monitor) throws CoreException {
+
+		IDataModel model = (IDataModel) config;
+		addNatures(project);
+		final IVirtualComponent c = ComponentCore.createComponent(project);
+		c.create(0, null);
+		final IVirtualFolder webroot = c.getRootFolder();
+		webroot.createLink(new Path("/" + model.getStringProperty(ISimpleWebFacetInstallDataModelProperties.CONTENT_DIR)), 0, null); //$NON-NLS-1$
+		try {
+			((IDataModelOperation) model.getProperty(FacetDataModelProvider.NOTIFICATION_OPERATION)).execute(monitor, null);
+		} catch (ExecutionException e) {
+			Logger.getLogger().logError(e);
+		}
+	}
+
+	private void addNatures(final IProject project) throws CoreException {
+
+		final IProjectDescription desc = project.getDescription();
+		final String[] current = desc.getNatureIds();
+		final String[] replacement = new String[current.length + 1];
+		System.arraycopy(current, 0, replacement, 0, current.length);
+		replacement[current.length] = IModuleConstants.MODULE_NATURE_ID;
+		desc.setNatureIds(replacement);
+		project.setDescription(desc, null);
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetProjectCreationDataModelProvider.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetProjectCreationDataModelProvider.java
new file mode 100644
index 0000000..e561581
--- /dev/null
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/SimpleWebFacetProjectCreationDataModelProvider.java
@@ -0,0 +1,20 @@
+package org.eclipse.wst.project.facet;
+
+import org.eclipse.wst.common.componentcore.datamodel.FacetProjectCreationDataModelProvider;
+import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+public class SimpleWebFacetProjectCreationDataModelProvider extends FacetProjectCreationDataModelProvider {
+
+	public SimpleWebFacetProjectCreationDataModelProvider() {
+		super();
+	}
+	
+	public void init() {
+		super.init();
+		FacetDataModelMap map = (FacetDataModelMap) getProperty(FACET_DM_MAP);
+		IDataModel simpleWebFacet = DataModelFactory.createDataModel(new SimpleWebFacetInstallDataModelProvider());
+		map.add(simpleWebFacet);
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/StaticWebFacetInstallDataModelProvider.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/StaticWebFacetInstallDataModelProvider.java
deleted file mode 100644
index 7a9d64b..0000000
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/StaticWebFacetInstallDataModelProvider.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package org.eclipse.wst.project.facet;
-
-import java.util.Set;
-
-import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
-import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
-
-public class StaticWebFacetInstallDataModelProvider
-	extends FacetInstallDataModelProvider
-	implements IStaticWebFacetInstallDataModelProperties{
-
-	public Set getPropertyNames() {
-		Set names = super.getPropertyNames();
-		names.add(CONTENT_DIR);
-		return names;
-	}
-	
-	public Object getDefaultProperty(String propertyName) {
-		if(propertyName.equals(CONTENT_DIR)){
-			return "WebContent"; //$NON-NLS-1$
-		} else if(propertyName.equals(FACET_ID)){
-			return IModuleConstants.WST_WEB_MODULE;
-		}
-		return super.getDefaultProperty(propertyName);
-	}	
-}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/StaticWebFacetInstallDelegate.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/StaticWebFacetInstallDelegate.java
deleted file mode 100644
index dfbc625..0000000
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/project/facet/StaticWebFacetInstallDelegate.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package org.eclipse.wst.project.facet;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IProjectDescription;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.wst.common.componentcore.ComponentCore;
-import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
-import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
-import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
-import org.eclipse.wst.common.project.facet.core.IDelegate;
-import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
-
-public class StaticWebFacetInstallDelegate implements IDelegate{
-
-	public void execute(IProject project, IProjectFacetVersion fv, Object config, IProgressMonitor monitor) throws CoreException {
-
-		IDataModel model = (IDataModel) config;
-		
-		addNatures(project);
-		
-		final IVirtualComponent c = ComponentCore.createComponent(project);
-		c.create(0, null);
-		
-		final IVirtualFolder webroot = c.getRootFolder();
-		webroot.createLink(new Path("/" + model.getStringProperty(IStaticWebFacetInstallDataModelProperties.CONTENT_DIR)), 0, null);
-	}
-
-	
-	private void addNatures( final IProject project )
-        throws CoreException{
-		
-        final IProjectDescription desc = project.getDescription();
-        final String[] current = desc.getNatureIds();
-        final String[] replacement = new String[ current.length + 1 ];
-        System.arraycopy( current, 0, replacement, 0, current.length );
-        replacement[ current.length ] = "org.eclipse.wst.common.modulecore.ModuleCoreNature";
-        desc.setNatureIds( replacement );
-        project.setDescription( desc, null );
-    }		
-
-}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/DelegateConfigurationElement.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/DelegateConfigurationElement.java
new file mode 100644
index 0000000..0e8fd62
--- /dev/null
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/DelegateConfigurationElement.java
@@ -0,0 +1,195 @@
+/*
+ * Created on Dec 14, 2004
+ *
+ * TODO To change the template for this generated file go to
+ * Window - Preferences - Java - Code Style - Code Templates
+ */
+package org.eclipse.wst.web.internal;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.InvalidRegistryObjectException;
+
+/**
+ * An object which represents the user-defined contents of an extension in a plug-in manifest.
+ */
+public class DelegateConfigurationElement implements IConfigurationElement {
+
+	private final IConfigurationElement delegateElement;
+	private static final String DELEGATE_NAME = "delegateConfigurationElement"; //$NON-NLS-1$ 
+	private static final String DELEGATE_NAMESPACE = "delegateConfigurationElementNamespace"; //$NON-NLS-1$ 
+	private static final String DELEGATE_NULL_STRING = "delegateConfigurationElement: NULL"; //$NON-NLS-1$ 
+
+	public DelegateConfigurationElement(IConfigurationElement aDelegate) {
+		delegateElement = aDelegate;
+	}
+
+	/**
+	 * @param propertyName
+	 * @return
+	 * @throws org.eclipse.core.runtime.CoreException
+	 */
+	public Object createExecutableExtension(String propertyName) throws CoreException {
+		if (delegateElement == null)
+			return null;
+		return delegateElement.createExecutableExtension(propertyName);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#equals(java.lang.Object)
+	 */
+	public boolean equals(Object obj) {
+		if (delegateElement == null)
+			return false;
+		return delegateElement.equals(obj);
+	}
+
+	/**
+	 * @param name
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String getAttribute(String name) throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return null;
+		return delegateElement.getAttribute(name);
+	}
+
+	/**
+	 * @param name
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String getAttributeAsIs(String name) throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return null;
+		return delegateElement.getAttributeAsIs(name);
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String[] getAttributeNames() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return new String[0];
+		return delegateElement.getAttributeNames();
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public IConfigurationElement[] getChildren() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return new IConfigurationElement[0];
+		return delegateElement.getChildren();
+	}
+
+	/**
+	 * @param name
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public IConfigurationElement[] getChildren(String name) throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return new IConfigurationElement[0];
+		return delegateElement.getChildren(name);
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public IExtension getDeclaringExtension() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			throw new InvalidRegistryObjectException();
+		return delegateElement.getDeclaringExtension();
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String getName() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return DELEGATE_NAME;
+		return delegateElement.getName();
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String getNamespace() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return DELEGATE_NAMESPACE;
+		return delegateElement.getNamespace();
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public Object getParent() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return null;
+		return delegateElement.getParent();
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String getValue() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return null;
+		return delegateElement.getValue();
+	}
+
+	/**
+	 * @return
+	 * @throws org.eclipse.core.runtime.InvalidRegistryObjectException
+	 */
+	public String getValueAsIs() throws InvalidRegistryObjectException {
+		if (delegateElement == null)
+			return null;
+		return delegateElement.getValueAsIs();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#hashCode()
+	 */
+	public int hashCode() {
+		if (delegateElement == null)
+			return -1;
+		return delegateElement.hashCode();
+	}
+
+	/**
+	 * @return
+	 */
+	public boolean isValid() {
+
+		if (delegateElement == null)
+			return false;
+		return delegateElement.isValid();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
+	public String toString() {
+		if (delegateElement == null)
+			return DELEGATE_NULL_STRING;
+		return delegateElement.toString();
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/ResourceHandler.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/ResourceHandler.java
index 4390981..87c27dc 100644
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/ResourceHandler.java
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/ResourceHandler.java
@@ -1,38 +1,37 @@
-/***************************************************************************************************
- * Copyright (c) 2003, 2004 IBM Corporation and others. All rights reserved. This program and the
- * accompanying materials are made available under the terms of the Eclipse Public License v1.0
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: IBM Corporation - initial API and implementation
- **************************************************************************************************/
-
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
 package org.eclipse.wst.web.internal;
 
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
+import org.eclipse.osgi.util.NLS;
 
-public class ResourceHandler
-{
+public final class ResourceHandler extends NLS {
+
 	private static final String BUNDLE_NAME = "staticwebproject";//$NON-NLS-1$
 
-	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
-			.getBundle(BUNDLE_NAME);
-
 	private ResourceHandler() {
-		//Default constructor
+		// Do not instantiate
 	}
 
-	public static String getString(String key)
-	{
-		// TODO Auto-generated method stub
-		try
-		{
-			return RESOURCE_BUNDLE.getString(key);
-		}
-		catch( MissingResourceException e )
-		{
-			return '!' + key + '!';
-		}
+	public static String StaticWebProjectCreationWizard_Wizard_Title;
+	public static String StaticWebProjectWizardBasePage_Page_Description;
+	public static String StaticWebSettingsPropertiesPage_Web_Content_Label;
+	public static String StaticContextRootComposite_Context_Root_Label;
+	public static String StaticWebProjectWizardBasePage_Page_Title;
+	public static String StaticWebSettingsPropertiesPage_Not_available_for_closed_projects;
+	public static String TargetRuntime;
+	public static String NewDotDotDot;
+	public static String InvalidServerTarget;
+	public static String ConfigureSettings;
+
+	static {
+		NLS.initializeMessages(BUNDLE_NAME, ResourceHandler.class);
 	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/WebPropertiesUtil.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/WebPropertiesUtil.java
index 7a3cc43..79a7677 100644
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/WebPropertiesUtil.java
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/WebPropertiesUtil.java
@@ -35,7 +35,7 @@
 		if (name.equals("") || name == null) { //$NON-NLS-1$
 			//  this was added because the error message shouldnt be shown initially. It should be
 			// shown only if context root field is edited to
-			errorMessage = ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Title"); //$NON-NLS-1$
+			errorMessage = ResourceHandler.StaticWebProjectWizardBasePage_Page_Title; 
 			
 			//errorMessage = ProjectSupportResourceHandler.getString("Context_Root_cannot_be_empty_2"); //$NON-NLS-1$
 			return errorMessage;
@@ -60,7 +60,7 @@
 							//	ResourceHandler.getString("_Context_root_cannot_conta_UI_");//$NON-NLS-1$
 							// = " Context root cannot contain whitespaces."
 						} else {
-							errorMessage = ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Title"); //$NON-NLS-1$
+							errorMessage = ResourceHandler.StaticWebProjectWizardBasePage_Page_Title; 
 							
 							//errorMessage = ProjectSupportResourceHandler.getString("The_character_is_invalid_in_a_context_root", new Object[]{(new Character(token.charAt(i))).toString()}); //$NON-NLS-1$
 							break outer;
@@ -70,7 +70,7 @@
 			}
 		} // en/ end of if(name.trim
 		else
-			errorMessage = ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Title"); //$NON-NLS-1$
+			errorMessage = ResourceHandler.StaticWebProjectWizardBasePage_Page_Title; 
 			//errorMessage = ProjectSupportResourceHandler.getString("Names_cannot_begin_or_end_with_whitespace_5"); //$NON-NLS-1$
 
 		return errorMessage;
@@ -91,12 +91,12 @@
 
 	public static String validateFolderName(String folderName) {
 		if (folderName.length() == 0)
-			return ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Title"); //$NON-NLS-1$
+			return ResourceHandler.StaticWebProjectWizardBasePage_Page_Title; 
 			
 			//return ProjectSupportResourceHandler.getString("Folder_name_cannot_be_empty_2"); //$NON-NLS-1$
 
 		if (contains(folderName, BAD_CHARS))
-			return ResourceHandler.getString("StaticWebProjectWizardBasePage.Page_Title"); //$NON-NLS-1$
+			return ResourceHandler.StaticWebProjectWizardBasePage_Page_Title; 
 			
 			//return ProjectSupportResourceHandler.getString("Folder_name_is_not_valid", new Object[]{folderName}); //$NON-NLS-1$
 
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/ComponentDeployable.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/ComponentDeployable.java
new file mode 100644
index 0000000..3149b99
--- /dev/null
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/ComponentDeployable.java
@@ -0,0 +1,249 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2005 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.wst.web.internal.deployables;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualContainer;
+import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
+import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
+import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
+import org.eclipse.wst.server.core.IModule;
+import org.eclipse.wst.server.core.ServerUtil;
+import org.eclipse.wst.server.core.internal.ModuleFile;
+import org.eclipse.wst.server.core.internal.ModuleFolder;
+import org.eclipse.wst.server.core.model.IModuleFolder;
+import org.eclipse.wst.server.core.model.IModuleResource;
+import org.eclipse.wst.server.core.util.ProjectModule;
+
+public abstract class ComponentDeployable extends ProjectModule {
+
+	protected IVirtualComponent component = null;
+	protected List members = new ArrayList();
+	
+	public ComponentDeployable(IProject project) {
+		super(project);
+		this.component = ComponentCore.createComponent(project);
+	}
+	
+	/**
+	 * @see org.eclipse.jst.server.core.IJ2EEModule#isBinary()
+	 */
+	public boolean isBinary() {
+		return false;
+	}
+	
+	private void addMembersToModuleFolder(ModuleFolder mf, IModuleResource[] mr) {
+		IModuleResource[] existingMembers = null;
+		if (mf == null || mf.members() == null)
+			existingMembers = new IModuleResource[0];
+		else
+			existingMembers = mf.members();
+		if (existingMembers==null)
+			existingMembers = new IModuleResource[0];
+		List membersJoin = new ArrayList();
+		membersJoin.addAll(Arrays.asList(existingMembers));
+		List newMembers = Arrays.asList(mr);
+		for (int i=0; i<newMembers.size(); i++) {
+			boolean found = false;
+			IModuleResource newMember = (IModuleResource) newMembers.get(i);
+			for (int k=0; k<membersJoin.size(); k++) {
+				IModuleResource existingResource = (IModuleResource) membersJoin.get(k);
+				if (existingResource.equals(newMember)) {
+					found = true;
+					break;
+				}
+			}
+			if (!found)
+				membersJoin.add(newMember);
+		}
+		if (mf !=null)
+			mf.setMembers((IModuleResource[]) membersJoin.toArray(new IModuleResource[membersJoin.size()]));
+	}
+	
+	 /**
+     * Returns the child modules of this module.
+     * 
+     * @return org.eclipse.wst.server.core.model.IModule[]
+     */
+    public IModule[] getChildModules() {
+        return getModules();
+    }
+    
+    public IModule[] getModules() {
+		List modules = new ArrayList();
+		if (component != null) {
+	    	IVirtualReference[] components = component.getReferences();
+	    	for (int i = 0; i < components.length; i++) {
+				IVirtualReference reference = components[i];
+				IVirtualComponent virtualComp = reference.getReferencedComponent();
+				if (virtualComp != null && virtualComp.getProject()!=component.getProject()) {
+					Object module = ServerUtil.getModule(virtualComp.getProject());
+					if (module != null && !modules.contains(module))
+						modules.add(module);
+				}
+			}
+		}
+        return (IModule[]) modules.toArray(new IModule[modules.size()]);
+	}
+    
+    /**
+	 * Find the module resources for a given container and path. Inserts in the java containers
+	 * at a given path if not null.
+	 * 
+	 * @param cont a container
+	 * @param path the current module relative path
+	 * @param javaPath the path where Java resources fit in the root
+	 * @param javaCont
+	 * @return a possibly-empty array of module resources
+	 * @throws CoreException
+	 */
+	protected IModuleResource[] getMembers(IContainer cont, IPath path, IPath javaPath, IContainer[] javaCont) throws CoreException {
+		IResource[] res = cont.members();
+		int size2 = res.length;
+		List list = new ArrayList(size2);
+		for (int j = 0; j < size2; j++) {
+			if (res[j] instanceof IContainer) {
+				IContainer cc = (IContainer) res[j];
+				
+				IPath newPath = path.append(cc.getName());
+				// Retrieve already existing module folder if applicable
+				ModuleFolder mf = (ModuleFolder) getExistingModuleResource(members,newPath);
+				if (mf == null) {
+					mf = new ModuleFolder(cc, cc.getName(), path);
+					list.add(mf);
+				}
+				IModuleResource[] mr = getMembers(cc, newPath, javaPath, javaCont);
+				
+				if (javaPath != null && newPath.isPrefixOf(javaPath))
+					mr = handleJavaPath(path, javaPath, newPath, javaCont, mr, cc);
+
+				addMembersToModuleFolder(mf, mr);
+				
+			} else {
+				IFile f = (IFile) res[j];
+				// Handle the default package case
+				if (path.equals(javaPath)) {
+					ModuleFolder mFolder = (ModuleFolder) getExistingModuleResource(members,javaPath);
+					ModuleFile mFile = new ModuleFile(f, f.getName(), javaPath, f.getModificationStamp() + f.getLocalTimeStamp());
+					addMembersToModuleFolder(mFolder,new IModuleResource[]{mFile});
+				} else {
+					ModuleFile mf = new ModuleFile(f, f.getName(), path, f.getModificationStamp() + f.getLocalTimeStamp());
+					list.add(mf);
+				}
+			}
+		}
+		IModuleResource[] mr = new IModuleResource[list.size()];
+		list.toArray(mr);
+		return mr;
+	}
+	
+	protected IModuleResource[] getMembers(IVirtualContainer cont, IPath path) throws CoreException {
+		IVirtualResource[] res = cont.members();
+		int size2 = res.length;
+		List list = new ArrayList(size2);
+		for (int j = 0; j < size2; j++) {
+			if (res[j] instanceof IVirtualContainer) {
+				IVirtualContainer cc = (IVirtualContainer) res[j];
+				// Retrieve already existing module folder if applicable
+				ModuleFolder mf = (ModuleFolder) getExistingModuleResource(members,new Path(cc.getName()));
+				if (mf == null) {
+					mf = new ModuleFolder((IContainer)cc.getUnderlyingResource(), cc.getName(), path);
+					list.add(mf);
+				}
+				IModuleResource[] mr = getMembers(cc, path.append(cc.getName()));
+				addMembersToModuleFolder(mf, mr);
+			} else {
+				IFile f = (IFile) res[j].getUnderlyingResource();
+				if (!isFileInSourceContainer(f)) {
+					ModuleFile mf = new ModuleFile(f, f.getName(), path, f.getModificationStamp() + f.getLocalTimeStamp());
+					list.add(mf);
+				}
+			}
+		}
+		IModuleResource[] mr = new IModuleResource[list.size()];
+		list.toArray(mr);
+		return mr;
+	}
+	
+	protected boolean isFileInSourceContainer(IFile file) {
+		return false;
+	}
+	private IModuleResource getExistingModuleResource(List aList, IPath path) {
+    	IModuleResource result = null;
+    	// If the list is empty, return null
+    	if (aList==null || aList.isEmpty())
+    		return null;
+    	// Otherwise recursively check to see if given resource matches current resource or if it is a child
+    	int i=0;
+    	do {
+	    	IModuleResource moduleResource = (IModuleResource) aList.get(i);
+	    		if (moduleResource.getModuleRelativePath().append(moduleResource.getName()).equals(path))
+	    			result = moduleResource;
+	    		// if it is a folder, check its children for the resource path
+	    		else if (moduleResource instanceof IModuleFolder) {
+	    			result = getExistingModuleResource(Arrays.asList(((IModuleFolder)moduleResource).members()),path);
+	    		}
+	    		i++;
+    	} while (result == null && i<aList.size() );
+    	return result;
+    }
+	
+	protected IModuleResource[] handleJavaPath(IPath path, IPath javaPath, IPath curPath, IContainer[] javaCont, IModuleResource[] mr, IContainer cc) throws CoreException {
+		//subclasses may override
+		return new IModuleResource[]{};
+	}
+	
+	public IModuleResource[] members() throws CoreException {
+		members.clear();
+		IVirtualComponent vc = ComponentCore.createComponent(getProject());
+		if (vc != null) {
+			IVirtualFolder vFolder = vc.getRootFolder();
+			IModuleResource[] mr = getMembers(vFolder, Path.EMPTY);
+			int size = mr.length;
+			for (int j = 0; j < size; j++) {
+				if (!members.contains(mr[j]))
+					members.add(mr[j]);
+			}
+		}
+		
+		IModuleResource[] mr = new IModuleResource[members.size()];
+		members.toArray(mr);
+		return mr;
+	}
+	
+	/**
+	 * Returns the root folders for the resources in this module.
+	 * 
+	 * @return a possibly-empty array of resource folders
+	 */
+	public IContainer[] getResourceFolders() {
+		IVirtualComponent vc = ComponentCore.createComponent(getProject());
+		if (vc != null) {
+			IVirtualFolder vFolder = vc.getRootFolder();
+			if (vFolder != null)
+				return vFolder.getUnderlyingFolders();
+		}
+		return new IContainer[]{};
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployable.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployable.java
index e48eeab..7c01687 100644
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployable.java
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployable.java
@@ -8,104 +8,75 @@
  **************************************************************************************************/
 package org.eclipse.wst.web.internal.deployables;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Properties;
 
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
+import org.eclipse.wst.common.project.facet.core.IProjectFacet;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 import org.eclipse.wst.server.core.IModule;
-import org.eclipse.wst.server.core.IModuleType;
 import org.eclipse.wst.server.core.util.IStaticWeb;
-import org.eclipse.wst.server.core.util.ProjectModule;
 
-public class StaticWebDeployable extends ProjectModule implements IStaticWeb {
+public class StaticWebDeployable extends ComponentDeployable implements IStaticWeb {
 
-	protected IVirtualComponent component = null;
-	 
 	public StaticWebDeployable(IProject project, IVirtualComponent component) {
 		super(project);
-		this.component = component;
 	}
-
-	public String getFactoryId() {
-		return StaticWebDeployableFactory.getFactoryId();
-	}
-
-	/**
-	 * Returns true if this deployable currently exists, and false if it has been deleted or moved
-	 * and is no longer represented by this deployable.
-	 * 
-	 * @return boolean
-	 */
-	public boolean exists() {
-		if (getProject() == null || !getProject().exists())
-			return false;
-		return true;
-	}
-
+	
 	public String getContextRoot() {
 		Properties props = component.getMetaProperties();
 		if(props.containsKey("context-root")) //$NON-NLS-1$
 			return props.getProperty("context-root"); //$NON-NLS-1$
-		return component.getName();
+	    return component.getName();
+    }
+	
+	 public String getURI(IModule module) {
+	    IVirtualComponent comp = ComponentCore.createComponent(module.getProject());
+	    String aURI = null;
+	    if (comp !=null) {
+	    	if (!comp.isBinary() && isProjectOfType(module.getProject(),IModuleConstants.WST_WEB_MODULE)) {
+        		IVirtualReference ref = component.getReference(comp.getName());
+        		aURI = ref.getRuntimePath().append(comp.getName()+".war").toString(); //$NON-NLS-1$
+        	}
+	    }
+	    	
+    	if (aURI !=null && aURI.length()>1 && aURI.startsWith("/")) //$NON-NLS-1$
+    		aURI = aURI.substring(1);
+    	return aURI;
+	 }
+	 
+	 private boolean isProjectOfType(IProject project, String typeID) {
+		IFacetedProject facetedProject = null;
+		try {
+			facetedProject = ProjectFacetsManager.create(project);
+		} catch (CoreException e) {
+			return false;
+		}
+		
+		if (facetedProject !=null && ProjectFacetsManager.isProjectFacetDefined(typeID)) {
+			IProjectFacet projectFacet = ProjectFacetsManager.getProjectFacet(typeID);
+			return projectFacet!=null && facetedProject.hasProjectFacet(projectFacet);
+		}
+		return false;
 	}
-
-	public String getType() {
-		return IModuleConstants.WST_WEB_MODULE;
-	}
-
+	 
 	public String getVersion() {
+		IFacetedProject facetedProject = null;
+		try {
+			facetedProject = ProjectFacetsManager.create(component.getProject());
+			if (facetedProject !=null && ProjectFacetsManager.isProjectFacetDefined(IModuleConstants.WST_WEB_MODULE)) {
+				IProjectFacet projectFacet = ProjectFacetsManager.getProjectFacet(IModuleConstants.WST_WEB_MODULE);
+				return facetedProject.getInstalledVersion(projectFacet).getVersionString();
+			}
+		} catch (Exception e) {
+			//Ignore
+		}
 		return "1.0"; //$NON-NLS-1$
 	}
 
-    /* (non-Javadoc)
-     * @see org.eclipse.wst.server.core.IModule#getModuleType()
-     */
-    public IModuleType getModuleType() {
-		return new IModuleType() {
-
-			public String getId() {
-				return getType();
-			}
-
-			public String getName() {
-				return getModuleTypeName();
-			}
-
-			public String getVersion() {
-				return getModuleTypeVersion();
-			}
-		};
-
-	}
-    
-    public String getModuleTypeName(){
-        return getName();
-    }
-    
-    public String getModuleTypeVersion(){
-        return getVersion();
-    }
-
-    /**
-     * Returns the child modules of this module.
-     * 
-     * @return org.eclipse.wst.server.core.model.IModule[]
-     */
-    public IModule[] getChildModules() {
-        List list = new ArrayList();
-//
-//        if (this.archives != null) {
-//            int size = this.archives.length;
-//            for (int i = 0; i < size; i++)
-//                list.add(this.archives[i]);
-//        }
-//
-        IModule[] children = new IModule[list.size()];
-        list.toArray(children);
-        return children;
-    }
-
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployableFactory.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployableFactory.java
index e40d324..f3856a2 100644
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployableFactory.java
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/deployables/StaticWebDeployableFactory.java
@@ -10,14 +10,14 @@
 
 import java.util.ArrayList;
 import java.util.Iterator;
-import java.util.List;
 
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.ModuleCoreNature;
-import org.eclipse.wst.common.componentcore.internal.StructureEdit;
 import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.project.facet.core.IFacetedProject;
@@ -37,7 +37,16 @@
 	public static String getFactoryId() {
 		return ID;
 	}
-
+	protected IModule createModule(ModuleCoreNature nature) {
+		IProject project = nature.getProject();
+		try {
+			IVirtualComponent comp = ComponentCore.createComponent(project);
+			return createModuleDelegates(comp);
+		} catch (Exception e) {
+			Logger.getLogger().write(e);
+		}
+		return null;
+	}
 	/**
 	 * Returns true if the project represents a deployable project of this type.
 	 * 
@@ -72,56 +81,26 @@
 
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.server.core.model.ModuleFactoryDelegate#getModules()
-	 */
-	public IModule[] getModules() {
-		if (projects == null || projects.isEmpty())
-			cacheModules();
-		int i = 0;
-		Iterator modules = projects.keySet().iterator();
-		IModule[] modulesArray = new IModule[projects.size()];
-		while (modules.hasNext()) {
-			IModule[] module = null;
-			IProject project = (IProject) modules.next();
-			module = (IModule[])projects.get(project);
-			modulesArray[i++] = module[0];
-		}
-		return modulesArray;
-
-	}
-
-	protected List createModules(ModuleCoreNature nature) {
-		IProject project = nature.getProject();
-		List modules = new ArrayList(1); 
-		StructureEdit moduleCore = null;
+	protected IModule createModule(IProject project) {
 		try {
-			IVirtualComponent component = ComponentCore.createComponent(project);
-			modules = createModuleDelegates(component);
-
-		} catch (Exception e) {
-			e.printStackTrace();
-		} finally {
-			if(moduleCore != null) 
-				moduleCore.dispose();
+			ModuleCoreNature nature = (ModuleCoreNature) project.getNature(IModuleConstants.MODULE_NATURE_ID);
+			if (nature != null)
+				return createModule(nature);
+		} catch (CoreException e) {
+			Logger.getLogger().write(e);
 		}
-		return modules;
+		return null;
 	}
-	
-	protected List createModuleDelegates(IVirtualComponent component) throws CoreException {
+
+	protected IModule createModuleDelegates(IVirtualComponent component) throws CoreException {
 		StaticWebDeployable moduleDelegate = null;
 		IModule module = null;
-		List moduleList = new ArrayList();
 		try {
 			if(isValidModule(component.getProject())) {
 				moduleDelegate = new StaticWebDeployable(component.getProject(),component);
-				module = createModule(component.getName(), component.getName(), moduleDelegate.getType(), moduleDelegate.getVersion(), moduleDelegate.getProject());
-				moduleList.add(module);
+				module = createModule(component.getName(), component.getName(), IModuleConstants.WST_WEB_MODULE, moduleDelegate.getVersion(), moduleDelegate.getProject());
 				moduleDelegate.initialize(module);
 			}
-			// adapt(moduleDelegate, (WorkbenchComponent) workBenchModules.get(i));
 		} catch (Exception e) {
 			Logger.getLogger().write(e);
 		} finally {
@@ -130,25 +109,21 @@
 					moduleDelegates.add(moduleDelegate);
 			}
 		}
-		return moduleList;
-
+		return module;
 	}
 	
-	protected IModule[] createModules(IProject project) {
-
-		// List modules = createModules(nature);
-		ModuleCoreNature nature = null;
-		try {
-			nature = (ModuleCoreNature) project.getNature(IModuleConstants.MODULE_NATURE_ID);
-		} catch (CoreException e) {
-			Logger.getLogger().write(e);
-		}
-		if(nature == null) return new IModule[0];
-		List modules = createModules(nature);
-		if (modules == null)
-			return new IModule[0];
-		IModule[] moduleArray = new IModule[modules.size()];
-		modules.toArray(moduleArray);
-		return moduleArray;
+	/**
+	 * Returns the list of resources that the module should listen to
+	 * for state changes. The paths should be project relative paths.
+	 * Subclasses can override this method to provide the paths.
+	 *
+	 * @return a possibly empty array of paths
+	 */
+	protected IPath[] getListenerPaths() {
+		return new IPath[] {
+			new Path(".project"), // nature
+			new Path(".settings/.component"), // component
+			new Path(".settings/org.eclipse.wst.common.project.facet.core.xml") // facets
+		};
 	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/operation/StaticWebModuleCreationFacetOperation.java b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/operation/StaticWebModuleCreationFacetOperation.java
index 1fcd387..cb3f822 100644
--- a/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/operation/StaticWebModuleCreationFacetOperation.java
+++ b/plugins/org.eclipse.wst.web/static_web_project/org/eclipse/wst/web/internal/operation/StaticWebModuleCreationFacetOperation.java
@@ -10,9 +10,6 @@
  *******************************************************************************/
 package org.eclipse.wst.web.internal.operation;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -22,50 +19,45 @@
 import org.eclipse.wst.common.componentcore.datamodel.properties.IComponentCreationDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;
 import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelOperation;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
-import org.eclipse.wst.project.facet.IStaticWebFacetInstallDataModelProperties;
-import org.eclipse.wst.project.facet.StaticWebFacetInstallDataModelProvider;
+import org.eclipse.wst.project.facet.ISimpleWebFacetInstallDataModelProperties;
+import org.eclipse.wst.project.facet.SimpleWebFacetInstallDataModelProvider;
 
-public class StaticWebModuleCreationFacetOperation  extends AbstractDataModelOperation{
+public class StaticWebModuleCreationFacetOperation extends AbstractDataModelOperation {
 
-    public StaticWebModuleCreationFacetOperation(IDataModel dataModel) {
-        super(dataModel);
-    }
+	public StaticWebModuleCreationFacetOperation(IDataModel dataModel) {
+		super(dataModel);
+	}
 
-    public IStatus execute(IProgressMonitor monitor, IAdaptable info) {
+	public IStatus execute(IProgressMonitor monitor, IAdaptable info) {
 
 		IDataModel dm = DataModelFactory.createDataModel(new FacetProjectCreationDataModelProvider());
 		String projectName = model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME);
-		
+
 		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, projectName);
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_LOCATION,
-				model.getProperty(IComponentCreationDataModelProperties.LOCATION));
-		
-		List facetDMs = new ArrayList();
 
-		IDataModel newModel = setupWebInstallAction();
-		facetDMs.add(newModel);
+		FacetDataModelMap map = (FacetDataModelMap) dm.getProperty(IFacetProjectCreationDataModelProperties.FACET_DM_MAP);
+		map.add(setupWebInstallAction());
 
-		dm.setProperty(IFacetProjectCreationDataModelProperties.FACET_DM_LIST, facetDMs);
 		IStatus stat = OK_STATUS;
 		try {
 			stat = dm.getDefaultOperation().execute(monitor, info);
 		} catch (ExecutionException e) {
 			Logger.getLogger().logError(e);
 		}
-		return stat;    	
-    }
+		return stat;
+	}
 
 	protected IDataModel setupWebInstallAction() {
-		String versionStr = "1.0"; 
-		IDataModel webFacetInstallDataModel = DataModelFactory.createDataModel(new StaticWebFacetInstallDataModelProvider());
+		String versionStr = "1.0";
+		IDataModel webFacetInstallDataModel = DataModelFactory.createDataModel(new SimpleWebFacetInstallDataModelProvider());
 		webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_PROJECT_NAME, model.getStringProperty(IComponentCreationDataModelProperties.PROJECT_NAME));
 		webFacetInstallDataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, versionStr);
-		webFacetInstallDataModel.setProperty(IStaticWebFacetInstallDataModelProperties.CONTENT_DIR,
-				model.getStringProperty(ISimpleWebModuleCreationDataModelProperties.WEBCONTENT_FOLDER));
+		webFacetInstallDataModel.setProperty(ISimpleWebFacetInstallDataModelProperties.CONTENT_DIR, model.getStringProperty(ISimpleWebModuleCreationDataModelProperties.WEBCONTENT_FOLDER));
 
 		return webFacetInstallDataModel;
 	}
-}
+}
\ No newline at end of file
