diff --git a/gmf-notation/project-info/plan.xml b/gmf-notation/project-info/plan.xml
index 3e715e6..2afb207 100644
--- a/gmf-notation/project-info/plan.xml
+++ b/gmf-notation/project-info/plan.xml
@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
 <?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
 <plan xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml">
-   <release projectid="modeling.gmp.gmf-notation" version="1.5.0"/>
+   <release projectid="modeling.gmp.gmf-notation" version="1.6.0"/>
    <introduction>
-   		<html:p>This document lays out the feature and API set for the sixth release of the Eclipse Graphical Modeling Framework Notation (GMF Notation) Project, version 1.5.0.  This project plan inherits from the Modeling Project Plan, which should be referenced when consulting this individual project plan.</html:p>
+   		<html:p>This document lays out the feature and API set for the seventh release of the Eclipse Graphical Modeling Framework Notation (GMF Notation) Project, version 1.6.0.  This project plan inherits from the Modeling Project Plan, which should be referenced when consulting this individual project plan.</html:p>
    </introduction>
    <release_deliverables>
      <html:p>
     The release deliverables have the same form as is found in most Eclipse projects, namely:
 <html:ul>
-<html:li>GMF Notation source code release, available as versions tagged "R1_5" in the project's CVS repository.</html:li>
+<html:li>GMF Notation source code release, available as versions tagged "R1_6" in the project's CVS repository.</html:li>
 <html:li>GMF Notation SDK (includes sources, examples, and documentation) (downloadable zip and update site).</html:li>
 <html:li>GMF Notation Runtime binary distribution (downloadable zip and update site).</html:li>
 <html:li>GMF Notation Tests (downloadable zip and update site)</html:li>
@@ -18,44 +18,44 @@
     </release_deliverables>
    <release_milestones>
       <preamble>
-      	<html:p>Release milestones occur at roughly 6 week intervals and follow the Platform milestone releases by approximately 1 week; that is, until the final 3.7 release of the Platform, upon which GMF Notation and other projects will release simultaneously. It is anticipated that GMF Notation will synchronize its release milestones with the Indigo release schedule for +1 components.</html:p>
+      	<html:p>Release milestones occur at roughly 6 week intervals and follow the Platform milestone releases by approximately 1 week; that is, until the final 4.2 release of the Platform, upon which GMF Notation and other projects will release simultaneously. It is anticipated that GMF Notation will synchronize its release milestones with the Juno release schedule for +1 components.</html:p>
       </preamble>
-      <milestone date="08/16/2010" milestone="M1"></milestone>
-      <milestone date="09/27/2010" milestone="M2"></milestone>
-      <milestone date="11/08/2010" milestone="M3"></milestone>
-      <milestone date="12/13/2010" milestone="M4"></milestone>
-      <milestone date="01/31/2011" milestone="M5"></milestone>
-      <milestone date="03/14/2011" milestone="M6"><html:p>API freeze</html:p></milestone>
-      <milestone date="05/02/2011" milestone="M7"></milestone>
-      <milestone date="05/16/2011" milestone="RC1"></milestone>
-      <milestone date="05/23/2011" milestone="RC2"></milestone>
-      <milestone date="05/30/2011" milestone="RC3"></milestone>
-      <milestone date="06/06/2011" milestone="RC4"></milestone>
-      <milestone date="06/13/2011" milestone="RC5"></milestone>
-      <milestone date="06/22/2011" milestone="1.5.0"></milestone>
+      <milestone date="08/16/2011" milestone="M1"></milestone>
+      <milestone date="09/27/2011" milestone="M2"></milestone>
+      <milestone date="11/08/2011" milestone="M3"></milestone>
+      <milestone date="12/13/2011" milestone="M4"></milestone>
+      <milestone date="01/31/2012" milestone="M5"></milestone>
+      <milestone date="03/14/2012" milestone="M6"><html:p>API freeze</html:p></milestone>
+      <milestone date="05/02/2012" milestone="M7"></milestone>
+      <milestone date="05/16/2012" milestone="RC1"></milestone>
+      <milestone date="05/23/2012" milestone="RC2"></milestone>
+      <milestone date="05/30/2012" milestone="RC3"></milestone>
+      <milestone date="06/06/2012" milestone="RC4"></milestone>
+      <milestone date="06/13/2012" milestone="RC5"></milestone>
+      <milestone date="06/22/2012" milestone="1.6.0"></milestone>
       <postamble>
-      	<html:p>GMF Notation will produce maintenance releases to align with the Indigo SR releases, that includes the Eclipse Platform 3.7.1 and 3.7.2 releases. GMF Notation may produce interim maintenance releases in addition to these in order to satisfy clients requests.
+      	<html:p>GMF Notation will produce maintenance releases to align with the Juno SR releases, that includes the Eclipse Platform 4.2.1 and 4.2.2 releases. GMF Notation may produce interim maintenance releases in addition to these in order to satisfy clients requests.
 <html:ul>
-<html:li>9/22/2011 (last Friday of September) - GMF Notation 1.5.1 maintenance release (Indigo Service Release 1)</html:li>
-<html:li>2/23/2011 (last Friday of February) - GMF Notation 1.5.2 maintenance release (Indigo Service Release 2)</html:li>
-<html:li>A list of issues indicated for the 1.5.x maintenance stream can be found in Bugzilla, or by using links on maintenance stream build pages.</html:li>
+<html:li>9/22/2012 (last Friday of September) - GMF Notation 1.6.1 maintenance release (Juno Service Release 1)</html:li>
+<html:li>2/23/2013 (last Friday of February) - GMF Notation 1.6.2 maintenance release (Juno Service Release 2)</html:li>
+<html:li>A list of issues indicated for the 1.6.x maintenance stream can be found in Bugzilla, or by using links on maintenance stream build pages.</html:li>
 </html:ul> 
       	</html:p>
       </postamble>
    </release_milestones>
    <target_environments>
    		<html:p>In order to remain current, each Eclipse release targets reasonably current versions of the underlying operating environments.</html:p>
-   		<html:p>The GMF Notation project depends upon on the Platform and other projects, which are mostly "pure" Java. The 3.7 release of the Eclipse Platform Project is written and compiled against version 1.5 of the Java Platform APIs, and targeted to run on version 1.5 of the Java Runtime Environment, Standard Edition. GMF Notation will target the same Java version as EMF, which currently requires Java 1.5.</html:p>
-		<html:p>Eclipse Platform SDK 3.7 will be tested and validated on a number of reference platforms. GMF Notation will be tested and validated against a subset of those listed for the platform. Those available will be presented on the project download site.</html:p>
+   		<html:p>The GMF Notation project depends upon on the Platform and other projects, which are mostly "pure" Java. The 4.2 release of the Eclipse Platform Project is written and compiled against version 1.5 of the Java Platform APIs, and targeted to run on version 1.5 of the Java Runtime Environment, Standard Edition. GMF Notation will target the same Java version as EMF, which currently requires Java 1.5.</html:p>
+		<html:p>Eclipse Platform SDK 4.2 will be tested and validated on a number of reference platforms. GMF Notation will be tested and validated against a subset of those listed for the platform. Those available will be presented on the project download site.</html:p>
      <internationalization>
      	<html:p>The Eclipse Platform is designed as the basis for internationalized products. The user interface elements provided by the Eclipse SDK components, including dialogs and error messages, are externalized. The English strings are provided as the default resource bundles. As a result, the GMF Notation project will provide English strings in its default bundles and be localized to a subset of those locales offered by the Platform. This plan will be updated to indicate which locales will be provided and the time frame for availability.</html:p>
      </internationalization>
    </target_environments>
    <compatibility_with_previous_releases>
-     <html:p>Compatibility of Release 1.5</html:p>
+     <html:p>Compatibility of Release 1.6</html:p>
 	<html:p>The GMF Notation Project will be developed in parallel, and released simultaneously, with the following projects. As stated above, each milestone release of the GMF Notation Project will be compatible with the corresponding milestones for each of these projects, and delivered the appropriate offset.</html:p>
-	<html:ul><html:li>Eclipse Platform SDK version 3.7</html:li>
-		<html:li>Eclipse Modeling Framework (EMF) version 2.7</html:li>
+	<html:ul><html:li>Eclipse Platform SDK version 4.2</html:li>
+		<html:li>Eclipse Modeling Framework (EMF) version 2.8</html:li>
 	</html:ul>
 	<html:p>Therefore, the GMF Notation initial release will be compatible with these versions and will publish binary and source compatibilities with migration guides on subsequent releases.</html:p>
    </compatibility_with_previous_releases>
@@ -66,10 +66,17 @@
 				<html:a href="http://www.eclipse.org/org/councils/roadmap_v4_0/themesandpriorities.html">Eclipse Themes and Priorities</html:a>).
 			</html:p>
 		</preamble>
+		<theme name="Eclipse 3.8">
+			<description>
+				<html:div>
+					No support, no testing on 3.8
+                </html:div>
+			</description>
+		</theme>
     	<theme name="Release Currency">
-      		<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMP&amp;component=GMF-notation&amp;target_milestone=1.5.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=ingigo-" />
-      		<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;target_milestone=1.5.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=indigo-" />
-      		<deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=indigo-" />
+      		<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMP&amp;component=GMF-notation&amp;target_milestone=1.6.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=juno-" />
+      		<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;target_milestone=1.6.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=juno-" />
+      		<deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=juno-" />
     	</theme>
 	</themes_and_priorities>
  </plan>
diff --git a/gmf-runtime/project-info/plan.xml b/gmf-runtime/project-info/plan.xml
index abc2fc8..38aa03a 100644
--- a/gmf-runtime/project-info/plan.xml
+++ b/gmf-runtime/project-info/plan.xml
@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
 <?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
 <plan xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml">
-   <release projectid="modeling.gmp.gmf-runtime" version="1.5.0"/>
+   <release projectid="modeling.gmp.gmf-runtime" version="1.6.0"/>
    <introduction>
-   		<html:p>This document lays out the feature and API set for the sixth release of the Eclipse Graphical Modeling Framework Runtime (GMF Runtime) Project, version 1.5.0.  This project plan inherits from the Modeling Project Plan, which should be referenced when consulting this individual project plan.</html:p>
+   		<html:p>This document lays out the feature and API set for the seventh release of the Eclipse Graphical Modeling Framework Runtime (GMF Runtime) Project, version 1.5.0.  This project plan inherits from the Modeling Project Plan, which should be referenced when consulting this individual project plan.</html:p>
    </introduction>
    <release_deliverables>
      <html:p>
     The release deliverables have the same form as is found in most Eclipse projects, namely:
 <html:ul>
-<html:li>GMF Runtime source code release, available as versions tagged "R1_5" in the project's CVS repository.</html:li>
+<html:li>GMF Runtime source code release, available as versions tagged "R1_6" in the project's CVS repository.</html:li>
 <html:li>GMF Runtime SDK (includes sources, examples, and documentation) (downloadable zip and update site).</html:li>
 <html:li>GMF Runtime Runtime binary distribution (downloadable zip and update site).</html:li>
 <html:li>GMF Runtime Tests (downloadable zip and update site)</html:li>
@@ -18,47 +18,47 @@
     </release_deliverables>
    <release_milestones>
       <preamble>
-      	<html:p>Release milestones occur at roughly 6 week intervals and follow the Platform milestone releases by approximately 1 week; that is, until the final 3.7 release of the Platform, upon which GMF Runtime and other projects will release simultaneously. It is anticipated that GMF Runtime will synchronize its release milestones with the Indigo release schedule for +3 components.</html:p>
+      	<html:p>Release milestones occur at roughly 6 week intervals and follow the Platform milestone releases by approximately 1 week; that is, until the final 4.2 release of the Platform, upon which GMF Runtime and other projects will release simultaneously. It is anticipated that GMF Runtime will synchronize its release milestones with the Juno release schedule for +3 components.</html:p>
       </preamble>
-      <milestone date="08/18/2010" milestone="M1"></milestone>
-      <milestone date="09/29/2010" milestone="M2"></milestone>
-      <milestone date="11/10/2010" milestone="M3"></milestone>
-      <milestone date="12/15/2010" milestone="M4"></milestone>
-      <milestone date="02/02/2011" milestone="M5"></milestone>
-      <milestone date="03/16/2011" milestone="M6"><html:p>API freeze</html:p></milestone>
-      <milestone date="05/04/2011" milestone="M7"></milestone>
-      <milestone date="05/18/2011" milestone="RC1"></milestone>
-      <milestone date="05/25/2011" milestone="RC2"></milestone>
-      <milestone date="06/01/2011" milestone="RC3"></milestone>
-      <milestone date="06/08/2011" milestone="RC4"></milestone>
-      <milestone date="06/15/2011" milestone="RC5"></milestone>
-      <milestone date="06/22/2011" milestone="1.5.0"></milestone>
+      <milestone date="08/16/2011" milestone="M1"></milestone>
+      <milestone date="09/27/2011" milestone="M2"></milestone>
+      <milestone date="11/08/2011" milestone="M3"></milestone>
+      <milestone date="12/13/2011" milestone="M4"></milestone>
+      <milestone date="01/31/2012" milestone="M5"></milestone>
+      <milestone date="03/14/2012" milestone="M6"><html:p>API freeze</html:p></milestone>
+      <milestone date="05/02/2012" milestone="M7"></milestone>
+      <milestone date="05/16/2012" milestone="RC1"></milestone>
+      <milestone date="05/23/2012" milestone="RC2"></milestone>
+      <milestone date="05/30/2012" milestone="RC3"></milestone>
+      <milestone date="06/06/2012" milestone="RC4"></milestone>
+      <milestone date="06/13/2012" milestone="RC5"></milestone>
+      <milestone date="06/22/2012" milestone="1.6.0"></milestone>
       <postamble>
-      	<html:p>GMF Runtime will produce maintenance releases to align with the Indigo SR releases, that includes the Eclipse Platform 3.7.1 and 3.7.2 releases. GMF Runtime may produce interim maintenance releases in addition to these in order to satisfy clients requests.
+      	<html:p>GMF Runtime will produce maintenance releases to align with the Juno SR releases, that includes the Eclipse Platform 4.2.1 and 4.2.2 releases. GMF Runtime may produce interim maintenance releases in addition to these in order to satisfy clients requests.
 <html:ul>
-<html:li>9/22/2011 (last Friday of September) - GMF Runtime 1.5.1 maintenance release (Indigo Service Release 1)</html:li>
-<html:li>2/23/2011 (last Friday of February) - GMF Runtime 1.5.2 maintenance release (Indigo Service Release 2)</html:li>
-<html:li>A list of issues indicated for the 1.5.x maintenance stream can be found in Bugzilla, or by using links on maintenance stream build pages.</html:li>
+<html:li>9/22/2012 (last Friday of September) - GMF Runtime 1.6.1 maintenance release (Juno Service Release 1)</html:li>
+<html:li>2/23/2013 (last Friday of February) - GMF Runtime 1.6.2 maintenance release (Juno Service Release 2)</html:li>
+<html:li>A list of issues indicated for the 1.6.x maintenance stream can be found in Bugzilla, or by using links on maintenance stream build pages.</html:li>
 </html:ul> 
       	</html:p>
       </postamble>
    </release_milestones>
    <target_environments>
    		<html:p>In order to remain current, each Eclipse release targets reasonably current versions of the underlying operating environments.</html:p>
-   		<html:p>The Eclipse GMF Runtime project depends upon on the Platform and other projects, which are mostly "pure" Java. The 3.7 release of the Eclipse Platform Project is written and compiled against version 1.5 of the Java Platform APIs, and targeted to run on version 1.5 of the Java Runtime Environment, Standard Edition. GMF Runtime will target the same Java version as EMF, which currently requires Java 1.5.</html:p>
-		<html:p>Eclipse Platform SDK 3.7 will be tested and validated on a number of reference platforms. GMF Runtime will be tested and validated against a subset of those listed for the platform. Those available will be presented on the project download site.</html:p>
+   		<html:p>The Eclipse GMF Runtime project depends upon on the Platform and other projects, which are mostly "pure" Java. The 4.2 release of the Eclipse Platform Project is written and compiled against version 1.5 of the Java Platform APIs, and targeted to run on version 1.5 of the Java Runtime Environment, Standard Edition. GMF Runtime will target the same Java version as EMF, which currently requires Java 1.5.</html:p>
+		<html:p>Eclipse Platform SDK 4.2 will be tested and validated on a number of reference platforms. GMF Runtime will be tested and validated against a subset of those listed for the platform. Those available will be presented on the project download site.</html:p>
      <internationalization>
      	<html:p>The Eclipse Platform is designed as the basis for internationalized products. The user interface elements provided by the Eclipse SDK components, including dialogs and error messages, are externalized. The English strings are provided as the default resource bundles. As a result, the GMF Runtime project will provide English strings in its default bundles and be localized to a subset of those locales offered by the Platform. This plan will be updated to indicate which locales will be provided and the time frame for availability.</html:p>
      </internationalization>
    </target_environments>
    <compatibility_with_previous_releases>
-     <html:p>Compatibility of Release 1.5</html:p>
+     <html:p>Compatibility of Release 1.6</html:p>
 	<html:p>The GMF Runtime Project will be developed in parallel, and released simultaneously, with the following projects. As stated above, each milestone release of the GMF Runtime Project will be compatible with the corresponding milestones for each of these projects, and delivered the appropriate offset.</html:p>
-	<html:ul><html:li>Eclipse Platform SDK version 3.7</html:li>
-		<html:li>Eclipse Modeling Framework (EMF) version 2.7</html:li>
-		<html:li>Graphical Editing Framework (GEF) version 3.7</html:li>
+	<html:ul><html:li>Eclipse Platform SDK version 4.2</html:li>
+		<html:li>Eclipse Modeling Framework (EMF) version 2.8</html:li>
+		<html:li>Graphical Editing Framework (GEF) version 3.8</html:li>
 	</html:ul>
-	<html:p>Therefore, the GMF initial release will be compatible with these versions and will publish binary and source compatibilities with migration guides on subsequent releases.</html:p>
+	<html:p>Therefore, the GMF Runtime initial release will be compatible with these versions and will publish binary and source compatibilities with migration guides on subsequent releases.</html:p>
    </compatibility_with_previous_releases>
    <themes_and_priorities>
 		<preamble>
@@ -67,10 +67,17 @@
 				<html:a href="http://www.eclipse.org/org/councils/roadmap_v4_0/themesandpriorities.html">Eclipse Themes and Priorities</html:a>).
 			</html:p>
 		</preamble>
+		<theme name="Eclipse 3.8">
+			<description>
+				<html:div>
+					No support, no testing on 3.8
+                </html:div>
+			</description>
+		</theme>
     	<theme name="Release Currency">
-      		<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMP&amp;component=GMF-runtime&amp;target_milestone=1.5.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=ingigo-" />
-      		<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;target_milestone=1.5.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=indigo-" />
-      		<deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=indigo-" />
+      		<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMP&amp;component=GMF-runtime&amp;target_milestone=1.6.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=juno-" />
+      		<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;target_milestone=1.6.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=indigo&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=juno-" />
+      		<deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=GMF&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=juno-" />
     	</theme>
 	</themes_and_priorities>
  </plan>
