diff --git a/CLA.php b/CLA.php
index 4c2b9d9..624c40a 100644
--- a/CLA.php
+++ b/CLA.php
@@ -1,2 +1,16 @@
 <?php
+/**
+ * Copyright (c) 2013, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 header("Location: /legal/ECA.php");
\ No newline at end of file
diff --git a/CoO.php b/CoO.php
index 4d12a60..8f91077 100644
--- a/CoO.php
+++ b/CoO.php
@@ -1,2 +1,16 @@
 <?php
+/**
+ * Copyright (c) 2013, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 header("Location: /legal/ECA.php#text2");
\ No newline at end of file
diff --git a/DCO.php b/DCO.php
index cdac98c..4e7cc40 100644
--- a/DCO.php
+++ b/DCO.php
@@ -1,47 +1,48 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2016 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
+/**
+ * Copyright (c) 2016, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
- *    Christopher Guindon (Eclipse Foundation) - Initial implementation
- *******************************************************************************/
+ *   Christopher Guindon (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-  $App = new App();
-  $Nav = new Nav();
-  $Menu = new Menu();
+$App = new App();
+$Theme = $App->getThemeClass();
 
-  include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+include ($App->getProjectCommon());
 
-  # Begin: page-specific settings.  Change these.
-  $pageTitle     = "Developer Certificate of Origin";
-  $pageKeywords  = "certificate, Developer Certificate of Origin, contributor, legal, eclipse";
-  $pageAuthor    = "Mike Milinkovich";
+$pageTitle = "Developer Certificate of Origin";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("certificate, Developer Certificate of Origin, contributor, legal, eclipse");
+$Theme->setPageAuthor("Mike Milinkovich");
 
-  # Paste your HTML content between the EOHTML markers!
-  $html = '<div id="midcolumn">';
+// Paste your HTML content between the EOHTML markers!
+$html = '<div id="midcolumn">';
 
-  // Fetch DCO.HTML and return evertying in <body>
-  $document = new DOMDocument;
-  $new_document = new DOMDocument;
-  $document->loadHTML(file_get_contents('DCO.html'));
-  $body = $document->getElementsByTagName('body')->item(0);
-  foreach ($body->childNodes as $child){
-    $new_document->appendChild($new_document->importNode($child, true));
-  }
+// Fetch DCO.HTML and return evertying in <body>
+$document = new DOMDocument();
+$new_document = new DOMDocument();
+$document->loadHTML(file_get_contents('DCO.html'));
+$body = $document->getElementsByTagName('body')->item(0);
+foreach ($body->childNodes as $child) {
+  $new_document->appendChild($new_document->importNode($child, true));
+}
 
-  $html .= $new_document->saveHTML();
-  $html .= '</div>';
-  ob_start();
-  include('content/eca_sidebar.php');
-  $html .= ob_get_clean();
+$html .= $new_document->saveHTML();
+$html .= '</div>';
+ob_start();
+include ('content/eca_sidebar.php');
+$html .= ob_get_clean();
 
-  # Generate the web page
-  $App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
\ No newline at end of file
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/ECA.php b/ECA.php
index d4acb96..63b6e40 100644
--- a/ECA.php
+++ b/ECA.php
@@ -1,37 +1,38 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2016 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
+/**
+ * Copyright (c) 2016, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
- *    Christopher Guindon (Eclipse Foundation) - Initial implementation
- *******************************************************************************/
+ *   Christopher Guindon (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-  $App = new App();
-  $Nav = new Nav();
-  $Menu = new Menu();
+$App = new App();
+$Theme = $App->getThemeClass();
 
-  include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+include ($App->getProjectCommon());
 
-  # Begin: page-specific settings.  Change these.
-  $pageTitle     = "Eclipse Contributor Agreement";
-  $pageKeywords  = "certificate, ECA, contributor, legal, eclipse";
-  $pageAuthor    = "Mike Milinkovich";
+$pageTitle = "Eclipse Contributor Agreement";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("certificate, ECA, contributor, legal, eclipse");
+$Theme->setPageAuthor("Mike Milinkovich");
 
-  # Paste your HTML content between the EOHTML markers!
-  $html = '<div id="midcolumn">';
-  $html .= file_get_contents('ECA.html');
-  $html .= '</div>';
-  ob_start();
-  include('content/eca_sidebar.php');
-  $html .= ob_get_clean();
+// Paste your HTML content between the EOHTML markers!
+$html = '<div id="midcolumn">';
+$html .= file_get_contents('ECA.html');
+$html .= '</div>';
+ob_start();
+include ('content/eca_sidebar.php');
+$html .= ob_get_clean();
 
-  # Generate the web page
-  $App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
\ No newline at end of file
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/_projectCommon.php b/_projectCommon.php
index 7701245..08add00 100644
--- a/_projectCommon.php
+++ b/_projectCommon.php
@@ -1,44 +1,45 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2016, 2017 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
+/**
+ * Copyright (c) 2016, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
- *    Christopher Guindon (Eclipse Foundation) - Initial implementation
- *******************************************************************************/
+ *   Christopher Guindon (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-  # Set the theme for your project's web pages.
-  # See the Committer Tools "Phoenix" secion in the How Do I? for list of themes
-  # https://dev.eclipse.org/committers/
-  $theme = NULL;
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
 
-  # Define your project-wide Nav bars here.
-  # Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-  $Nav->addNavSeparator("About Us",   "/org/");
-  $Nav->addCustomNav("Annual Report", "/org/foundation/reports/annual_report.php", "_self", 1);
-  $Nav->addCustomNav("Foundation", "/org/foundation/", "_self", 1);
-  $Nav->addCustomNav("Governance", "/org/documents/", "_self", 1);
-  $Nav->addCustomNav("Legal Resources", "/legal/", "_self", 1);
-  $Nav->addCustomNav("Contact Us", "/org/foundation/contact.php", "_self", 1);
+$theme = NULL;
 
-  $Nav->addNavSeparator("ECA", "/legal/ECA.php");
-  $Nav->addCustomNav("Sign", "/contribute/cla", "_self", 1);
-  $Nav->addCustomNav("Validation Tool", "/contribute/cla", "_self", 1);
-  
-  $Nav->addNavSeparator("EPL-2.0",   "/legal/epl-2.0");
-  $Nav->addCustomNav("Plain HTML", "/org/documents/epl-2.0/EPL-2.0.html", "_self", 1);
-  $Nav->addCustomNav("Plain Text", "/org/documents/epl-2.0/EPL-2.0.txt", "_self", 1);
-  $Nav->addCustomNav("PDF", "/org/documents/epl-2.0/EPL-2.0.pdf", "_self", 1);
-  $Nav->addCustomNav("FAQ", "/legal/epl-2.0/faq.php", "_self", 1);
-  
-  $Nav->addNavSeparator("EPL-1.0",   "/org/documents/epl-v10.php");
-  $Nav->addCustomNav("Plain HTML", "/org/documents/epl-v10.html", "_self", 1);
-  $Nav->addCustomNav("FAQ", "/legal/eplfaq.php", "_self", 1);
-  
-  $Nav->addNavSeparator("Licenses",   "/legal/licenses.php");
-  $Nav->addCustomNav("Approved 3rd Party", "/legal/licenses.php#approved", "_self", 1);
-  $Nav->addCustomNav("Non Approved", "/legal/licenses.php#nonapproved", "_self", 1);
-  $Nav->addCustomNav("Docs &amp; examples", "/legal/noncodelicenses.php", "_self", 1);
+$Nav = new Nav();
+$Nav->addNavSeparator("About Us", "/org/");
+$Nav->addCustomNav("Annual Report", "/org/foundation/reports/annual_report.php", "_self", 1);
+$Nav->addCustomNav("Foundation", "/org/foundation/", "_self", 1);
+$Nav->addCustomNav("Governance", "/org/documents/", "_self", 1);
+$Nav->addCustomNav("Legal Resources", "/legal/", "_self", 1);
+$Nav->addCustomNav("Contact Us", "/org/foundation/contact.php", "_self", 1);
+
+$Nav->addNavSeparator("ECA", "/legal/ECA.php");
+$Nav->addCustomNav("Sign", "/contribute/cla", "_self", 1);
+$Nav->addCustomNav("Validation Tool", "/contribute/cla", "_self", 1);
+
+$Nav->addNavSeparator("EPL-2.0", "/legal/epl-2.0");
+$Nav->addCustomNav("Plain HTML", "/org/documents/epl-2.0/EPL-2.0.html", "_self", 1);
+$Nav->addCustomNav("Plain Text", "/org/documents/epl-2.0/EPL-2.0.txt", "_self", 1);
+$Nav->addCustomNav("PDF", "/org/documents/epl-2.0/EPL-2.0.pdf", "_self", 1);
+$Nav->addCustomNav("FAQ", "/legal/epl-2.0/faq.php", "_self", 1);
+
+$Nav->addNavSeparator("EPL-1.0", "/org/documents/epl-v10.php");
+$Nav->addCustomNav("Plain HTML", "/org/documents/epl-v10.html", "_self", 1);
+$Nav->addCustomNav("FAQ", "/legal/eplfaq.php", "_self", 1);
+
+$Nav->addNavSeparator("Licenses", "/legal/licenses.php");
+$Nav->addCustomNav("Approved 3rd Party", "/legal/licenses.php#approved", "_self", 1);
+$Nav->addCustomNav("Non Approved", "/legal/licenses.php#nonapproved", "_self", 1);
+$Nav->addCustomNav("Docs &amp; examples", "/legal/noncodelicenses.php", "_self", 1);
diff --git a/approvedcontentlicenses.php b/approvedcontentlicenses.php
index c73f9ee..4e83144 100644
--- a/approvedcontentlicenses.php
+++ b/approvedcontentlicenses.php
@@ -1,48 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Approved Licenses for Non-Code Content";
-	$pageKeywords	= "legal, guide, summary";
-	$pageAuthor		= "Mike Milinkovich";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-    <div id="midcolumn">
-    <h1>$pageTitle</h1>
-    <p>This document lists the licenses approved by the Board of Directors for use for 
-    Non-Code Content (as that term is defined in the <a href="termsofuse.php">Eclipse.org Terms of Use</a>). 
-    They are:</p>
-    <ul>
-    <li>Eclipse Public License 1.0</li>
-    </ul> 
-	  		
-  	</div>
+include ($App->getProjectCommon());
 
-EOHTML;
+$pageTitle = "Approved Licenses for Non-Code Content";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, guide, summary");
+$Theme->setPageAuthor("Mike Milinkovich");
 
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/clafaq.php b/clafaq.php
index 64ff9ac..da8c65c 100644
--- a/clafaq.php
+++ b/clafaq.php
@@ -1,15 +1,18 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2016 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
- *    Mike Milinkovich (Eclipse Foundation) - Initial implementation
- *    Christopher Guindon (Eclipse Foundation)
- *******************************************************************************/
-  // Bug 495498 - [CLA] Implement new version of CLA
-  // Redirect to the new ECAfaq page.
-  header('Location: ecafaq.php');
\ No newline at end of file
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Christopher Guindon (Eclipse Foundation)
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+// Bug 495498 - [CLA] Implement new version of CLA
+// Redirect to the new ECAfaq page.
+header('Location: ecafaq.php');
\ No newline at end of file
diff --git a/committer_process/_projectCommon.php b/committer_process/_projectCommon.php
deleted file mode 100644
index ec8b856..0000000
--- a/committer_process/_projectCommon.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-	# Set the theme for your project's web pages.
-	# See the Committer Tools "Phoenix" secion in the How Do I? for list of themes
-	# https://dev.eclipse.org/committers/ 
-	$theme = "solstice";
-
-	# Define your project-wide Nav bars here.
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	$Nav->addNavSeparator("About Us", 	"../../org/");
-	$Nav->addCustomNav("Foundation", "../../org/foundation/", "_self", 1);	
-	$Nav->addCustomNav("Governance", "../../org/documents/", "_self", 1);
-	$Nav->addCustomNav("Legal Resources", "../", "_self", 1);
-	$Nav->addCustomNav("Press Releases", "../../community/news/eclipsenews.php", "_self", 1);
-	$Nav->addCustomNav("Contact Us", "../../org/foundation/contact.php", "_self", 1);
-
-?>
diff --git a/committer_process/individual_committer_questionnaire.php b/committer_process/individual_committer_questionnaire.php
index dec0e1a..26a6e5e 100644
--- a/committer_process/individual_committer_questionnaire.php
+++ b/committer_process/individual_committer_questionnaire.php
@@ -1,3 +1,17 @@
 <?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 header("Location:http://portal.eclipse.org");
-?>
+
diff --git a/committer_process/member_committer_questionnaire.php b/committer_process/member_committer_questionnaire.php
index 934ec9a..d0b8088 100644
--- a/committer_process/member_committer_questionnaire.php
+++ b/committer_process/member_committer_questionnaire.php
@@ -1,3 +1,16 @@
 <?php
-header("Location:http://portal.eclipse.org");
-?>
\ No newline at end of file
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+header("Location:http://portal.eclipse.org");
\ No newline at end of file
diff --git a/committerguidelines.php b/committerguidelines.php
index 325d2ce..4455744 100644
--- a/committerguidelines.php
+++ b/committerguidelines.php
@@ -1,56 +1,53 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2005,2017 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *******************************************************************************/
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
-$App = new App();
-$Nav = new Nav();
-$Menu = new Menu();
-include($App->getProjectCommon());
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-$pageTitle 		= "Committer Due Diligence Guidelines";
-$pageKeywords	= "legal, foundation, committer, committers, diligence, guidelines, IP, intellectual property, policy, procedure";
-$pageAuthor		= "Mike Milinkovich";
+$App = new App();
+$Theme = $App->getThemeClass();
+
+include ($App->getProjectCommon());
+
+$pageTitle = "Committer Due Diligence Guidelines";
+
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, foundation, committer, committers, diligence, guidelines, IP, intellectual property, policy, procedure");
+$Theme->setPageAuthor("Mike Milinkovich");
 
 // FIXME Workaround because I can't get Asciidoctor to generate embeddable HTML
-function getBodyContent($path)
-{
-    $DOMDocument = new DOMDocument();
-    $DOMDocument->loadHTMLFile($path);
-    $body = $DOMDocument->getElementsByTagName('body')->item(0);
-    $content = "";
-    foreach ($body->childNodes as $childNode) {
-        $content .= $DOMDocument->saveHTML($childNode);
-    }
-    return $content;
+function getBodyContent($path) {
+  $DOMDocument = new DOMDocument();
+  $DOMDocument->loadHTMLFile($path);
+  $body = $DOMDocument->getElementsByTagName('body')->item(0);
+  $content = "";
+  foreach ($body->childNodes as $childNode) {
+    $content .= $DOMDocument->saveHTML($childNode);
+  }
+  return $content;
 }
 
-ob_start(); ?>
-
-<div id="midcolumn">
-	<div class="homeitem3col">
-		<?php print getBodyContent(dirname(__FILE__) . '/documents/html/committers-dd.html'); ?>
-	</div>
-</div>
-
-<!-- <div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-			<li><a href="https://projects.eclipse.org/user/cla/validate>CLA Validator Tool</a></li>
-			</ul>
-		</div>
-	</div> -->
-
-<?php
-	$html = ob_get_contents();
-	ob_end_clean();
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-
+ob_start();
 ?>
+<div id="midcolumn">
+  <div class="homeitem3col">
+    <?php print getBodyContent(dirname(__FILE__) . '/documents/html/committers-dd.html'); ?>
+  </div>
+</div>
+<?php
+$html = ob_get_contents();
+ob_end_clean();
+
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/content/eca_sidebar.php b/content/eca_sidebar.php
index dfea2d7..cdbbfe3 100644
--- a/content/eca_sidebar.php
+++ b/content/eca_sidebar.php
@@ -1,32 +1,43 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2016 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
+/**
+ * Copyright (c) 2016, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
- *    Christopher Guindon (Eclipse Foundation) - Initial implementation
- *******************************************************************************/
+ *   Christopher Guindon (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 ?>
 <div id="rightcolumn">
   <div class="sideitem">
     <h6>Related Links</h6>
     <ul>
-    <li><a href="/legal/ECA.php">Eclipse Contributor Agreement</a> [<a href="/legal/ECA.html">html</a>]</li>
-    <li><a href="/legal/ecafaq.php">ECA FAQ</a></li>
-    <li><a href="/legal/DCO.php">Developer Certificate of Origin</a> [<a href="/legal/DCO.html">html</a>]</li>
-    <li><a href="/legal/index.php">Legal resources</a></li>
-    <li><a href="/legal/guidetolegaldoc.php">Guide to legal documents</a></li>
-    <li><a href="/legal/index.php#Committers" class=jump>Committer Resources</a></li>
-    <li><a href="http://wiki.eclipse.org/Development_Resources/Contributing_via_Git">Contributing via Git</a></li>
+      <li><a href="/legal/ECA.php">Eclipse Contributor Agreement</a> [<a
+        href="/legal/ECA.html"
+      >html</a>]</li>
+      <li><a href="/legal/ecafaq.php">ECA FAQ</a></li>
+      <li><a href="/legal/DCO.php">Developer Certificate of Origin</a> [<a
+        href="/legal/DCO.html"
+      >html</a>]</li>
+      <li><a href="/legal/index.php">Legal resources</a></li>
+      <li><a href="/legal/guidetolegaldoc.php">Guide to legal documents</a></li>
+      <li><a href="/legal/index.php#Committers" class=jump>Committer Resources</a></li>
+      <li><a
+        href="http://wiki.eclipse.org/Development_Resources/Contributing_via_Git"
+      >Contributing via Git</a></li>
     </ul>
-    <p>To complete and submit a ECA, log into the <a href="/contribute/cla">Eclipse projects forge</a>
-    (you will need to create an account with the Eclipse Foundation if you have not
-    already done so); click on "Eclipse Contributor Agreement"; and Complete the form.
-    Be sure to use the same email address when you register for the
-    account that you intend to use when you commit to Git.
+    <p>
+      To complete and submit a ECA, log into the <a href="/contribute/cla">Eclipse
+        projects forge</a> (you will need to create an account with the Eclipse
+      Foundation if you have not already done so); click on "Eclipse Contributor
+      Agreement"; and Complete the form. Be sure to use the same email address
+      when you register for the account that you intend to use when you commit
+      to Git.
     </p>
   </div>
 </div>
\ No newline at end of file
diff --git a/content/en_approvedcontentlicenses.php b/content/en_approvedcontentlicenses.php
new file mode 100644
index 0000000..1e36f46
--- /dev/null
+++ b/content/en_approvedcontentlicenses.php
@@ -0,0 +1,27 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>
+    This document lists the licenses approved by the Board of Directors for use
+    for Non-Code Content (as that term is defined in the <a
+      href="termsofuse.php"
+    >Eclipse.org Terms of Use</a>). They are:
+  </p>
+  <ul>
+    <li>Eclipse Public License 1.0</li>
+  </ul>
+</div>
\ No newline at end of file
diff --git a/content/en_copyright.php b/content/en_copyright.php
new file mode 100644
index 0000000..419dc6a
--- /dev/null
+++ b/content/en_copyright.php
@@ -0,0 +1,57 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1>Copyright Agent</h1>
+  <p>We respect the intellectual property rights of others, and require that the
+    people who use the Site do the same. We also maintain a policy under which
+    the Web Site use privileges of users who are repeat infringers of
+    intellectual property rights are terminated in appropriate circumstances. If
+    you believe that your work has been copied in a way that constitutes
+    copyright infringement, please forward the following information to
+    Eclipse's Copyright Agent, designated as such pursuant to the Digital
+    Millennium Copyright Act, 17 U.S.C. &#167; 512(c)(2), named below:</p>
+
+  <ul>
+    <li>Your address, telephone number, and email address;</li>
+    <li>A description of the copyrighted work that you claim has been infringed;
+    </li>
+    <li>A description of where the alleged infringing material is located;</li>
+    <li>A statement by you that you have a good faith belief that the disputed
+      use is not authorized by the copyright owner, its agent, or the law;</li>
+    <li>An electronic or physical signature of the person authorized to act on
+      behalf of the owner of the copyright interest; and</li>
+    <li>A statement by you, made under penalty of perjury, that the above
+      information in your Notice is accurate and that you are the copyright
+      owner or authorized to act on the copyright owner's behalf.</li>
+  </ul>
+
+  <h3>Copyright Agent:</h3>
+  <p>Manager, Intellectual Property<br /> Eclipse Foundation, Inc.<br /> 102
+  Centrepointe Drive<br /> Ottawa, Ontario<br /> Canada<br /> K2G 6B1<br /> <br />
+  Phone: +1.613.224.9461<br /> Fax: +1.212.918.1619<br /> Email:
+  license@eclipse.org
+  </p>
+  <br />
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Related Links</h6>
+    <ul>
+      <li><a href="index.php">Legal resources</a></li>
+      <li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_ecafaq.php b/content/en_ecafaq.php
new file mode 100644
index 0000000..dd1d4f0
--- /dev/null
+++ b/content/en_ecafaq.php
@@ -0,0 +1,224 @@
+<?php
+/**
+ * Copyright (c) 2016, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ * Christopher Guindon (Eclipse Foundation)
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>Last updated August 10, 2016</p>
+  <p>
+    The <a href="ECA.php">Eclipse Contributor Agreement</a> (ECA) is a key
+    document in the process of managing intellectual property contributions to
+    Eclipse projects. This FAQ is intended to help explain what they are, and
+    how they are used.
+  </p>
+  <div class="panel-group" id="accordion" role="tablist"
+    aria-multiselectable="true"
+  >
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingOne">
+        <h4 class="panel-title">
+          <a role="button" data-toggle="collapse" data-parent="#accordion"
+            href="#collapseOne" aria-expanded="true" aria-controls="collapseOne"
+          > 1. What does the ECA do? </a>
+        </h4>
+      </div>
+      <div id="collapseOne" class="panel-collapse collapse in" role="tabpanel"
+        aria-labelledby="headingOne"
+      >
+        <div class="panel-body">The purpose of the ECA is to provide a written
+          record that you have agreed to provide your contributions of code and
+          documentation under the licenses used by the Eclipse project(s) you're
+          contributing to. It also makes it clear that you are promising that
+          what you are contributing to Eclipse is code that you wrote, and you
+          have the necessary rights to contribute it to our projects. And
+          finally, it documents a commitment from you that your open source
+          contributions will be permanently on the public record.</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingTwo">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseTwo" aria-expanded="false"
+            aria-controls="collapseTwo"
+          > 2. Why is a ECA necessary? </a>
+        </h4>
+      </div>
+      <div id="collapseTwo" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingTwo"
+      >
+        <div class="panel-body">It's basically about documenting the provenance
+          of all of the intellectual property coming into Eclipse. We want to
+          have a clear record that you have agreed to the terms under which the
+          Eclipse community has agreed to accept contributions.</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingThree">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseThree" aria-expanded="false"
+            aria-controls="collapseThree"
+          > 3. Does this means that the Eclipse Foundation will own my code? </a>
+        </h4>
+      </div>
+      <div id="collapseThree" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingThree"
+      >
+        <div class="panel-body">No. The ECA does not include a license or
+          assignment to the Eclipse Foundation. Unlike many other open source
+          communities or projects, Eclipse simply wants you to license your
+          contributions under the open source license(s) used by the project. So
+          you (or your employer) will continue to own your code.</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingFour">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseFour" aria-expanded="false"
+            aria-controls="collapseFour"
+          > 4. Why do you need to know my personal information? </a>
+        </h4>
+      </div>
+      <div id="collapseFour" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingFour"
+      >
+        <div class="panel-body">As part of our open source project
+          recordkeeping, we want to be able to link every line of code to the
+          people who contributed them. In the unlikely event of a dispute over
+          authorship or copyright provenance, Eclipse needs to be able to
+          demonstrate when the code arrived at Eclipse, how we acquired the
+          rights to that code, and who wrote it</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingFive">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseFive" aria-expanded="false"
+            aria-controls="collapseFive"
+          > 5. How long is the ECA good for? </a>
+        </h4>
+      </div>
+      <div id="collapseFive" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingFive"
+      >
+        <div class="panel-body">The ECA is good for three years, after which it
+          will be expired and you will be asked to complete a new one. However,
+          if your personal information changes (e.g. your address or your
+          employer), we ask that you invalidate your current ECA and complete a
+          new one.</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingSix">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseSix" aria-expanded="false"
+            aria-controls="collapseSix"
+          > 6. Does the ECA replace my committer agreement? </a>
+        </h4>
+      </div>
+      <div id="collapseSix" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingSix"
+      >
+        <div class="panel-body">No. Your Committer Agreement is the agreement
+          that allows you to have write access to the Eclipse Foundation source
+          code repositories. The ECA is intended for people who are not
+          committers who wish to make contributions to Eclipse projects.</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingSeven">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseSeven" aria-expanded="false"
+            aria-controls="collapseSeven"
+          > 7. I am an Eclipse committer. Do I need to sign a ECA? </a>
+        </h4>
+      </div>
+      <div id="collapseSeven" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingSeven"
+      >
+        <div class="panel-body">
+          Maybe. You do not need to sign a ECA to work on the projects for which
+          you are a committer. However, if you want to make contributions to an
+          Eclipse project for which you are <strong>not</strong> a committer,
+          you will need a ECA.
+        </div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingEight">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseEight" aria-expanded="false"
+            aria-controls="collapseEight"
+          > 8. What happens if I don't sign the ECA? </a>
+        </h4>
+      </div>
+      <div id="collapseEight" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingEight"
+      >
+        <div class="panel-body">Nothing, except you won't be allowed to
+          contribute to open source projects at Eclipse</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingNine">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseNine" aria-expanded="false"
+            aria-controls="collapseNine"
+          > 9. Eclipse has been around a long time. Why are you doing ECAs now?
+          </a>
+        </h4>
+      </div>
+      <div id="collapseNine" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingNine"
+      >
+        <div class="panel-body">We want to make it easier for you to contribute
+          to Eclipse projects. Previously, we have been asking contributors to
+          agree to the equivalent of the ECA via Bugzilla or Gerrit on each and
+          every contribution. Moving to ECAs is intended to streamline that
+          process, and make it easier for contributions to be accepted by
+          Eclipse projects.</div>
+      </div>
+    </div>
+    <div class="panel panel-info">
+      <div class="panel-heading" role="tab" id="headingTen">
+        <h4 class="panel-title">
+          <a class="collapsed" role="button" data-toggle="collapse"
+            data-parent="#accordion" href="#collapseTen" aria-expanded="false"
+            aria-controls="collapseTen"
+          > 10. How do I sign a ECA? </a>
+        </h4>
+      </div>
+      <div id="collapseTen" class="panel-collapse collapse" role="tabpanel"
+        aria-labelledby="headingTen"
+      >
+        <div class="panel-body">
+          Log into the <a href="http://www.eclipse.org/contribute/cla">Eclipse
+            projects forge</a> (you will need to create an account with the
+          Eclipse Foundation if you have not already done so); click on "Eclipse
+          Contributor Agreement"; and Complete the form. Be sure to use the same
+          email address when you register for the account that you intend to use
+          on Git commit records.
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_eplfaq.php b/content/en_eplfaq.php
new file mode 100644
index 0000000..bfb125f
--- /dev/null
+++ b/content/en_eplfaq.php
@@ -0,0 +1,430 @@
+<?php
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>
+    <strong>Please see the <a
+      href="https://www.eclipse.org/org/documents/epl-2.0/faq.php"
+    >Eclipse Public License 2.0 FAQ</a>.
+    </strong>
+  </p>
+  <p>
+    <strong>For informational purposes only.</strong>
+  </p>
+  <p>
+    This FAQ attempts to provide answers to commonly asked questions related to
+    <em>the <a href="../org/documents/epl-v10.php">Eclipse Public License 1.0
+        (EPL)</a></em>. It is provided for informational purposes only. It is
+    not part of, nor does it modify, amend, or supplement the terms of the EPL.
+    The EPL is a legal agreement that governs the rights granted to material
+    licensed under it, so please read it carefully. If there is any conflict
+    between this FAQ and the EPL, the terms of the EPL shall govern. This FAQ
+    should not be regarded as legal advice. If you need legal advice, you must
+    contact your own lawyer.
+  </p>
+  <div class="homeitem3col">
+    <h3>Table of Contents</h3>
+    <ol>
+      <li><a href="#CPLEPL">What is the relationship between the CPL and the EPL
+          1.0?</a></li>
+      <li><a href="#WHYEPL">Why was the EPL 1.0 written?</a></li>
+      <li><a href="#EPLDIFFER">Specifically how does the EPL 1.0 differ from the
+          CPL?</a></li>
+      <li><a href="#EPLVERSION">What is the latest version of the EPL</a></li>
+      <li><a href="#MEMAPPROVE">Do all Eclipse Foundation members approve of the
+          EPL?</a></li>
+      <li><a href="#TRANSITION">How and when will the Eclipse Foundation
+          transition from the CPL to the EPL 1.0?</a></li>
+      <li><a href="#EPLOSI">Is the EPL approved by the Open Source Initiative
+          (OSI)?</a></li>
+      <li><a href="#LICAPP">What is required for OSI license approval?</a></li>
+      <li><a href="#BUSADVOS">What are the business advantages of the Open
+          Source model?</a></li>
+      <li><a href="#TECHADVOS">What are the technical advantages of the Open
+          Source model?</a></li>
+      <li><a href="#PARTIESEPL">How are the parties defined in the EPL 1.0?</a></li>
+      <li><a href="#ANONCONTR">Can a Contributor remain anonymous?</a></li>
+      <li><a href="#RECRIGHTS">What rights do Contributors grant Recipients
+          under EPL 1.0?</a></li>
+      <li><a href="#USEINANOTHER">Does the EPL 1.0 allow me to take the Source
+          Code for a Program licensed under it and include all or part of it in
+          another program licensed under the GPL, BSD license or other Open
+          Source license?</a></li>
+      <li><a href="#COMPILEWOMOD">Can I take a Program licensed under the EPL
+          1.0, compile it without modification, and commercially license the
+          result?</a></li>
+      <li><a href="#SOURCEWOBJ">Do I need to include the source code for such
+          Program with the object code distribution?</a></li>
+      <li><a href="#PROPPROD">When I incorporate a portion of a Program licensed
+          under the EPL 1.0 into my own proprietary product distributed in
+          object code form, can I use a single license for the full product, in
+          other words, covering the portion of the Program plus my own code?</a></li>
+      <li><a href="#AGREESTEWARD">The EPL states that it can be changed by the
+          Agreement Steward. Does a Contributor have the choice of
+          redistributing a previously distributed Program under the old or the
+          new version of the EPL?</a></li>
+      <li><a href="#MODNODIST">If I modify a Program licensed under the EPL, but
+          never distribute it to anyone else, do I have to make my modifications
+          available to others?</a></li>
+      <li><a href="#MODDIST">If I modify a Program licensed under the EPL and
+          distribute the object code of the modified Program for free, must I
+          make the source code available?</a></li>
+      <li><a href="#MODULEDIST">If I write a module to add to a Program licensed
+          under the EPL and distribute the object code of the module along with
+          the rest of the Program, must I make the source code to my module
+          available in accordance with the terms of the EPL?</a></li>
+      <li><a href="#SRCREDIST">What are my obligations if I copy source code
+          obtained from Eclipse.org and licensed under the Eclipse Public
+          License and include it in my product that I then distribute?</a></li>
+      <li><a href="#EPLWARRANTY">Does the EPL offer any warranty with regard to
+          the Program?</a></li>
+      <li><a href="#GETANSWER">This document does not have the answer to my
+          question. How can I get my question answered?</a></li>
+      <li><a href="#DERIV">Some open source software communities specify what
+          they mean by a &quot;derivative work&quot;. Does the Eclipse
+          Foundation have a position on this?</a></li>
+      <li><a href="#LINK">Some free software communities say that linking to
+          their code automatically means that your program is a derivative work.
+          Is this the position of the Eclipse Foundation?</a></li>
+      <li><a href="#EXAMPLE">I&lsquo;m a programmer not a lawyer, can you give
+          me a clear cut example of when something is or is not a derivative
+          work?</a></li>
+      <li><a href="#USEEPL">I am starting my own open source software project.
+          Does the Eclipse Foundation allow me to use the EPL for my project?</a></li>
+      <li><a href="#CODEGEN">Many Eclipse tools and wizards use code templates
+          which are included in the application that is generated. Is the code
+          generated by these tools considered a derivative work that must be
+          licensed under the EPL?</a></li>
+      <li><a href="#3RDPARTY">What licenses are acceptable for third-party code
+          redistributed by Eclipse projects?</a></li>
+      <li><a href="#OSICOMPLIANT">Is an OSI-compliant license a requirement for
+          all third-party code redistributed by Eclipse projects?</a></li>
+      <li><a href="#GPLCOMPATIBLE">Are the Eclipse Public License (EPL) 1.0 and
+          the General Public License (GPL) compatible?</a></li>
+      <li><a href="#DUALLIC">For dual-licensed projects, which license terms
+          apply?</a></li>
+    </ol>
+  </div>
+  <h3>Frequently Asked Questions</h3>
+  </blockquote>
+  <ol>
+    <li><strong><a name="CPLEPL">What is the relationship between IBM&rsquo;s
+          Common Public License (CPL) and the Eclipse Public License 1.0 (EPL)?</a></strong><br />
+      </b>The Eclipse SDK codebase was originally distributed under the CPL. The
+      EPL 1.0 was derived from <a
+      href="http://www-128.ibm.com/developerworks/library/os-cpl.html"
+      target="_blank"
+    >CPL version 1.0</a>. As a result, much of the information provided in the <a
+      href="http://www.ibm.com/developerworks/opensource/library/os-cplfaq/index.html"
+      target="_blank"
+    >Common Public License (CPL) Frequently Asked Questions</a> document is
+      relevant to the EPL, as well. The purpose of this FAQ is to highlight the
+      differences.<br /> <br /></li>
+    <li><strong><a name="WHYEPL">Why was the EPL 1.0 written?</a></strong><br />
+      The EPL 1.0 was written specifically for the <a href="../org/"
+      target="_top"
+    >Eclipse Foundation</a>. First, it changes the Agreement Steward, formerly
+      IBM for the CPL, to now be the Eclipse Foundation for the EPL. Second, it
+      addresses concerns some Eclipse Foundation members had with how the CPL
+      deals with possible patent litigation.<br /> <br /></li>
+    <li><strong><a name="EPLDIFFER">Specifically how does the EPL 1.0 differ
+          from the CPL?</a><br /> </strong>Section 7 of the CPL contained the
+      following language:<br /> <br /> <em>&quot;If Recipient institutes patent
+        litigation against a Contributor with respect to a patent applicable to
+        software (including a cross-claim or counterclaim in a lawsuit), then
+        any patent licenses granted by that Contributor to such Recipient under
+        this Agreement shall terminate as of the date such litigation is filed.
+        In addition, 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&rsquo;s patent(s),
+        then such Recipient&rsquo;s rights granted under Section 2(b) shall
+        terminate as of the date such litigation is filed.&quot;<br /> <br />
+    </em> The first sentence was removed in the EPL 1.0. Many members and
+      prospective members believed that the first sentence was overly broad and
+      viewed it as an inhibitor to the continued growth of the Eclipse
+      eco-system. The second sentence remains unchanged in the EPL 1.0.<br /> <br />
+      The current <a href="../org/documents/Eclipse_IP_Policy.pdf">Eclipse
+        Foundation Intellectual Property Policy</a> further clarifies the
+      general principles under which the Eclipse Foundation shall accept
+      contributions, license contributions, license materials owned by the
+      Eclipse Foundation, and manage other intellectual property matters.<br />
+      <br /></li>
+    <li><strong><a name="EPLVERSION">What is the latest version of the EPL?</a><br />
+    </strong><a href="epl-2.0">Version 2.0</a> is the latest version of the EPL.
+      Please see the <a
+      href="https://www.eclipse.org/org/documents/epl-2.0/faq.php"
+    >Eclipse Public License 2.0 FAQ</a>.<br /> <br /></li>
+    <li><strong><a name="MEMAPPROVE">Do all Eclipse Foundation members approve
+          of the EPL?</a><br /> </strong>Yes, the Eclipse Foundation membership
+      approved the EPL 1.0 unanimously. Future members must agree to abide by
+      the EPL and the Intellectual Property Policy as part of joining the
+      Eclipse Foundation and signing the <a
+      href="../org/documents/Eclipse%20MEMBERSHIP%20AGMT%202003_11_10%20Final.pdf"
+    >Eclipse Foundation Membership Agreement</a>.<br /> <br /></li>
+    <li><strong><a name="TRANSITION">How and when will the Eclipse Foundation
+          transition from the CPL to the EPL 1.0?</a><br /> </strong>For
+      details, see the <a href="cpl2epl/CPL2EPLTransitionPlan.pdf">CPL to EPL
+        Transition Plan</a> (.pdf) and the <a href="cpl2epl/cpl2eplfaq.php">CPL
+        to EPL Transition Plan FAQ</a>.<br /> <br /></li>
+    <li><strong><a name="EPLOSI">Is the EPL approved by the Open Source
+          Initiative (OSI)?</a><br /></strong> Yes, the EPL has been approved.
+      Version 1.0 was approved in May 2004. See the complete <a
+      href="http://opensource.org/licenses/" target="_blank"
+    >list of OSI-approved licenses</a>.<br /> <br /></li>
+    <li><strong><a name="LICAPP">What is required for OSI license approval?</a><br /></strong>
+      A license qualifies for OSI approval if it conforms to the OSI&rsquo;s
+      &quot;Open Source Definition&quot; or &quot;OSD.&quot; The OSD covers nine
+      topics of concern. Chief among these is the requirement that a license not
+      restrict any party from selling or giving away the software. Further, the
+      Program must include source code, must allow distribution in source code
+      as well as compiled form, and must allow modifications and derived works.
+      Find more information on the <a
+      href="http://www.opensource.org/docs/definition.php" target="_blank"
+    >OSD</a> at opensource.org.<br /> <br /></li>
+    <li><strong><a name="BUSADVOS">What are the business advantages of the Open
+          Source model?<br /></strong> </a>An Open Source community provides a
+      way for individuals and companies to collaborate on projects that would be
+      difficult to achieve on their own..<br /> <br /></li>
+    <li><strong><a name="TECHADVOS">What are the technical advantages of the
+          Open Source model?</strong></a><br /> The Open Source model has the
+      technical advantage of turning users into potential co-developers. With
+      source code readily available, users will help you debug quickly and
+      promote rapid code enhancements. &quot;Given a bit of encouragement, your
+      users will diagnose problems, suggest fixes, and help improve the code far
+      more quickly than you could unaided.&quot; (The Cathedral and the Bazaar,
+      Eric Steven Raymond. See <a
+      href="http://tuxedo.org/~esr/writings/cathedral-bazaar/" target="_blank"
+    >http://tuxedo.org/~esr/writings/cathedral-bazaar/</a>)<br /> <br /></li>
+    <li><strong><a name="PARTIESEPL">How are the parties defined in the EPL 1.0?</strong></a><br />
+      There are two types of parties to the EPL 1.0. They are
+      &quot;Contributors&quot; and &quot;Recipients.&quot; Contributors include
+      an initial Contributor, who is the person or entity that creates the
+      initial code distributed under the EPL 1.0, and subsequent Contributors,
+      who originate changes or additions to the code (the combination referred
+      to as the &quot;Program&quot;). Any person or entity that redistributes
+      the Program is also a Contributor. Recipients include anyone who receives
+      the Program under the EPL, including Contributors.<br /> <br /></li>
+    <li><strong><a name="ANONCONTR">Can a Contributor remain anonymous?</strong></a><br />
+      No. Except for those who simply redistribute the Program, each Contributor
+      must identify itself as the originator of its Contribution in a way that
+      later Recipients will be able to readily see.<br /> <br /></li>
+    <li><strong><a name="RECRIGHTS">What rights do Contributors grant Recipients
+          under EPL?</strong></a><br /> Contributors license Recipients under
+      the rights that they have in their Contributions.<br /> <br /></li>
+    <li><strong><a name="USEINANOTHER">Does the EPL allow me to take the Source
+          Code for a Program licensed under it and include all or part of it in
+          another program licensed under the GNU General Public License (GPL),
+          Berkeley Software Distribution (BSD) license or other Open Source
+          license?</strong></a><br /> No. Only the owner of software can decide
+      whether and how to license it to others. Contributors to a Program
+      licensed under the EPL understand that source code for the Program will be
+      made available under the terms of the EPL. Unless you are the owner of the
+      software or have received permission from the owner, you are not
+      authorized to apply the terms of another license to the Program by
+      including it in a program licensed under another Open Source license.<br />
+      <br /></li>
+    <li><strong><a name="COMPILEWOMOD">Can I take a Program licensed under the
+          EPL, compile it without modification, and commercially license the
+          result?</strong></a><br /> Yes. You may compile a Program licensed
+      under the EPL without modification and commercially license the result in
+      accordance with the terms of the EPL.<br /> <br /></li>
+    <li><strong><a name="SOURCEWOBJ">Do I need to include the source code for
+          such Program with the object code distribution?</strong></a><br /> No.
+      But you do need to include a statement that the source code is available
+      from you and information on how to obtain it.<br /> <br /> </font></li>
+    <li><strong><a name="PROPPROD">When I incorporate a portion of a Program
+          licensed under the EPL into my own proprietary product distributed in
+          object code form, can I use a single license for the full product, in
+          other words, covering the portion of the Program plus my own code?</strong></a><br />
+      Yes. The object code for the product may be distributed under a single
+      license as long as it references the EPL portion and complies, for that
+      portion, with the terms of the EPL.<br /> <br /></li>
+    <li><strong><a name="AGREESTEWARD">The EPL states that it can be changed by
+          the Agreement Steward. Does a Contributor have the choice of
+          redistributing a previously distributed Program under the old or the
+          new version of the EPL?</strong></a><br /> While Contributions are
+      licensed under the version of the License under which they are originally
+      distributed, the EPL provides for the ability of any Contributor to choose
+      between that version or a later version.<br /> <br /></li>
+    <li><strong><a name="MODNODIST">If I modify a Program licensed under the
+          EPL, but never distribute it to anyone else, do I have to make my
+          modifications available to others?</strong></a><br /> No. If you do
+      not distribute the modified Program, you do not have to make your
+      modifications available to others.<br /> <br /></li>
+    <li><strong><a name="MODDIST">If I modify a Program licensed under the EPL
+          and distribute the object code of the modified Program for free, must
+          I make the source code available?</strong></a><br /> Yes. By
+      distributing the modified Program, even if it is only a free version of
+      the object code, you are obligated to make the source code to the modified
+      Program available to others.<br /> <br /></li>
+    <li><strong><a name="MODULEDIST">If I write a module to add to a Program
+          licensed under the EPL and distribute the object code of the module
+          along with the rest of the Program, must I make the source code to my
+          module available in accordance with the terms of the EPL?</strong></a><br />
+      No, as long as the module is not a derivative work of the Program.<br /> <br /></li>
+    <li><strong><a name="SRCREDIST">What are my obligations if I copy source
+          code obtained from Eclipse.org and licensed under the Eclipse Public
+          License and include it in my product that I then distribute?</a></strong><br />
+      Source code licensed under the EPL may only be redistributed under the
+      EPL.<br /> <br /></li>
+    <li><strong><a name="EPLWARRANTY">Does the EPL offer any warranty with
+          regard to the Program?</strong></a><br /> No. The Program released
+      under the EPL is provided on an &quot;as is&quot; basis, without
+      warranties or conditions of any kind.<br /> <br /></li>
+    <li><strong><a name="GETANSWER">This document does not have the answer to my
+          question. How can I get my question answered?</a><br /> </strong> You
+      may want to check the <a href="legalfaq.php">Eclipse Foundation Legal
+        Frequently Asked Questions </a>document to see if your question is
+      answered there. If not, please send a note to the <a
+      href="mailto:license@eclipse.org"
+    >Eclipse Management Office</a> and we will do our best to get back to you.<br />
+      <br /></li>
+    <li><strong><a name="DERIV">Some open source software communities specify
+          what they mean by a &quot;derivative work&quot;. Does the Eclipse
+          Foundation have a position on this?</a><br /></strong> As described in
+      article 1(b)(ii) of the Eclipse Public License, &quot;...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.&quot;
+      The definition of derivative work varies under the copyright laws of
+      different jurisdictions. The Eclipse Public License is governed under U.S.
+      law. Under the U.S. Copyright Act, a &quot;derivative work&quot; is
+      defined as <em>&quot;...a work based upon one or more preexisting works,
+        such as a translation, musical arrangement, dramatization,
+        fictionalization, motion picture version, sound recording, art
+        reproduction, abridgment, condensation, or any other form in which a
+        work may be recast, transformed, or adapted. A work consisting of
+        editorial revisions, annotations, elaborations, or other modifications
+        which, as a whole, represent an original work of authorship, is a
+        &quot;derivative work&quot;.&quot;</em> The Eclipse Foundation
+      interprets the term &quot;derivative work&quot; in a way that is
+      consistent with the definition in the U.S. Copyright Act, as applicable to
+      computer software. You will need to seek the advice of your own legal
+      counsel in deciding whether your program constitutes a derivative work. <br />
+      <br /></li>
+    <li><strong><a name="LINK">Some free software communities say that linking
+          to their code automatically means that your program is a derivative
+          work. Is this the position of the Eclipse Foundation?</a><br /></strong>
+      No, the Eclipse Foundation interprets the term &quot;derivative work&quot;
+      in a way that is consistent with the definition in the U.S. Copyright Act,
+      as applicable to computer software. Therefore, linking to Eclipse project
+      code might or might not create a derivative work, depending on all of the
+      other facts and circumstances. <br /> <br /></li>
+    <li><strong><a name="EXAMPLE">I&lsquo;m a programmer not a lawyer, can you
+          give me a clear cut example of when something is or is not a
+          derivative work?</a><br /></strong> If you have made a copy of
+      existing Eclipse code and made a few minor revisions to it, that is a
+      derivative work. If you&quot;ve written your own Eclipse Platform Plug-in
+      with 100% your own code to implement functionality not currently in
+      Eclipse, then it is not a derivative work. Scenarios between those two
+      extremes will require you to seek the advice of your own legal counsel in
+      deciding whether your program constitutes a derivative work.<br /> <br />
+      For clarity, merely interfacing or interoperating with Eclipse Platform
+      Plug-in APIs (without modification) does not make an Eclipse Platform
+      Plug-in a derivative work.<br /> <br /></li>
+    <li><strong><a name="USEEPL">I am starting my own open source software
+          project. Does the Eclipse Foundation allow me to use the EPL for my
+          project?</a><br /></strong> Yes. The EPL is an OSI-approved open
+      source license and may be used unaltered by projects regardless of where
+      they are hosted.<br /> <br /></li>
+    <li><strong><a name="CODEGEN">Many Eclipse tools and wizards use code
+          templates which are included in the application that is generated. Is
+          the code generated by these tools considered a derivative work that
+          must be licensed under the EPL?</a><br /></strong> Unfortunately,
+      there is no clear answer to this question. To the extent that the code
+      generated by a wizard is purely functional in nature and therefore not the
+      proper subject matter for copyright protection, it could be argued that it
+      is not subject to copyright protection, and therefore is not a derivative
+      work. An example of that type of code would include calls to APIs or other
+      technical instructions which are dictated by functional or technical
+      requirements. Moreover, to the extent the generated code is a very small
+      part of the final overall work, there is an argument that such use would
+      be di minimus, and the final product or application should not be
+      considered to be a derivative work. Finally, to the extent developers who
+      use the generated code make many changes and additions to the code, there
+      is also an argument that the resultant application is not a derivative
+      work. Of course, these are just arguments and not "bright line" tests, and
+      therefore each position could be subject to differing viewpoints. The
+      Eclipse Foundation cannot take a position on this issue, as it will
+      ultimately be a question of the facts and circumstances associated with a
+      particular use.<br /> <br /></li>
+    <li><strong><a name="3RDPARTY">What licenses are acceptable for third-party
+          code redistributed by Eclipse projects?</a><br /></strong> The Eclipse
+      Foundation views license compatibility through the lens of enabling
+      successful commercial adoption of Eclipse technology in software products
+      and services. We wish to create a commercial ecosystem based on the
+      redistribution of Eclipse software technologies in commercially licensed
+      software products. Determining whether a license for third-party code is
+      acceptable often requires the input and advice of The Eclipse
+      Foundation&rsquo;s legal advisors.<br /> <br />Please see our <a
+      href="http://www.eclipse.org/legal/licenses.php"
+    >list of the most common licenses</a> approved for use by third-party code
+      redistributed by Eclipse Foundation Projects. This list is not exhaustive.
+      If you have any questions, please contact <a
+      href="mailto:license@eclipse.org"
+    >license@eclipse.org</a>.<br /> <br /></li>
+    <li><strong><a name="OSICOMPLIANT">Is an OSI-compliant license a requirement
+          for all third-party code redistributed by Eclipse projects?</a><br /></strong>
+      The Eclipse Foundation fully supports the Open Source Initiative&rsquo;s
+      certification of open source licenses, and the Eclipse Public License is
+      certified as such. However, there are licenses for software content which
+      meet The Eclipse Foundation&rsquo;s requirements for compatibility with
+      the EPL and downstream commercial re-distribution that are not OSI
+      certified, and Eclipse projects may make use of such licenses after review
+      and approval by the Eclipse Foundation.<br /> <br /> The reverse is also
+      true: there are OSI-compliant licenses are not compatible with the EPL or
+      do not permit downstream commercial re-distribution. Such licenses are not
+      used by Eclipse projects.<br /> <br /></li>
+    <li><strong><a name="GPLCOMPATIBLE">Are the Eclipse Public License (EPL) 1.0
+          and the General Public License (GPL) compatible?</a><br /></strong>
+      The EPL 1.0 and the GPL are not compatible in any combination where the
+      result would be considered either: (a) a &quot;derivative work&quot;
+      (which The Eclipse Foundation interprets consistent with the definition of
+      that term in the U.S. Copyright Act ) or (b) a work &quot;based on&quot;
+      the GPL code, as that phrase is used in the <a
+      href="http://www.gnu.org/licenses/old-licenses/gpl-2.0.html"
+    >GPLv2</a>, <a href="http://www.fsf.org/licensing/licenses/gpl.html">GPLv3</a>
+      or the <a href="http://www.fsf.org/licensing/licenses/gpl-faq.html">GPL
+        FAQ</a> as applicable. Further, you may not combine EPL 1.0 and GPL code
+      in any scenario where source code under those licenses are both the same
+      source code module.<br /> <br /> Based upon the <a
+      href="http://www.fsf.org/licensing/licenses/"
+    >position</a> of the Free Software Foundation, you may not combine EPL 1.0
+      and GPL code in any scenario where linking exists between code made
+      available under those licenses. The above applies to both GPL version 2
+      and GPL version 3.<br /> <br /></li>
+    <li><strong><a name="DUALLIC">For Eclipse projects which are dual-licensed,
+          your file headers state that the code is being made available under
+          two licenses. For example: "This program and the accompanying
+          materials are made available under the terms of the Eclipse Public
+          License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+          this distribution." What is meant by the use of the conjunction "and"?</a><br /></strong>
+      The code is being made available under both of the licenses. The consumer
+      of the code can select which license terms they wish to use, modify and/or
+      further distribute the code under.</li>
+  </ol>
+</div>
+<!-- remove the entire <div> tag to omit the right column!  -->
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Related Links</h6>
+    <ul>
+      <li><a href="legalfaq.php">Eclipse Legal FAQ</a></li>
+      <li><a href="epl/notice.php">Eclipse Software User Agreement</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_guidetolegaldoc-EPL-1.0.php b/content/en_guidetolegaldoc-EPL-1.0.php
new file mode 100644
index 0000000..e9454b3
--- /dev/null
+++ b/content/en_guidetolegaldoc-EPL-1.0.php
@@ -0,0 +1,619 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+
+<style>
+.checklist {
+  border: 1px solid #ccc;
+  list-style: none;
+}
+
+.checklist, .checklist li {
+  margin: 0;
+  padding: 0;
+}
+
+.checklist label {
+  display: block;
+  padding-left: 25px;
+  text-indent: -25px;
+}
+
+.postit {
+  border: 1px dashed black;
+  margin: 10px 0 10px 0;
+}
+
+.postitinner {
+  margin: 0 5px 5px 5px;
+}
+</style>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>Last updated: March 31, 2008</p>
+  <h2>
+    <a name="Who"></a>1.0 Who should read this document
+  </h2>
+  <p>
+    <strong>Committers or Contributors to <a href="/" target="_blank">Eclipse.org</a>
+      projects
+    </strong>
+  </p>
+  <blockquote>
+    <p>Reading this document will help you understand the legal documentation
+      requirements of your project. While committers are ultimately responsible
+      for ensuring that content in the Eclipse.org projects contains the
+      appropriate legal documentation, it is always appreciated when
+      contributors can deliver content that requires minimal work to be
+      integrated into the codebase.</p>
+  </blockquote>
+  <p>
+    <strong>Redistributors of Eclipse.org content</strong>
+  </p>
+  <blockquote>
+    <p>Reading this document will help you choose whether you need to modify,
+      remove, or add to any of the Eclipse.org legal documentation. You may be
+      redistributing Eclipse.org content as part of your product.</p>
+  </blockquote>
+  <p>
+    <strong>Developers of Eclipse-based content or products</strong>
+  </p>
+  <blockquote>
+    <p>Even if you are not necessarily redistributing Eclipse.org content
+      itself, reading this document will help you to determine whether or not
+      you wish to adopt some or all of the described framework, for documenting
+      your own content.</p>
+  </blockquote>
+  <p>
+    <strong>Users of Eclipse-based content or products</strong>
+  </p>
+  <blockquote>
+    <p>Reading this document will help you to locate the various legal notices
+      and agreements that govern your use of the content.</p>
+  </blockquote>
+  <h2>
+    <a name="What"></a>2.0 What will this document explain?
+  </h2>
+  <p>In this document you will be introduced to the basic Eclipse.org legal
+    documentation styles; Agreements, Abouts, Licenses and Notices. For each of
+    these styles, we have provided a brief overview, some background information
+    and instructions pertaining to where you can find them as well as where you
+    should place them. After describing the framework used for legal
+    documentation in Eclipse-based content, this document will explain how you
+    should redistribute Eclipse.org content and will offer suggestions as to how
+    you may wish to deal with the delivery of legal documentation when including
+    non-Eclipse.org content in your product.</p>
+  <h2>
+    <a name="Why"></a>3.0 Why so many notices?
+  </h2>
+  <p>Most software products are delivered with a single license file. This file
+    is usually found in the root directory of the installation or in some
+    obviously-named directory such as &quot;license&quot; or &quot;legal.&quot;
+    This straightforward mechanism is used even if there are differently
+    licensed components in the product. In those cases, the single license file
+    may actually contain multiple licenses or notices and it is usually clear
+    which parts of the product each license or notice applies to.</p>
+  <p>
+    Eclipse-based content is highly modularized to facilitate ease of delivery,
+    extensibility, and upgradeability. Important modular concepts in the Eclipse
+    space include <i>plug-ins</i>, <i>plug-in fragments</i> (herein called
+    &quot;fragments&quot;), and <i>features</i>. A typical Eclipse installation
+    may potentially include plug-ins and features authored and/or distributed by
+    many different parties including the Eclipse Foundation, other open-source
+    organizations, and commercial vendors.
+  </p>
+  <p>The content that is developed and maintained at Eclipse.org is a very large
+    codebase that is continuously evolving and may be accessed in a multitude of
+    ways.</p>
+  <p>For example:</p>
+  <blockquote>
+    <ul>
+      <li>Some parts of the content are constantly changing with updates being
+        committed on an almost continuous basis. With committers on a single
+        project spread across many time zones development may be occurring 24x7.</li>
+      <li>Most of the content is licensed under the <a
+        href="../org/documents/epl-v10.php"
+      >Eclipse Public License Version 1.0 (&quot;EPL&quot;)</a>, although at the
+        discretion of the Board of Directors a project may be dual-licensed, or
+        even be maintained under another license altogether. However, the
+        codebase also contains redistributions of many packages maintained at
+        sites other than Eclipse.org, or content based on such packages. For
+        example, there may be redistributions of packages from the <a
+        href="http://www.apache.org" target="_blank"
+      >Apache Software Foundation</a> such as Ant and Tomcat, or code based on
+        parts of such packages. These packages may be offered under licenses
+        other than the EPL.
+      </li>
+      <li>The content at Eclipse.org may be accessed and downloaded in many
+        ways. Most projects create builds on a regular basis. Some projects
+        create many builds for different platforms and configurations on a daily
+        basis. Because these builds are created straight from the Eclipse.org
+        source code repositories, recently committed updates are found in the
+        builds. It is also possible to access content directly from the source
+        code repositories or to download new or updated features using the
+        Eclipse Update Manager.</li>
+    </ul>
+  </blockquote>
+  <p>All of these content characteristics call for a modular approach to legal
+    documentation. Consequently, any distribution of content originating from
+    Eclipse.org should contain notices as described in the following sections.</p>
+  <h2>
+    <a name="LegalDoc"></a>4.0 Eclipse.org legal documentation
+  </h2>
+  <h3>4.1 Software User Agreement</h3>
+  <p>
+    <strong>The Basics:</strong>
+  </p>
+  <p>
+    The top-level umbrella agreement is the <a href="epl/notice.php"
+      target="_blank"
+    >Eclipse Foundation Software User Agreement</a>. The Software User
+    Agreement, to be called &quot;SUA&quot; herein, is not actually a license -
+    it does not grant any rights to use the software and that is why it must
+    reference other legal notices and agreements. The main purpose of the SUA is
+    to describe the potential layout of the legal documentation in the
+    accompanying content.
+  </p>
+  <p>
+    <strong>The Details:</strong>
+  </p>
+  <p>The most important wording is that which says that the EPL applies to all
+    the content unless otherwise indicated. Note that although the EPL is used
+    by all projects at the Eclipse Foundation, at the discretion of the Board of
+    Directors a project may be dual-licensed, or even be maintained under
+    another license altogether.</p>
+  <p>The rest of the text describes the other kinds of notices or licenses that
+    may be found in the content. There is also a short paragraph under the
+    heading &quot;Cryptography&quot; which lets you know that the content may
+    contain cryptography.</p>
+  <p>You will also often see on many of the download pages at Eclipse.org, text
+    that says:</p>
+  <blockquote>
+    <p>
+      All downloads are provided under the terms and conditions of the <a
+        href="epl/notice.php" target="_blank"
+      >Eclipse Foundation Software User Agreement</a> unless otherwise
+      specified.
+    </p>
+  </blockquote>
+  <p>
+    <strong>The Location:</strong>
+  </p>
+  <p>The SUA usually appears in the root directory of Eclipse builds as the file
+    named &quot;notice.html&quot;. A copy of the Project's primary license(s)
+    must appear in the same location as the SUA. In most cases this will be the
+    Eclipse Public License alone.</p>
+  <p>
+    <strong>Note:</strong> The appropriate SUA and a copy of any referenced
+    license <strong>must</strong> be located in the root directory of any
+    Eclipse.org distributed build (typically distributed as a ZIP file). Any web
+    page that makes builds available <strong>must </strong>have a link to the
+    appropriate SUA with appropriate wording.
+  </p>
+  <p>
+    <em>The SUA Checklist</em>
+  </p>
+  <ul class="checklist">
+    <li><label for="o31"><input id="o31" name="o31" type="checkbox" />Every
+        build distribution has the standard SUA in the root as
+        &quot;notice.html&quot;</label></li>
+    <li><label for="o32"><input id="o32" name="o32" type="checkbox" />Every
+        build distribution has a copy of the primary license(s) in the root,
+        e.g., &quot;epl-v10.html&quot;</label></li>
+  </ul>
+  <h3>
+    <a name="Abouts"></a>4.2 Abouts
+  </h3>
+  <p>
+    <strong>The Basics:</strong>
+  </p>
+  <p>Any directory containing content that is licensed under different terms
+    than the license(s) referred to by the SUA, should be detailed in a file
+    named &quot;about.html.&quot; We call these files &quot;Abouts.&quot; Abouts
+    usually contain licensing terms as well as other information such as whether
+    content contains cryptographic functionality that may be subject to export
+    controls.</p>
+  <p>
+    <strong>The Details:</strong>
+  </p>
+  <p>
+    Most plug-ins will contain a default About that simply confirms that all the
+    content in that plug-in is made available under the EPL. There are other
+    plug-ins, however, that will contain content licensed under licenses other
+    than or in addition to the EPL and/or third party content provided under
+    other licenses. If you are the maintainer of a plug-in for an Eclipse.org
+    project, please see the <a href="epl/about.php" target="_blank"> About
+      templates for plugins</a>.
+  </p>
+  <p>Since most plug-ins do NOT contain specially-licensed content, most
+    plug-ins will contain only the default About. The plug-ins with the special
+    Abouts are the &quot;interesting&quot; ones that most users will want to
+    read.</p>
+  <p>
+    <strong>Note:</strong> All plug-ins and fragments should contain an About.
+    All Eclipse.org plug-ins and fragments must contain either one of the
+    default Abouts or a special About written and/or approved by the Eclipse
+    Foundation. In JAR&rsquo;ed plug-ins, any local files linked from the About
+    such as copies of licenses, must be located in a directory called
+    &quot;about_files.&quot;
+  </p>
+  <p>
+    <strong>The Location:</strong>
+  </p>
+  <p>Although Abouts may be found potentially in any directory, they should
+    always be found in plug-ins and fragments. Previously, plug-ins and
+    fragments were usually packaged as sub-directories of a directory named
+    &quot;plugins.&quot; Currently, plug-ins and fragments may also be packaged
+    as JARs (Java&trade; ARchives). For JAR&rsquo;ed plug-ins, any local files
+    linked from an About such as copies of licenses, must be located in a
+    directory called &quot;about_files.&quot; The contents of the
+    &quot;about_files&quot; directory are handled specially so that links
+    resolve correctly when the About in a JAR&rsquo;ed plug-in is viewed in an
+    external browser spawned from the About dialog.</p>
+  <p>As an example:</p>
+  <blockquote>
+    <table cellspacing="4">
+      <tr>
+        <td><i>eclipse</i></td>
+        <td>(installation root directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>notice.html</i></td>
+        <td>Software User Agreement</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>epl-v10.html</i></td>
+        <td>the project&rsquo;s primary licenses(s) (typically the EPL alone)
+          referenced by the SUA</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
+        <td>(plug-ins and fragments directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.apache.ant_1.6.2</i></td>
+        <td>(plug-in packaged as a directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
+        <td>About</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
+        <td>Apache Software License referenced by About</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>LICENSE.dom.html</i></td>
+        <td>W3C License referenced by About</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.core.runtime_3.1.0.jar</i></td>
+        <td>(plug-in packaged as a JAR)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
+        <td>About</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about_files</i></td>
+        <td>(directory for any local files linked from About)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
+        <td>Apache Software License referenced by About</td>
+      </tr>
+    </table>
+  </blockquote>
+  <p>
+    Users looking for legal documentation may find the Abouts by browsing the
+    directory structure of an Eclipse installation but the files are also
+    viewable from the &quot;About plug-ins&quot; dialog in the Eclipse
+    workbench. To view the Abouts, go to the menu item <strong>Help -> About
+      Eclipse Platform</strong> and then click on the button &quot;Plug-in
+    Details&quot; and then select a plug-in and click on the button &quot;More
+    Info.&quot;
+  </p>
+  <p>
+    <em>The Abouts Checklist</em>
+  </p>
+  <ul class="checklist">
+    <li><label for="o51"><input id="o51" name="o51" type="checkbox" />Every
+        plug-in has an &quot;about.html&quot;, usually the standard one.</label></li>
+    <li><label for="o53"><input id="o53" name="o53" type="checkbox" />Every
+        plug-in with a non-standard &quot;about.html&quot; contains the
+        additional referenced license files.</label></li>
+    <li><label for="o52"><input id="o52" name="o52" type="checkbox" />Every
+        JAR&rsquo;ed plug-in stores linked files in &quot;about_files&quot;</label></li>
+  </ul>
+  <br /> <img src="guidetolegaldoc_files/About_plugins_dialog.jpg" width="598"
+    height="447"
+  >
+  <p>&nbsp;</p>
+  <h3>4.3 Features Licenses and Feature Update Licenses</h3>
+  <p>
+    <strong>The Basics:</strong>
+  </p>
+  <p>A feature is a set of one or more related plug-ins and/or fragments that
+    can be installed and upgraded together. There are three important legal
+    documentation files for features, the Feature License (license.html), the
+    Feature Update License (feature.properties &gt; license) and the Feature
+    Blurb (about.properties &gt; blurb).</p>
+  <p>
+    <strong>The Details:</strong>
+  </p>
+  <p>
+    <em>The Feature License</em>
+  </p>
+  <p>Each feature has a file named &quot;license.html.&quot; We call this a
+    &quot;Feature License.&quot; In Eclipse.org builds, this file is an exact
+    copy of the file &quot;notice.html&quot; that is found in the root directory
+    of the distribution. In other words, it is the SUA.</p>
+  <p>
+    <em>The Feature Update License</em>
+  </p>
+  <p>Each feature has a file named &quot;feature.properties.&quot; In that file
+    is a property named &quot;license&quot. This is known as the &quot;Feature
+    Update License.&quot; For Eclipse.org builds, the Feature Update License is
+    an exact copy of the SUA in PLAIN TEXT format. Feature Update Licenses must
+    be delivered in that format whereas all the other files we&rsquo;ve covered
+    so far have been HTML files.</p>
+  <p>
+    <em>The Feature Blurb</em>
+  </p>
+  <p>Each feature has at least one plug-in associated with it which is the
+    &quot;feature plug-in&quot; for that feature. Not surprisingly, this plug-in
+    usually has the same name as the feature. The property named
+    &quot;blurb&quot; contains text that appears in the &quot;About
+    features&quot; dialog in the Eclipse workbench. This is known as a
+    &quot;Feature Blurb.&quot; Blurbs often contain copyright notices and any
+    other statements of attribution that may be required by licenses.</p>
+  <p>
+    <em>What&rsquo;s the difference?</em>
+  </p>
+  <p>The difference between the Feature License and Feature Update License is
+    when they are shown to the user. The Feature License is only available once
+    a feature has been installed. The Feature Update License is seen when a user
+    is using the Eclipse Update Manager to install or upgrade a feature and must
+    agree to an agreement before proceeding with the installation. One thing
+    that is important to note is that with the distributed licensing model used
+    by plug-ins, unless a Feature Update License contains an aggregation of all
+    the notices from the plug-ins for a feature, a user will not be able to see
+    these notices before installing the feature. It is for this reason that the
+    maintainer of a feature may choose to have different text for the Feature
+    License and Feature Update License.</p>
+  <p>
+    <strong>Note: </strong>All features must contain a Feature License and a
+    Feature Update License in the directory for that feature. The
+    feature&rsquo;s plug-in must contain a Feature Blurb.
+  </p>
+  <p>
+    <strong>The Location:</strong>
+  </p>
+  <p>
+    <em>The Feature License</em>
+  </p>
+  <p>The Feature License is found in the feature directory which is usually a
+    sub-directory of the directory named &quot;features.&quot; Any referenced
+    files (for example, the EPL or the SUA) are located in the same location.</p>
+  <p>
+    <em>The Feature Update License</em>
+  </p>
+  <p>The Feature Update License is found in the feature directory which is
+    usually a sub-directory of the directory named &quot;features.&quot; Any
+    referenced files (for example, the EPL or the SUA) are located in the same
+    location.</p>
+  <p>
+    <em>The Feature Blurb</em>
+  </p>
+  <p>
+    The Feature Blurb resides in the &quot;plugins&quot; directory as either a
+    sub-directory or a JAR. In the feature plug-in there is a file named
+    &quot;about.properties.&quot;, the Feature Blurb is the property named
+    &quot;blurb&quot;. To view the blurb for each installed feature, go to the
+    menu item <strong>Help > About Eclipse Platform</strong> and then click
+    &quot;Feature Details&quot; and then select a feature. The blurb will appear
+    in the bottom half of the dialog.
+  </p>
+  <p>
+    <em>The Feature Checklist</em>
+  </p>
+  <ul class="checklist">
+    <li><label for="o41"><input id="o41" name="o41" type="checkbox" />Every
+        feature has the standard SUA in <u>HTML</u> in &quot;license.html&quot;</label></li>
+    <li><label for="o42"><input id="o42" name="o42" type="checkbox" />Every
+        feature has the Project&rsquo;s primary license(s) (e.g., typically the
+        EPL in &quot;epl-v10.html&quot;)</label></li>
+    <li><label for="o43"><input id="o43" name="o43" type="checkbox" />Every
+        feature has the standard SUA in <u>plain text</u> in &quot;feature.xml
+        &lt;license&gt;&quot; or &quot;feature.properties / license&quot;</label></li>
+    <li><label for="o44"><input id="o44" name="o44" type="checkbox" />Every
+        feature plug-in has copyright notices, etc. in the &quot;blurb&quot;
+        property of &quot;about.properties&quot;</label></li>
+  </ul>
+  <br /> <img src="guidetolegaldoc_files/About_features_dialog.jpg" width="598"
+    height="536"
+  >
+  <p>An example directory structure corresponding to the above description:</p>
+  <blockquote>
+    <table cellspacing="4">
+      <tr>
+        <td><i>eclipse</i></td>
+        <td>(installation root directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>features</i></td>
+        <td>(features directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
+        <td>(feature directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>license.html</i></td>
+        <td>(Feature License)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>epl-v10.html</i></td>
+        <td>the project&rsquo;s primary licenses(s) (typically the EPL alone)
+          referenced by the SUA/Feature License)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>feature.properties</i></td>
+        <td>(Feature Update License in &quot;license&quot; property)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
+        <td>(plug-ins and fragments directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
+        <td>(plug-in packaged as a directory)</td>
+      </tr>
+      <tr>
+        <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.properties</i></td>
+        <td>(Feature Blurb in &quot;blurb&quot; property)</td>
+      </tr>
+    </table>
+  </blockquote>
+  <p>&nbsp;</p>
+  <h3>4.4 Notices in source code</h3>
+  <p>
+    <strong>The Basics:</strong>
+  </p>
+  <p>Where practical, all source code (which includes Java source as well other
+    types of files such as XML, HTML, etc.) should contain appropriate copyright
+    and license notices as well information on each contribution.</p>
+  <p>
+    <strong>The Details:</strong>
+  </p>
+  <p>
+    The standard format for these notices can be found at www.eclipse.org &gt;
+    Legal Stuff &gt; <a href="copyrightandlicensenotice.php" target="_blank">
+      Default Copyright and License Notice</a>.
+  </p>
+  <p>If the source is to be licensed under a license other than or in addition
+    to the EPL, you must ensure that the Eclipse Foundation has approved the
+    notice.</p>
+  <p>
+    <strong>The Location:</strong>
+  </p>
+  <p>In the source code.</p>
+  <h3>4.5 Notices in documentation</h3>
+  <p>
+    <strong>The Basics:</strong>
+  </p>
+  <p>The Legal page has a copyright notice and a link to the About in the
+    plug-in that contains the book.</p>
+  <p>An example is shown below:</p>
+  <img src="guidetolegaldoc_files/Help_legal_page.jpg" width="598" height="260">
+  <p>&nbsp;</p>
+  <strong>The Location:</strong>
+  <p>Documentation books usually contain a &quot;Legal&quot; page as the last
+    page in the book.</p>
+  <h2>
+    <a name="Redistribution"></a>5.0 Redistribution of Eclipse.org content
+  </h2>
+  <p>There are a number of considerations when redistributing an Eclipse.org
+    build in or with your own products. Such redistribution also covers
+    redistribution of a subset of an Eclipse.org build such as one or more
+    plug-ins or features from the build. Specifically:</p>
+  <ol>
+    <li>All of the legal documentation is written on behalf of the Eclipse
+      Foundation as if it were the distributor of the content. If you
+      redistribute the content then it is no longer true that Eclipse Foundation
+      is providing the content. In this case, the content originated with the
+      Eclipse Foundation and you are redistributing it.</li>
+    <li>If you are redistributing the object code under your own license as the
+      EPL, and other licenses used by the Eclipse.org projects allow you to do
+      (there may be exceptions), then the existing Eclipse.org legal
+      documentation can be very misleading to readers since it states that use
+      of the object code is governed by various open source licenses.</li>
+    <li>Although the distributed model of the SUA, Abouts, Feature License, and
+      Feature Update Licenses is necessary for the dynamic model of content
+      distribution from Eclipse.org, it may not suit your situation. The
+      downside of this model is that users have to locate and read many files to
+      find all the terms and conditions. In most cases, redistributors want to
+      present a single license although you may want to consider how you will
+      updates provided through the Eclipse Update Manager for example.</li>
+    <li>Changing any of the existing legal documentation requires a change in
+      the version number of any affected component. Soon, the Eclipse Foundation
+      will begin to digitally sign JAR&rsquo;ed plug-ins and features and we
+      will likely see developers of Eclipse-based content do the same thing.
+      Thus it&rsquo;s pretty clear that altering or removing any of the legal
+      documentation is not really an option. Instead it is better to put
+      appropriate wording in your license explaining that the content was
+      originally obtained from the Eclipse Foundation under open source licenses
+      including the EPL, and that you are redistributing it and potentially
+      relicensing it. Such an explanation will provide the opportunity and
+      context for the flowdowns in 3 b) of the EPL.</li>
+  </ol>
+  <p>If you wish to cover the entire redistribution with a single license then
+    you will likely want to locate the necessary licenses for the
+    &quot;special&quot; Abouts and fulfill the obligations of those licenses
+    such as flowing down disclaimers, etc.</p>
+  <h2>
+    <a name="3rdParty"></a>6.0 Legal documentation in non-Eclipse.org content
+  </h2>
+  <p>
+    If you are delivering your own Eclipse-based content then it will likely be
+    packaged as plug-ins and features. In these cases it is desirable to follow
+    the framework described above so that users can view Abouts, Feature
+    Licenses, and Feature Update Licenses. You will likely want a single license
+    to cover the entire package of your own content plus the redistributed
+    Eclipse.org code. You may therefore wish to point out which plug-ins and/or
+    features are being redistributed from the Eclipse Foundation and which are
+    originating from you. You may wish to have the Abouts, Feature Licenses, and
+    Feature Update Licenses in your own plug-ins and features, simply point the
+    user back to the single license in the root directory of the installation
+    rather than duplicating the text everywhere. Of course if you deliver
+    additional or updated features packaged on an update site for download and
+    installation with the Eclipse Update Manager (in which case you should read
+    the <a href="updatemanager.php" target="_blank">Eclipse Foundation Update
+      Manager Agreement</a> found on the Legal Stuff page at eclipse.org) you
+    will probably want to make the user aware of any additional terms and
+    conditions by adding them to the relevant documents.
+  </p>
+  <h2>
+    <a name="Summary"></a>7.0 Summary
+  </h2>
+  <p>There are many legal documentation issues to consider when redistributing
+    Eclipse.org content and delivering Eclipse-based content. It is important
+    that you fully understand what you are redistributing and delivering, and
+    how it will be delivered and thus how your users will encounter (and where
+    necessary agree to) legal documentation, so that you can ensure your
+    conformity with, and their acceptance of, the requirements set forth in the
+    applicable license agreements.</p>
+  <p>
+    If you have any questions or concerns, please <a
+      href="mailto:license@eclipse.org"
+    >contact</a> the staff of the Eclipse Foundation.
+  </p>
+  <small>Java and all Java-based trademarks are trademarks of Sun Microsystems,
+    Inc. in the United States, other countries, or both.</small>
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Quick Links</h6>
+    <ul>
+      <li><a href="#Who">Who Should Read This?</a></li>
+      <li><a href="#What">What Will This Explain?</a></li>
+      <li><a href="#Why">Why So Many Notices?</a></li>
+      <li><a href="#LegalDoc">The Legal Documents</a></li>
+      <li><a href="#Redistribution">Redistribution</a></li>
+      <li><a href="#3rdParty">Documenting Your Products</a></li>
+      <li><a href="#Summary">Summary</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_guidetolegaldoc2.php b/content/en_guidetolegaldoc2.php
new file mode 100644
index 0000000..ef77574
--- /dev/null
+++ b/content/en_guidetolegaldoc2.php
@@ -0,0 +1,392 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<style>
+.checklist {
+  border: 1px solid #ccc;
+  list-style: none;
+}
+
+.checklist, .checklist li {
+  margin: 0;
+  padding: 0;
+}
+
+.checklist label {
+  display: block;
+  padding-left: 25px;
+  text-indent: -25px;
+}
+
+.postit {
+  border: 1px dashed black;
+  margin: 10px 0 10px 0;
+}
+
+.postitinner {
+  margin: 0 5px 5px 5px;
+}
+</style>
+<form action="#" method="GET">
+  <div id="midcolumn">
+    <h1><?php print $pageTitle; ?></h1>
+    <p>Last updated: September 25, 2007</p>
+    <p>
+      This document is intended to assist the Eclipse committers in fulfilling
+      their obligations to implement the <a
+        href="/org/documents/Eclipse_IP_Policy.pdf"
+      >Eclipse IP Policy</a>. In addition to their role as the leading
+      developers on Eclipse projects, Committers are also charged with the
+      responsibility of ensuring that the software distributed by the Eclipse
+      Foundation meets the expectations of the community with respect to
+      intellectual property. This document provides a set of specific checklists
+      for developers on Eclipse Projects to follow regarding the legal
+      documentation required in all source files, builds, and releases. While
+      these checklists should cover most projects, there will obviously be cases
+      where additional advice is needed: if so, please contact <a
+        href="mailto:emo@eclipse.org"
+      >the Eclipse Management Organization</a>.
+    
+    
+    <h2>1. Source Code</h2>
+    <p>
+      Every source file must have a Copyright and License Notice. The standard
+      format for these notices can be found in <a
+        href="copyrightandlicensenotice.php" target="_blank"
+      > Default Copyright and License Notice</a>. If the source is to be
+      licensed under a license other than the EPL alone, you must ensure that
+      the Eclipse Foundation has approved the notice.
+    </p>
+    <p>
+      Source files must have the Copyright and License Notice <em><b>before</b></em>
+      the files are checked into the eclipse.org source repository.
+    </p>
+    <ul class="checklist">
+      <li><label for="o1"><input id="o1" name="o1" type="checkbox" />Every
+          source file has a Copyright and License Notice</label></li>
+    </ul>
+    <h2>2. Documentation</h2>
+    <p>
+      The help documentation must have a Legal page with a copyright notice and
+      a link to the <a href="#about_files">About file</a> in the plug-in that
+      contains the help documentation. For example:
+    </p>
+    <img src="guidetolegaldoc_files/Help_legal_page.jpg" width="598"
+      height="260"
+    >
+    <p>Documentation books usually contain a &quot;Legal&quot; page as the last
+      page in the book.</p>
+    <ul class="checklist">
+      <li><label for="o2"><input id="o2" name="o2" type="checkbox" />Every help
+          documentation set contains a Legal page</label></li>
+    </ul>
+    <h2>
+      <a name="3_Builds"></a>3. Builds
+    </h2>
+    <p>
+      Every build distribution, such as a zip or tar file, must contain a <a
+        href="epl/notice.html" target="_blank"
+      >Eclipse Foundation Software User Agreement</a> (known as the
+      &quot;SUA&quot;) in the root directory of the distribution in HTML format
+      in a file named &quot;notice.html&quot;.
+    </p>
+    <p>
+      A copy of the Project's primary license(s) must be in the root directory
+      of the distribution in HTML format. In most cases, this will be the <a
+        href="epl-v10.html"
+      >Eclipse Public License</a> alone in a file named &quot;epl-v10.html&quot;
+      In exceptional circumstances, the Board may approve the licensing of a
+      project under license terms other than the EPL alone.
+    
+    
+    <ul class="checklist">
+      <li><label for="o31"><input id="o31" name="o31" type="checkbox" />Every
+          build distribution has the standard SUA in the root as
+          &quot;notice.html&quot;</label></li>
+      <li><label for="o32"><input id="o32" name="o32" type="checkbox" />Every
+          build distribution has a copy of the primary license(s) in the root,
+          e.g., &quot;epl-v10.html&quot;</label></li>
+    </ul>
+    <div class="postit">
+      <div class="postitinner">
+        <a name="SUA"></a>
+        <h3>What is the Software User Agreement?</h3>
+        The Software User Agreement is the agreement that governs the use of all
+        software distributed by the Eclipse Foundation. The SUA references the
+        Eclipse Public License as the primary vehicle to grant license rights
+        and obligations to use the software. In addition, it also references
+        other legal notices and agreements and describes the potential layout of
+        the legal documentation in the accompanying Content.
+        <p>The reason for the SUA is that Eclipse-based content is highly
+          modularized to facilitate ease of delivery, extensibility, and
+          upgradeability. A typical Eclipse installation may potentially include
+          plug-ins and features authored and/or distributed by many different
+          parties including the Eclipse Foundation, other open-source
+          organizations, and commercial vendors.
+        
+        
+        <p>This modularity makes an Eclipse distribution somewhat different from
+          a classical software product delivered with a single license file. The
+          Eclipse Foundation SUA guides the consumer to the various licenses
+          distributed through out the Eclipse Project distribution.
+      
+      </div>
+    </div>
+    <h2>4. Features</h2>
+    <p>A feature is a set of one or more related plug-ins and/or fragments that
+      can be installed and upgraded together. Every feature must have at least
+      three (usually at least four) legal files:
+    
+    
+    <p>For example:</p>
+    <blockquote>
+      <table cellspacing="4">
+        <tr>
+          <td><i>eclipse</i></td>
+          <td>(installation root directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>features</i></td>
+          <td>(features directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
+          <td>(feature directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>license.html</i></td>
+          <td><b>(#1 Feature License)</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>epl-v10.html</i></td>
+          <td><b>(#2 Project's Primary License(s) (typically EPL alone)
+              referenced by Feature License)</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>feature.properties</i></td>
+          <td><b>(#3 Feature Update License in &quot;license&quot; property)</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
+          <td>(plug-ins and fragments directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
+          <td>(plug-in packaged as a directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.properties</i></td>
+          <td><b>(#4 Feature Blurb in &quot;blurb&quot; property)</b></td>
+        </tr>
+      </table>
+    </blockquote>
+    The first required file is &quot;license.html&quot;. This file is required
+    to be the <a href="epl/notice.html" target="_blank">Eclipse Foundation SUA</a>
+    in HTML format (and thus an exact duplicate of the &quot;notice.html&quot;
+    in <a href="#3_Builds">the root of the distribution</a>). This file is
+    referred to as <em>The Feature License</em>.
+    <p>
+      The second required file is the <a href="epl-v10.html">Eclipse Public
+        License</a> in HTML format in a file named &quot;epl-v10.html&quot; (and
+      thus also an exact duplicate of the &quot;epl-v10.html&quot; in <a
+        href="#3_Builds"
+      >the root of the distribution</a>).
+    
+    
+    <p>
+      Each feature has a file named &quot;feature.xml&quot; with a
+      <code>license</code>
+      node. Often the strings in the &quot;feature.xml&quot; file are
+      externalized in a &quot;feature.properties&quot; file. Either way, the
+      <code>license</code>
+      node or property must contain the <a href="epl/notice.txt" target="_blank">Eclipse
+        Foundation SUA</a> in PLAIN TEXT format. This text (node or property) is
+      referred to as <em>The Feature Update License</em>.
+    
+    
+    <p>Each feature has at least one plug-in associated with it which is the
+      &quot;feature plug-in&quot; for that feature. Not surprisingly, this
+      plug-in usually has the same name as the feature. The
+      &quot;about.properties&quot; property named &quot;blurb&quot; contains
+      text that appears in the &quot;About features&quot; dialog in the Eclipse
+      workbench. This is known as a &quot;Feature Blurb.&quot; Blurbs often
+      contain copyright notices and any other statements of attribution that may
+      be required by licenses.
+    
+    
+    <ul class="checklist">
+      <li><label for="o41"><input id="o41" name="o41" type="checkbox" />Every
+          feature has the standard SUA in <u>HTML</u> in
+          &quot;license.html&quot;</label></li>
+      <li><label for="o42"><input id="o42" name="o42" type="checkbox" />Every
+          feature has the Project's primary license(s) (e.g., the EPL in
+          &quot;epl-v10.html&quot;)</label></li>
+      <li><label for="o43"><input id="o43" name="o43" type="checkbox" />Every
+          feature has the standard SUA in <u>plain text</u> in &quot;feature.xml
+          &lt;license&gt;&quot; or &quot;feature.properties / license&quot;</label></li>
+      <li><label for="o44"><input id="o44" name="o44" type="checkbox" />Every
+          feature plug-in has copyright notices, etc. in the &quot;blurb&quot;
+          property of &quot;about.properties&quot;</label></li>
+    </ul>
+    <div class="postit">
+      <div class="postitinner">
+        <h3>Why So Many Copies?</h3>
+        <p>For technical reasons (i.e., this is the way the software works),
+          each of the different copies of the SUA and Project license(s) (e.g.,
+          EPL) are shown to the user at different times. We need to make sure
+          that the SUA and Project license(s) are available to the user
+          regardless of which installation and/or browsing mechanism he or she
+          uses, thus the existence of numerous copies of the same legal
+          documents.
+      
+      </div>
+    </div>
+    <div class="postit">
+      <div class="postitinner">
+        <h3>What&rsquo;s the Difference Between These Files?</h3>
+        <p>The difference between the Feature License and Feature Update License
+          is when they are shown to the user. The Feature License is only
+          available once a feature has been installed. The Feature Update
+          License is seen when a user is using the Eclipse Update Manager to
+          install or upgrade a feature and must agree to an agreement before
+          proceeding with the installation. One thing that is important to note
+          is that with the distributed licensing model used by plug-ins, unless
+          a Feature Update License contains an aggregation of all the notices
+          from the plug-ins for a feature, a user will not be able to see these
+          notices before installing the feature.</p>
+      </div>
+    </div>
+    <h2>5. Plug-ins</h2>
+    <p>
+      <a name="#about_files"></a> All plug-in directories must have an
+      &quot;about.html&quot; file describing the license terms of the code and
+      content of the plug-in. The &quot;about.html&quot; file may also contain
+      other information such as whether the content contains cryptographic
+      functionality that may be subject to export controls. These
+      &quot;about.html&quot; are collective known as &quot;Abouts.&quot;
+    
+    
+    <p>
+      Most plug-ins of Eclipse Projects are pure EPL and thus the about.html
+      file will be <a href="epl/about.html" target="_blank">default about for
+        EPL plug-ins</a>. If a plug-in contains non-EPL content, read more about
+      <a href="epl/about.php">About files</a> and how to write About files for
+      third-party content.
+    
+    
+    <p>In JAR&rsquo;ed plug-ins, any local files linked from an About such as
+      copies of licenses, must be located in a directory called
+      &quot;about_files.&quot; The contents of the &quot;about_files&quot;
+      directory are handled specially so that links resolve correctly when the
+      About in a JAR&rsquo;ed plug-in is viewed in an external browser spawned
+      from the About dialog.</p>
+    <p>As an example:</p>
+    <blockquote>
+      <table cellspacing="4">
+        <tr>
+          <td><i>eclipse</i></td>
+          <td>(installation root directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
+          <td>(plug-ins and fragments directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.apache.ant_1.6.2</i></td>
+          <td>(plug-in packaged as a directory)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
+          <td><b>About</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
+          <td><b>Apache Software License referenced by about.html</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>LICENSE.dom.html</i></td>
+          <td><b>W3C License referenced by about.html</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.core.runtime_3.1.0.jar</i></td>
+          <td>(plug-in packaged as a JAR)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
+          <td><b>About</b></td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about_files</i></td>
+          <td>(directory for any local files linked from about.html)</td>
+        </tr>
+        <tr>
+          <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
+          <td><b>Apache Software License referenced by about.html</b></td>
+        </tr>
+      </table>
+    </blockquote>
+    <ul class="checklist">
+      <li><label for="o51"><input id="o51" name="o51" type="checkbox" />Every
+          plug-in has an &quot;about.html&quot;, usually the standard one.</label></li>
+      <li><label for="o53"><input id="o53" name="o53" type="checkbox" />Every
+          plug-in with a non-standard &quot;about.html&quot; contains the
+          additional referenced license files.</label></li>
+      <li><label for="o52"><input id="o52" name="o52" type="checkbox" />Every
+          &rsquo;ed plug-in stores linked files in &quot;about_files&quot;</label></li>
+    </ul>
+    <h2>6. Download Web Pages</h2>
+    <p>
+      Any web page that makes builds available must have a link to the <a
+        href="#SUA"
+      >SUA</a> with the following wording:
+    
+    
+    <blockquote>
+      <p>
+        All downloads are provided under the terms and conditions of the <a
+          href="epl/notice.php" target="_blank"
+        >Eclipse Foundation Software User Agreement</a> unless otherwise
+        specified.
+      </p>
+    </blockquote>
+    <ul class="checklist">
+      <li><label for="o61"><input id="o61" name="o61" type="checkbox" />All
+          download pages contain the standard reference to the SUA.</label></li>
+    </ul>
+    <h2>Appendix A. Viewing All These Files</h2>
+    <h3>About Files</h3>
+    <p>
+      Users looking for legal documentation may find the Abouts by browsing the
+      directory structure of an Eclipse installation but the files are also
+      viewable from the &quot;About plug-ins&quot; dialog in the Eclipse
+      workbench. To view the Abouts, go to the menu item <strong>Help -> About
+        Eclipse Platform</strong> and then click on the button &quot;Plug-in
+      Details&quot; and then select a plug-in and click on the button &quot;More
+      Info.&quot;
+    </p>
+    <img src="guidetolegaldoc_files/About_plugins_dialog.jpg" width="598"
+      height="447"
+    >
+    <h3>Feature Blurbs</h3>
+    <p>
+      To view the blurb for each installed feature, go to the menu item <strong>Help
+        > About Eclipse Platform</strong> and then click &quot;Feature
+      Details&quot; and then select a feature. The blurb will appear in the
+      bottom half of the dialog.
+    </p>
+    <img src="guidetolegaldoc_files/About_features_dialog.jpg" width="598"
+      height="536"
+    >
+  </div>
+</form>
\ No newline at end of file
diff --git a/content/en_licenses.php b/content/en_licenses.php
new file mode 100644
index 0000000..c4bf9d5
--- /dev/null
+++ b/content/en_licenses.php
@@ -0,0 +1,38 @@
+<?php
+/**
+ * Copyright (c) 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="maincontent">
+  <div id="midcolumn">
+    <h1><?php echo $pageTitle; ?></h1>
+    <p>Updated <?php print $App->getFormattedDate($modified); ?></p>
+    <h3 id="approved">Approved Licenses</h3>
+    <p>
+      The following is a list of the most common licenses approved for use by
+      third party code redistributed by Eclipse Foundation Projects. This list
+      is not exhaustive. Should you have a query on a specific license not
+      listed here, please contact <a href="license@eclipse.org">license@eclipse.org</a>.
+    </p>
+    <?php dumpLicenseList($licenseFile); ?>
+    <h3 id="nonapproved">Non Approved Licenses</h3>
+    <ul>
+      <li>GNU General Public License (GPL)</li>
+      <li>Sun Binary Code License Agreement</li>
+    </ul>
+    <p>
+      Please note the LGPL has been approved by the Eclipse Board of Directors
+      in certain cases. Please contact <a href="license@eclipse.org">license@eclipse.org</a>
+      for more information.
+    </p>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_logo_guidelines.php b/content/en_logo_guidelines.php
new file mode 100644
index 0000000..e289822
--- /dev/null
+++ b/content/en_logo_guidelines.php
@@ -0,0 +1,274 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+
+<div id="midcolumn">
+    <h1><?php print $pageTitle; ?></h1>
+    <p>March 7, 2016</p>
+  <h3><a name="h.ggtn2qdts1nf"></a>Table of Contents</h3>
+      <blockquote>
+      <ul>
+        <li><a href="#Purpose" class=jump>Purpose</a></li>
+        <li><a href="#GeneralLogo" class=jump>General Usage of Logos</a></li>
+        <li><a href="#ProperEclipse" class=jump>Proper Usage of &quot;Eclipse&quot; Trademark and Logo</a></li>
+        <li><a href="#ProperProjects" class=jump>Proper Usage of Eclipse Project Names and Logos</a></li>
+        <li><a href="#ProperWG" class=jump>Proper Usage of Eclipse Working Group Names and Logos</a></li>
+        <li><a href="#ProperMember" class=jump>Proper Usage of &quot;Eclipse Foundation Member&quot; Logo</a></li>
+        <li><a href="#ProperBuilt" class=jump>Proper Usage of &lsquo;Built on Eclipse&lsquo; Trademark and Logo</a></li>
+        <li><a href="#ProperReady" class=jump>Proper Usage of &quot;Eclipse Ready&quot; Trademark and Logo</a></li>
+        <li><a href="#ProperIncubation" class=jump>Proper Usage of &quot;Eclipse Incubation&quot; Trademark and Logo</a></li>
+        <li><a href="#ProperNotice" class=jump>Proper Notice and Attribution</a></li>
+      </ul>
+      </blockquote>
+
+  <h3><a name="Purpose"></a>Purpose:</h3>
+  <p>These requirements are meant to promote and improve the image of
+  all elements of the Eclipse community, as well as to show that all
+  Eclipse Foundation projects are part of a community of developers,
+  adopters and users. While every project manages their own development
+  within the broader <a href="https://eclipse.org/projects/dev_process/development_process.php">Eclipse
+  Development Process</a>, a consistent set of trademark and branding
+  requirements benefits the entire Eclipse community.</p>
+
+  <p>The Eclipse Foundation holds the trademarks for the project names
+  and logos on behalf of, and for the benefit of, the Eclipse community
+  as a whole. The individual projects are not separate legal entities,
+  and thus not able to hold trademarks individually. The Eclipse
+  Foundation is a legal entity and owns the trademarks on behalf of the
+  entire community.</p>
+
+  <p>If you have any questions regarding this policy, or wish to use an
+  Eclipse Foundation trademark in a way not explicitly explained in
+  these Guidelines, then ask us by sending an email to
+  <a href="mailto:license@eclipse.org" target="_top">license@eclipse.org</a>.</p>
+
+  <p>The Eclipse Foundation and Eclipse projects have created a number
+  of trademarks and logos to identify the Eclipse community and
+  individual Eclipse projects. In addition to the &lsquo;Eclipse&rsquo;
+  trademark, the Eclipse Foundation has introduced seven trademarks and
+  logos: </p>
+    <ul>
+      <li/>
+    <p>Eclipse Foundation Member,</p>
+      <li/>
+    <p>EclipseCon,</p>
+      <li/>
+    <p>Eclipse Summit,</p>
+      <li/>
+    <p>Built on Eclipse,</p>
+      <li/>
+    <p>Eclipse Ready, and</p>
+      <li/>
+    <p>Eclipse Incubation.</p>
+    </ul>
+  <p>Individual Eclipse projects and Eclipse Working Groups have also
+  introduced unique names and logos&nbsp;that are trademarks of the
+  Eclipse Foundation. This document outlines the policy and guidelines
+  of the Eclipse Foundation in regards to any use of these trademarks.</p>
+  <p>Our goals in establishing these guidelines are pretty simple:</p>
+  <ul>
+  <li>The Eclipse trademarks are a
+    symbol of the quality and community support that people have come to
+    associate with Eclipse. To ensure that the Eclipse trademarks
+    continue to serve these functions, we need to keep control over
+    their use. Along these lines, we want to ensure that the use of our
+    marks is not likely to lead to confusion with other marks. By this
+    we mean that people should be able to tell when something is from
+    the Eclipse Foundation or one of the Eclipse projects. Also, use of
+    our marks must not be in a disparaging manner because we prefer that
+    our marks not be used to be rude about the Eclipse technology, the
+    Eclipse Foundation, its projects, or its Members.</li>
+  <li>We want to encourage our logos to be used in approved ways.
+    For example, we want to make it as simple as legally possible for
+    our Members to use the &lsquo;Eclipse Foundation Member&rsquo; mark.</li>
+  </ul>
+  <h3><a name="GeneralLogo"></a>General Usage of Logos</h3>
+  <ol>
+    <li/>
+  <p>Derivative works of the
+    &lsquo;EclipseCon&rsquo;, &lsquo;Eclipse Summit&rsquo;, &lsquo;Eclipse
+    Foundation Member&rsquo;, &lsquo;Built on Eclipse&rsquo;, &lsquo;Eclipse
+    Ready&rsquo; and projects logos are not allowed.</p>
+    <li/>
+  <p>The &lsquo;Eclipse&rsquo; logos
+    and production specification are available from www.eclipse.org.
+    Replication of these logos must follow these specifications.</p>
+    <li/>
+  <p>Except for use by Eclipse
+    projects on the eclipse.org website, use of the &lsquo;Eclipse
+    Incubation&rsquo; Trademark and Logo is not permitted unless
+    authorized in writing by the Eclipse Foundation.</p>
+  </ol>
+
+  <h3><a name="ProperEclipse"></a>Proper Usage of &quot;Eclipse&quot; Trademark and Logo</h3>
+  <p>The &ldquo;Eclipse&rdquo; name and logo are the intellectual
+  property of the Eclipse Foundation and must be identified as such.
+  Eclipse logos are provided for use under the terms of these
+  Guidelines. Use of the &ldquo;Eclipse&rdquo; name or Eclipse logos
+  are restricted to identifying the Eclipse Foundation, the Eclipse
+  projects, the Eclipse working groups, and their deliverables, as
+  applicable.</p>
+  <p>Eclipse logos (including the Eclipse logo, and the logos of
+  Eclipse projects and working groups) cannot be altered without the
+  written permission of the Eclipse Foundation. Eclipse Foundation
+  projects or working groups are permitted to create derivative works
+  of Eclipse logos with the permission of the <a href="http://www.eclipse.org/org/foundation/directors.php">Eclipse
+  Foundation Board of Directors</a>. Any project that wishes to seek
+  such permission may do so by sending an email to license@eclipse.org.</p>
+  <ol>
+    <li/>
+  <p>You must not incorporate the
+    &lsquo;Eclipse&rsquo; trademark into the name of your company or
+    software product name. If you have a software product that works
+    with an Eclipse technology, you must use phrases such as &lsquo;&lt;product
+    name&gt; for Eclipse&rsquo; or &lsquo;&lt;product name&gt;, Eclipse
+    Edition&rsquo;.</p>
+    <li/>
+  <p>You may request permission to
+    include the &lsquo;Eclipse&rsquo; trademark in the name of a
+    publication, certification program, domain name or book. At a
+    minimum you must ensure that a) the appropriate TM or (R) symbol is
+    associated with the &lsquo;Eclipse&rsquo; reference and appropriate
+    attribution as discussed below, b) &lsquo;Eclipse&rsquo; is not
+    concatenated with another word, e.g. EclipseBoard, and c) the usage
+    does not imply or make the user believe that the publication, domain
+    name or book is supported or authorized by the Eclipse Foundation.
+    Any organization wishing to seek such permission may do so by
+    sending an email to license@eclipse.org.</p>
+    <li/>
+  <p>An important use of the
+    &lsquo;Eclipse&rsquo; trademark is the &lsquo;org.eclipse&rsquo;
+    string used on all namespaces for Eclipse open source projects. This
+    naming convention is used to identify code that has been developed
+    as an Eclipse open source project. Therefore, no one, except Eclipse
+    open source projects may develop or maintain software packages that
+    use &lsquo;org.eclipse&rsquo; in their namespace.</p>
+    <li/>
+  <p>&lsquo;Eclipse&rsquo; must always be capitalized, except
+    when used as part of the Eclipse logos.</p>
+  </ol>
+  <h3><a name="ProperProjects"></a>Proper Usage of Eclipse Project Names and Logos</h3>
+  <p>The <a href="https://wiki.eclipse.org/Development_Resources/HOWTO/Project_Naming_Policy">Eclipse
+  Project Naming Policy</a>&nbsp;allows for Eclipse projects to have a
+  descriptive name, optional nickname and acronym. These names, e.g.
+  Orion, and acronyms, e.g. BIRT, can be become effective identifiers
+  of certain technologies, therefore it is important to establish
+  proper usage guidelines. All project names, nicknames, logos, and
+  acronyms are the intellectual property of the Eclipse Foundation and
+  must be identified as such. For clarity, projects are not required to
+  include &ldquo;Eclipse&rdquo; in their project logos. (Please see
+  proper notice and attribution below.)</p>
+  <ol>
+    <li/>
+  <p>All Eclipse projects must be
+    identified as being Eclipse projects. Therefore, when referencing an
+    Eclipse project, we ask that both the first and the most prominent
+    reference to the project on each page is identified as Eclipse
+    [project name], ex Eclipse Graphical Modeling Framework (GMF) or in
+    the case of a project name that already includes Eclipse, Eclipse
+    Communication Framework (ECF). Subsequent references may drop the
+    Eclipse identifier.</p>
+    <li/>
+  <p>You must not incorporate the
+    name of an Eclipse project, nickname or acronym into the name of
+    your company or software product name. If you have a software
+    product that works with an Eclipse project, it is suggested you use
+    terms such as '&lt;product name&gt; for &lt;Eclipse project name&gt;'
+    or '&lt;product name&gt;, &lt;Eclipse project name&gt; Edition'</p>
+    <li/>
+  <p>You may request permission to &nbsp;include an Eclipse
+    project trademark in the name of a publication, certification
+    program, domain name or book. At a minimum you must ensure that a)
+    the appropriate &trade; or &reg; symbol is associated with the
+    Eclipse project name reference and appropriate attribution as
+    discussed below, b) Eclipse project name is not concatenated with
+    another word, e.g. OrionPortal, and c) the usage does not imply or
+    make the user believe that the publication, domain name or book is
+    supported or authorized by the Eclipse Foundation or any Eclipse
+    project. &nbsp;Any organization wishing to seek such permission may
+    do so by sending an email to license@eclipse.org.</p>
+  </ol>
+
+  <h3><a name="ProperWG"></a>Proper Usage of Eclipse Working Group Names and Logos</h3>
+  <p>The names and logos of the Eclipse Foundation Working Groups (WG)
+  are the intellectual property of the Eclipse Foundation and must be
+  identified as such. (Please see proper notice and attribution below).
+  Use of WG trademarks are restricted to identifying the WGs and their
+  deliverables, as applicable. No other uses of WG names and logos are
+  permitted unless authorized in writing by the Eclipse Foundation.</p>
+  <p>Each WG may, at its discretion, develop guidelines for use of the
+  WG trademarks or their derivatives, as applicable, by third parties.
+  These guidelines will be referenced in Appendix A of this document
+  and shall be consistent with these Guidelines for Eclipse Logos and
+  Trademarks. It is not permitted to create any derivative work of a WG
+  trademark with written approval of the Eclipse Foundation, which will
+  consult with the Steering Committee of the relevant Working Group.
+  Any organization wishing to seek permission to create a derivative
+  work of any WG trademark may do so by sending an email to
+  license@eclipse.org.</p>
+
+  <h3><a name="ProperMember"></a>Proper Usage of &quot;Eclipse Foundation Member&quot; Logo</h3>
+  <p>The &lsquo;Eclipse Foundation Member&rsquo; logo is to identify
+  those organizations and individuals that are official members of the
+  Eclipse Foundation, including 1) Strategic Members, 2) Enterprise
+  Members, 3) Solutions (formerly Add-in Provider) Members, 4)
+  Associate Members, and 5) Committer Members. Only official Members of
+  the Eclipse Foundation are authorized to use this logo.</p>
+  <h3><a name="ProperBuilt"></a>Proper Usage of &lsquo;Built on Eclipse&lsquo; Trademark and Logo</h3>
+  <p>The &lsquo;Built on Eclipse&rsquo; trademark is used to identify a
+  product that includes the core Eclipse IDE Platform, specifically the
+  runtime, SWT, JFace, and Generic Workbench components. This type of
+  product is able to run standalone with no prerequisites of other
+  Eclipse components.</p>
+  <h3><a name="ProperReady"></a>Proper Usage of &quot;Eclipse Ready&quot; Trademark and Logo</h3>
+  <p>The &lsquo;Eclipse Ready&lsquo; trademark and logo is used to
+  identify a product that is packaged as an Eclipse IDE feature or
+  plug-in and must be added to an Eclipse platform product. This type
+  of product does not run standalone.</p>
+  <h3><a name="ProperIncubation"></a>Proper Usage of &quot;Eclipse Incubation&quot; Trademark and Logo</h3>
+  <p>The &lsquo;Eclipse Incubation&rsquo; Trademark and Logo are for use exclusively&nbsp;by
+  the Eclipse Foundation and the Eclipse projects. Only the Eclipse
+  Foundation and its projects are authorized to use this trademark and
+  logo. All other use -- even by Eclipse Foundation Members -- is
+  prohibited.</p>
+  <h3><a name="ProperNotice"></a>Proper Notice and Attribution</h3>
+  <p>The appropriate trademark symbol (i.e. TM or (R)) must appear at
+  both the first and most prominent use of the Eclipse Foundation
+  trademarks, and with all occurrence of the Eclipse logo.</p>
+  <p>When you use an Eclipse Foundation trademark or logo you must
+  include a statement attributing the trademark to the Eclipse
+  Foundation, Inc. For example, &quot;&lsquo;Eclipse&rsquo;, &lsquo;Built
+  on Eclipse&rsquo; and &lsquo;Eclipse Ready&rsquo;, &lsquo;BIRT&rsquo;,
+  &lsquo;Orion&rsquo; are trademarks of Eclipse Foundation, Inc.&quot;</p>
+  <h3></a>Footnotes</h3>
+  <p>These guidelines were first introduced at a point in time when
+  some companies and individuals already had product names that include
+  the &lsquo;Eclipse&rsquo; trademark. Companies and individuals using
+  the &lsquo;Eclipse&rsquo; trademark as of February 1, 2005 will not
+  be required to change their already existing product names to comply
+  with these guidelines now or in the future. However, all companies
+  and individuals are required to give proper notice and attribution of
+  the &lsquo;Eclipse&rsquo; trademark. All usage subsequent to February
+  1, 2005 are required to follow these guidelines.</p>
+  <p>Similarly, further revisions to these guidelines were first
+  introduced at a point in time when some companies and individuals
+  already had product names that include Eclipse project trademarks.
+  Companies and individuals using an Eclipse project trademarks as of
+  June 20, 2007 will not be required to change their already existing
+  product names to comply with these guidelines now or in the future.
+  However, all companies and individuals are required to give proper
+  notice and attribution of the Eclipse project trademark. All usage
+  subsequent to June 20, 2007 are required to follow these guidelines.</p>
+</div>
\ No newline at end of file
diff --git a/content/en_noncodelicenses.php b/content/en_noncodelicenses.php
new file mode 100644
index 0000000..395f950
--- /dev/null
+++ b/content/en_noncodelicenses.php
@@ -0,0 +1,77 @@
+<?php
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>December 6, 2017</p>
+  <p>
+    The following licenses have been approved by the Board of Directors for use
+    with Non-Code Content, as that term is defined in the <a
+      href="termsofuse.php"
+    >Eclipse.org Terms of Use</a>.
+  </p>
+  <ol>
+    <li>the <a href="/legal/epl-2.0">Eclipse Public License 2.0</a>,
+    </li>
+    <li>the <a href="../org/documents/epl-v10.php">Eclipse Public License 1.0</a>,
+    </li>
+    <li>the <a href="http://creativecommons.org/licenses/by-sa/3.0/"
+      target="_blank"
+    >Creative Commons Attribution-Share Alike 3.0 (Unported) License</a>,
+    </li>
+    <li>the <a href="http://creativecommons.org/licenses/by/3.0/"
+      target="_blank"
+    >Creative Commons Attribution 3.0 (Unported) License</a>,
+    </li>
+    <li>the <a href="http://creativecommons.org/licenses/by-sa/4.0/"
+      target="_blank"
+    >Creative Commons Attribution-Share Alike 4.0 (International) License</a>,
+      or
+    </li>
+    <li>the <a href="http://creativecommons.org/licenses/by/4.0/"
+      target="_blank"
+    >Creative Commons Attribution 4.0 (International) License</a>.
+    </li>
+  </ol>
+  <br />
+  <p>In addition, the following licenses have been approved by the Board of
+    Directors for use with example code or build scripts and artifacts within
+    Eclipse projects.</p>
+  <ol>
+    <li>the <a href="/legal/epl-2.0">Eclipse Public License 2.0</a>,
+    </li>
+    <li>the <a href="../org/documents/epl-v10.php">Eclipse Public License 1.0</a>,
+      or
+    </li>
+    <li>the <a href="../org/documents/edl-v10.php">Eclipse Distribution License</a>
+      (EDL).
+    </li>
+  </ol>
+  <br />
+  <p>
+    For additional details on the definition of example code or build scripts
+    and artifacts and how to seek PMC approval for using the EDL, please refer
+    to the <a href="../org/documents/Licensing_Example_Code.pdf">policy document</a>.
+  </p>
+  <br />
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Related Links</h6>
+    <ul>
+      <li><a href="index.php">Legal resources</a></li>
+      <li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_privacy.php b/content/en_privacy.php
new file mode 100644
index 0000000..6ef9e69
--- /dev/null
+++ b/content/en_privacy.php
@@ -0,0 +1,108 @@
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <h2>Eclipse.org Privacy Practices</h2>
+  <p>May 12, 2016</p>
+  <p>
+    <strong>Privacy</strong>
+  </p>
+  <p>You can visit Eclipse.org without revealing who you are or any information
+    about yourself. There are times, however, when the Eclipse Foundation or its
+    Members (&quot;We&quot; or &quot;Us&quot;) may need information from you.
+    You may choose to give personal information, such as your name and address
+    or e-mail id that may be needed, for example, to correspond with you. We
+    intend to let you know how such information will be used before it is
+    collected from you on the Internet. If you tell Us that you do not want Us
+    to use this information as a basis for further contact with you, We will
+    respect your wishes.</p>
+  <p>
+    <strong>Information Security and Quality</strong>
+  </p>
+  <p>We intend to protect the quality and integrity of your personally
+    identifiable information. We have tried to implement appropriate technical
+    and organizational measures, such as using encryption for transmission of
+    certain forms of information, to help keep that information secure,
+    accurate, current, and complete.</p>
+  <p>We will make a sincere effort to respond in a timely manner to your
+    requests to correct inaccuracies in your personal information. To correct
+    inaccuracies in your personal information please return the message
+    containing the inaccuracies to the sender with details of the correction
+    requested.</p>
+  <p>We offer as a service to our community the ability for users of Eclipse
+    software to store data on Eclipse Foundation servers through services
+    including but not limited to the User Storage Service and the Automated
+    Error Reporting Initiative. Any data stored through these services will be
+    publicly available on the Internet in unencrypted form and without access
+    restriction. Therefore you should not use this service to store passwords,
+    any personally identifiable information, any confidential business
+    information, or anything else that you do not want to be generally and
+    publicly available.</p>
+  <p>
+    <strong>Clickstream Data and Cookies</strong>
+  </p>
+  <p>We sometimes collect anonymous information from visits to this Web site to
+    help provide better service. For example, We keep track of the domains from
+    which people visit and We also measure visitor activity on Eclipse.org, but
+    in ways that keep the information anonymous. This anonymous information is
+    sometimes known as &quot;clickstream data.&quot; We may use this data to
+    analyze trends and statistics and to help us tailor the Web site to better
+    serve Eclipse participants.</p>
+  <p>Also, when personal data is collected from you in connection with a
+    transaction (such as contribution of code or posting to newsgroups) We may
+    extract some information about that transaction in an anonymous format and
+    combine it with other anonymous information such as clickstream data. This
+    anonymous information is used and analyzed only at an aggregate level to
+    help Us understand trends and patterns.</p>
+  <p>Some Eclipse.org pages use cookies to better serve you when you return to
+    the site. You can set your browser to notify you before you receive a
+    cookie, giving you the chance to decide whether to accept it. You can also
+    set your browser to turn off cookies. If you do so, however, some areas of
+    some sites may not function properly.</p>
+  <p>To the extent Contributions and other Material (as defined in the Terms of
+    Use) contain personal information about you, including, but not limited to,
+    your name, we have the right to provide that information to others pursuant
+    to the Term of Use.</p>
+  <p>
+    <strong>Business Relationships</strong>
+  </p>
+  <p>This Web site contains links to other Web sites. We are not responsible for
+    the privacy practices or the content of such Web sites.</p>
+  <p>
+    <strong>Notification of Changes</strong>
+  </p>
+  <p>This privacy statement was last updated on May 12, 2016. A notice will be
+    posted on this Web site home page for thirty (30) days whenever this privacy
+    statement is changed.</p>
+  <p>
+    <strong>Questions Regarding This Statement</strong>
+  </p>
+  <p>
+    Questions regarding this statement should be directed to: <a
+      href="mailto:license@eclipse.org"
+    >license@eclipse.org</a>.
+  </p>
+  <br />
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Related Links</h6>
+    <ul>
+      <li><a href="index.php">Legal resources</a></li>
+      <li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_termsofuse.php b/content/en_termsofuse.php
new file mode 100644
index 0000000..9b03c7d
--- /dev/null
+++ b/content/en_termsofuse.php
@@ -0,0 +1,213 @@
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="maincontent">
+  <div id="midcolumn">
+    <h1><?php print $pageTitle ?></h1>
+    <p>May 12, 2016</p>
+    <h3>Terms and Conditions of Use for the Eclipse Foundation Web Site and
+      Related Services</h3>
+    <p>
+      <b>By accessing, browsing, or using this web site, you acknowledge that
+        you have read, understand, and agree to be bound by these terms.</b>
+    </p>
+    <p>This Web site and related services are made available by the Eclipse
+      Foundation. All software, documentation, information and/or other
+      materials provided on and through this Web site (&quot;Content&quot;) and
+      all of the related services offered by the Eclipse Foundation may be used
+      solely under the following terms and conditions (&quot;Terms of
+      Use&quot;).</p>
+    <p>This Web site may contain other proprietary notices and copyright
+      information, the terms of which must be observed and followed. The Content
+      on this Web site may contain technical inaccuracies or typographical
+      errors and may be changed or updated without notice. The Eclipse
+      Foundation may also make improvements and/or changes to the Content at any
+      time without notice.</p>
+    <p>The Eclipse Foundation, its members ("Members") assume no responsibility
+      regarding the accuracy of the Content and use of the Content is at the
+      recipient&rsquo;s own risk. The Eclipse Foundation and the Members provide
+      no assurances that any reported problems with any Content will be
+      resolved. Except as otherwise expressly stated, by providing the Content,
+      neither the Eclipse Foundation nor the Members grant any licenses to any
+      copyrights, patents or any other intellectual property rights.</p>
+    <p>The Eclipse Foundation and the Members do not want to receive
+      confidential information from you through this Web site and related
+      services. Please note that any information or material sent to The Eclipse
+      Foundation or the Members will be deemed NOT to be confidential and will
+      be publicly available.</p>
+    <h3>User Data Storage Services ("UDSS")</h3>
+    <p>
+      As a service to you, Eclipse software may offer functionality whereby you
+      can store certain information on Eclipse Foundation’s computer systems, so
+      that it is accessible to you from various devices that you use. Examples
+      include, but are not limited to, the User Storage Service and the
+      Automated Error Reporting Initiative. <b>PLEASE BE AWARE THAT ALL
+        INFORMATION THAT YOU STORE WITH ECLIPSE WILL BE PUBLICLY ACCESSIBLE ON
+        THE INTERNET IN UNENCRYPTED FORM AND WITHOUT ANY ACCESS RESTRICTIONS. Do
+        not store passwords, any personally identifiable information, any
+        confidential business information, or anything else that you do not want
+        to be generally and publicly available. By using this functionality, any
+        information that you store (the “Stored Information”) will be subject to
+        the <a
+        href="https://creativecommons.org/publicdomain/zero/1.0/legalcode"
+      >CC0 1.0 Creative Commons</a> license, where, for purposes of that
+        license, the Stored Information shall constitute the “Work” and you
+        shall be the “Affirmer”.
+      </b> What that means is that anybody who accesses your information on the
+      Internet has a worldwide, unrestricted, royalty free, irrevocable,
+      perpetual, non-exclusive license to use, make, reproduce, prepare
+      derivative works of, publicly display, publicly perform, transmit, sell,
+      distribute, sublicense or otherwise transfer the Stored Information
+      without any obligation to you, including any obligation of attribution.
+    </p>
+    <p>Eclipse reserves the right to discontinue this service at any time or to
+      remove any specific Stored Information from owned or controlled computer
+      systems at any time, and Eclipse does not commit to making the Stored
+      Information available at all times in the future.</p>
+    <p>You are prohibited from posting, transmitting, or storing to or from this
+      Web site site or to any service offered by the Eclipse Foundation any
+      unlawful, threatening, libelous, defamatory, obscene, scandalous,
+      inflammatory, pornographic, or profane material, or any other material
+      that could give rise to any civil or criminal liability under the law.</p>
+    <p>
+      If you believe that Content residing or accessible on or through this Web
+      site or any UDSS infringes a copyright, please send a notice of copyright
+      infringement to our designated agent pursuant to the procedures set forth
+      here: <a href="copyright.php">https://www.eclipse.org/legal/copyright.php</a>
+    </p>
+    <h3>Disclaimers</h3>
+    <p>The Eclipse Foundation and the Members make no representations whatsoever
+      about any other Web site that you may access through this Web site. When
+      you access a non-Eclipse Foundation Web site, even one that may contain
+      the organization&rsquo;s name or mark, please understand that it is
+      independent from the Eclipse Foundation, and that the Eclipse Foundation
+      and the Members have no control over the content on such Web site. In
+      addition, a link to a non-Eclipse Foundation Web site does not mean that
+      the Eclipse Foundation or the Members endorse or accept any responsibility
+      for the content, or the use, of such Web site. It is up to you to take
+      precautions to ensure that whatever you select for your use is free of
+      such items as viruses, worms, Trojan horses and other items of a
+      destructive nature.</p>
+    <p>IN NO EVENT WILL THE ECLIPSE FOUNDATION AND/OR THE MEMBERS BE LIABLE TO
+      YOU (AN INDIVIDUAL OR ENTITY) OR ANY OTHER INDIVIDUAL OR ENTITY FOR ANY
+      DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, SPECIAL OR CONSEQUENTIAL DAMAGES
+      RELATED TO ANY USE OF THIS WEB SITE, THE CONTENT, STORED INFORMATION, OR
+      ON ANY OTHER HYPER LINKED WEB SITE, INCLUDING, WITHOUT LIMITATION, ANY
+      LOST PROFITS, LOST SALES, LOST REVENUE, LOSS OF GOODWILL, BUSINESS
+      INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON YOUR OR OUR INFORMATION
+      HANDLING SYSTEMS OR OTHERWISE, EVEN IF THE ECLIPSE FOUNDATION OR THE
+      MEMBERS ARE EXPRESSLY ADVISED OR AWARE OF THE POSSIBILITY OF SUCH DAMAGES
+      OR LOSSES.</p>
+    <p>ALL CONTENT IS PROVIDED BY THE ECLIPSE FOUNDATION AND/OR THE MEMBERS ON
+      AN "AS IS" BASIS ONLY. THE ECLIPSE FOUNDATION AND THE MEMBERS PROVIDE NO
+      REPRESENTATIONS, CONDITIONS AND/OR WARRANTIES, EXPRESS OR IMPLIED,
+      INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF FITNESS FOR A
+      PARTICULAR PURPOSE, MERCHANTABILITY AND NONINFRINGEMENT. THE ECLIPSE
+      FOUNDATION MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SECURITY OF
+      ANY INOFRMATION OR CONTENT STORED WITH THE ECLIPSE FOUNDATION.</p>
+    <p>The Eclipse Foundation and the Members reserve the right to investigate
+      complaints or reported violations of these Terms of Use and to take any
+      action they deem appropriate including, without limitation, reporting any
+      suspected unlawful activity to law enforcement officials, regulators, or
+      other third parties and disclosing any information necessary or
+      appropriate to such persons or entities relating to user profiles, e-mail
+      addresses, usage history, posted materials, IP addresses and traffic
+      information.</p>
+    <p>The Eclipse Foundation and the Members reserve the right to seek all
+      remedies available at law and in equity for violations of these Terms of
+      Use, including but not limited to the right to block access from a
+      particular Internet address to this Web site.</p>
+    <h3>Licenses</h3>
+    <p>
+      Except for Content available through the UDSS, the Content provided on
+      this Web site is provided under the terms and conditions of the <a
+        href="epl/notice.php"
+      >Eclipse Foundation Software User Agreement</a> and those additional
+      terms, conditions and notices referenced therein.
+    </p>
+    <p>
+      If the Content is licensed to you under the terms and conditions of the
+      Eclipse Public License ("<a href="epl-2.0">EPL</a>"), any Contributions,
+      as defined in the applicable license(s), uploaded, submitted, or otherwise
+      made available to the Eclipse Foundation and/or the Members, by you that
+      relate to such Content are provided under the terms and conditions of the
+      EPL and can be made available to others under the terms of the EPL.
+    </p>
+    <p>If the Content is licensed to you under license terms and conditions
+      other than the EPL ("Other License"), that Content, as well as any
+      modifications, enhancements and/or other code and/or documentation
+      (collectively, "Modifications") uploaded, submitted, or otherwise made
+      available to the Eclipse Foundation and/or the Members, by you that
+      constitute or otherwise relate to such Content are provided under terms
+      and conditions of the Other License and can be made available to others
+      under the terms of the Other License. In addition, with regard to
+      Modifications for which you are the copyright holder, you are also
+      providing the Modifications under the terms and conditions of the EPL and
+      such Modifications can be made available to others under the terms of the
+      EPL, provided however that the Eclipse Foundation shall have the right to
+      reject any Modifications if the acceptance by the Eclipse Foundation would
+      be in any way inconsistent with the Eclipse Foundation's Intellectual
+      Property Policy.</p>
+    <p>
+      To the extent you wish to upload, submit, or otherwise make Non-Code
+      Content (as defined below) available to the Eclipse Foundation and/or the
+      Members, you may make that material available under the terms and
+      conditions of the EPL or any other license stipulated for that purpose at
+      <a href=".">www.eclipse.org/legal</a>. Non-Code Content is Content for
+      which you own or control all rights, and which is not program code
+      intended to be submitted to a Project and documentation related to such
+      code and which is not Stored Information. For example, Non-Code Content
+      would include white papers, dissertations, articles or other literary
+      works, power point presentations, encyclopedias, anthologies, wikis,
+      blogs, diagrams, drawings, sketches, photos or other images, audio
+      content, video content and audiovisual materials.
+    </p>
+    <p>For all other software, information and other material including, without
+      limitation, ideas, concepts, know-how and techniques, uploaded, submitted
+      or otherwise made available to The Eclipse Foundation, the Members, and/or
+      users of this Web-site, (collectively "Material"), if the three paragraphs
+      above are inapplicable, and if the Material is not Stored Information, you
+      grant (or warrant that the owner of such rights has expressly granted) a
+      license under either the applicable Project License(s) (as that term is
+      defined in the Eclipse Intellectual Property Policy), or, if no such
+      Project License(s) is applicable, you grant (or warrant that the owner of
+      such rights has expressly granted) the Eclipse Foundation, the Members and
+      the users of this Web-site a worldwide, unrestricted, royalty free, fully
+      paid up, irrevocable, perpetual, non-exclusive license to use, make,
+      reproduce, prepare derivative works of, publicly display, publicly
+      perform, transmit, sell, distribute, sublicense or otherwise transfer such
+      Materials, and/or derivative works thereof, and authorize third parties to
+      do any, some or all of the foregoing including, but not limited to,
+      sublicensing others to do any some or all of the foregoing indefinitely.
+      You represent and warrant that to your knowledge, you have sufficient
+      rights in the Materials to grant the foregoing rights and licenses.</p>
+    <p>All logos and trademarks contained on this Web site are and remain the
+      property of their respective owners. No licenses or other rights in or to
+      such logos and/or trademarks are granted to you.</p>
+    <p>
+      You can learn more about the <a href="privacy.php">Eclipse.org privacy
+        practices</a> on the Web.
+    </p>
+    <br />
+  </div>
+  <div id="rightcolumn">
+    <div class="sideitem">
+      <h6>Related Links</h6>
+      <ul>
+        <li><a href="index.php">Legal resources</a></li>
+        <li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
+      </ul>
+    </div>
+  </div>
+</div>
\ No newline at end of file
diff --git a/content/en_trademarkattributions.php b/content/en_trademarkattributions.php
new file mode 100644
index 0000000..07383e5
--- /dev/null
+++ b/content/en_trademarkattributions.php
@@ -0,0 +1,50 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>
+    14th December, 2001<br> Modified: 3 May 2016
+  </p>
+  <p>Content on this web site may make reference to the following trademarks:</p>
+  <p>Eclipse, Polarsys and Jetty are registered trademark of the Eclipse
+    Foundation, Inc. in the United States, other countries, or both.</p>
+  <p>IBM, WebSphere. DB2, MQSeries, and VisualAge are trademarks of
+    International Business Machines Corporation in the United States, other
+    countries, or both.</p>
+  <p>C-bus is a trademark of Corollary, Inc. in the United States, other
+    countries, or both.</p>
+  <p>Java and all Java-based trademarks are trademarks of Oracle Corporation in
+    the United States, other countries, or both.</p>
+  <p>Microsoft, Windows, Windows NT, and the Windows logo are trademarks of
+    Microsoft Corporation in the United States, other countries, or both.</p>
+  <p>PC Direct is a trademark of Ziff Communications Company in the United
+    States, other countries, or both and is used by IBM Corporation under
+    license.</p>
+  <p>
+    ActionMedia, LANDesk, MMX, Pentium and ProShare are trademarks of Intel
+    Corporation in the United States, other countries, or both.<br> (Click <a
+      href="http://www.intel.com/sites/corporate/tradmarx.htm"
+    >here</a> to see a complete list of Intel trademarks).
+  </p>
+  <p>UNIX is a registered trademark of The Open Group in the United States and
+    other countries.</p>
+  <p>Linux s the registered trademark of Linus Torvalds in the U.S. and other
+    countries.</p>
+  <p>Android is a trademark of Google Inc.</p>
+  <p>Other company, product, and service names may be trademarks or service
+    marks of others.</p>
+  <br />
+</div>
\ No newline at end of file
diff --git a/content/en_updatemanager.php b/content/en_updatemanager.php
new file mode 100644
index 0000000..2eb9c6f
--- /dev/null
+++ b/content/en_updatemanager.php
@@ -0,0 +1,78 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <p>8th September, 2004</p>
+  <p>
+    <strong>As of February 11, 2011 this agreement was superseded by the revised
+      <a href="epl/notice.php">Eclipse Foundation Software User Agreement</a>.
+    </strong>
+  </p>
+  <p>
+    The Eclipse Foundation makes available the Eclipse Update Manager
+    (&quot;Update Manager&quot;) for the purpose of allowing users to install
+    software, documentation, information and/or other materials (collectively
+    &quot;Downloadable Features&quot;). A Downloadable Feature is a bundle of
+    Plug-ins and/or Fragments and related materials. This capability is provided
+    with the intent of allowing users to extend and update the functionality of
+    Eclipse-based products. Information about packaging Downloadable Features is
+    available at <a
+      href="http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-update-home/doc/eclipse_update_packaging.html"
+    >
+      http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-update-home/doc/eclipse_update_packaging.html</a>
+    (&quot;Specification&quot;).
+  </p>
+  <p>You may make a Downloadable Feature available on a web server (&quot;Update
+    Server&quot;) with the intent of allowing other parties to install the
+    Downloadable Feature using the Update Manager. By providing a Downloadable
+    Feature in such a manner and making it available in accordance with the
+    Specification, you acknowledge your agreement to and grant all necessary
+    rights to permit the following:</p>
+  <blockquote>
+    <ol>
+      <li>A series of actions may occur (&quot;Update Process&quot;) in which a
+        user may execute the Update Manager on a machine (&quot;Target
+        Machine&quot;) with the intent of extending and updating the
+        functionality of an Eclipse-based product.</li>
+      <li>During the Update Process, the Update Manager may interact with your
+        Update Server such that a Downloadable Feature or a portion thereof will
+        be copied from your Update Server to the Target Machine
+        (&quot;Downloaded&quot;) using the Update Manager.</li>
+      <li>According to the Specification, you must provide the terms and
+        conditions that govern the use of the Downloadable Feature
+        (&quot;Feature Update License&quot;) and such Feature Update License
+        shall be placed on your Update Server in accordance with the
+        Specification. Such Feature Update License must inform the user of the
+        terms and conditions that govern the Downloadable Feature.</li>
+      <li>The Update Manager will present the Feature Update License so that a
+        user may read it and indicate that they agree with the terms and
+        conditions of that license. Upon such indication of agreement by the
+        user, the Update Manager will complete installation of the Downloadable
+        Feature.</li>
+      <li>If you provide a Downloadable Feature (&quot;Top-Level Feature&quot;)
+        that &quot;includes&quot; other Downloadable Features (&quot;Included
+        Features&quot;) according to the Specification, any installation of the
+        Top-Level Feature by the Update Manager will present only the Feature
+        Update License for the Top-Level Feature and upon the user indicating
+        their agreement of that license&rsquo;s terms and conditions, both the
+        Top-Level Feature and the Included Features will be installed as
+        described above. It is your obligation to ensure that the Feature Update
+        License for the Top-Level Feature includes the terms and conditions that
+        apply to any and all Included Features or tells the user where to find
+        the Feature Update Licenses that apply to the Included Features.</li>
+    </ol>
+  </blockquote>
+</div>
\ No newline at end of file
diff --git a/copyright.php b/copyright.php
index 859fc29..87157cc 100644
--- a/copyright.php
+++ b/copyright.php
@@ -1,75 +1,34 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Eclipse.org Privacy Policy";
-	$pageKeywords	= "legal, privacy, policy";
-	$pageAuthor		= "Mike Milinkovich, Nov. 22, 2005";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	<div id="midcolumn">
-		<h1>Copyright Agent</h1>
+include ($App->getProjectCommon()); // All
 
-		<p>We respect the intellectual property rights of others, and require that the people who use the Site do the same.  We also maintain a policy under which the Web Site use privileges of users who are repeat infringers of intellectual property rights are terminated in appropriate circumstances.  If you believe that your work has been copied in a way that constitutes copyright infringement, please forward the following information to Eclipse's Copyright Agent, designated as such pursuant to the Digital Millennium Copyright Act, 17 U.S.C. &#167; 512(c)(2), named below: 
-			<ul>
-				<li>Your address, telephone number, and email address;</li>
-				<li>A description of the copyrighted work that you claim has been infringed; </li>
-				<li>A description of where the alleged infringing material is located;</li>
-				<li>A statement by you that you have a good faith belief that the disputed use is not authorized by the copyright owner, its agent, or the law; </li>
-				<li>An electronic or physical signature of the person authorized to act on behalf of the owner of the copyright interest; and </li>
-				<li>A statement by you, made under penalty of perjury, that the above information in your Notice is accurate and that you are the copyright owner or authorized to act on the copyright owner's behalf. </li> 
-			</ul>
-		</p>
-		<p>
-		<h3>Copyright Agent: </h3> 
-		Manager, Intellectual Property<br/>
-		Eclipse Foundation, Inc.<br/>
-		102 Centrepointe Drive<br/>
-		Ottawa, Ontario<br/>
-		Canada<br/>
-		K2G 6B1<br/> <br/>
-		Phone:  +1.613.224.9461<br/>
-		Fax:  +1.212.918.1619<br/>
-		Email:  license@eclipse.org<br/>
-		</p>
-		<br/>
-	</div>
-	<div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-			<li><a href="index.php">Legal resources</a></li>
-			<li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
-			</ul>
-		</div>
-	</div>
+$pageTitle = "Eclipse.org Privacy Policy";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, privacy, policy");
+$Theme->setPageAuthor("Mike Milinkovich, Nov. 22, 2005");
 
-EOHTML;
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/copyrightandlicensenotice.php b/copyrightandlicensenotice.php
index 8630222..a5e45a1 100644
--- a/copyrightandlicensenotice.php
+++ b/copyrightandlicensenotice.php
@@ -1,3 +1,16 @@
 <?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 header("Location:/projects/handbook/#ip-copyright-headers");
-?>
\ No newline at end of file
diff --git a/cpl2epl/_projectCommon.php b/cpl2epl/_projectCommon.php
index ec8b856..a7c84ac 100644
--- a/cpl2epl/_projectCommon.php
+++ b/cpl2epl/_projectCommon.php
@@ -1,17 +1,29 @@
 <?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	# Set the theme for your project's web pages.
-	# See the Committer Tools "Phoenix" secion in the How Do I? for list of themes
-	# https://dev.eclipse.org/committers/ 
-	$theme = "solstice";
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
 
-	# Define your project-wide Nav bars here.
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	$Nav->addNavSeparator("About Us", 	"../../org/");
-	$Nav->addCustomNav("Foundation", "../../org/foundation/", "_self", 1);	
-	$Nav->addCustomNav("Governance", "../../org/documents/", "_self", 1);
-	$Nav->addCustomNav("Legal Resources", "../", "_self", 1);
-	$Nav->addCustomNav("Press Releases", "../../community/news/eclipsenews.php", "_self", 1);
-	$Nav->addCustomNav("Contact Us", "../../org/foundation/contact.php", "_self", 1);
+$App->setOutDated('now');
 
-?>
+$theme = NULL;
+
+$Nav = new Nav();
+$Nav->addNavSeparator("About Us", "../../org/");
+$Nav->addCustomNav("Foundation", "../../org/foundation/", "_self", 1);
+$Nav->addCustomNav("Governance", "../../org/documents/", "_self", 1);
+$Nav->addCustomNav("Legal Resources", "../", "_self", 1);
+$Nav->addCustomNav("Press Releases", "../../community/news/eclipsenews.php", "_self", 1);
+$Nav->addCustomNav("Contact Us", "../../org/foundation/contact.php", "_self", 1);
+$Theme->setNav($Nav);
diff --git a/cpl2epl/about.php b/cpl2epl/about.php
index f25705a..9d9c97a 100644
--- a/cpl2epl/about.php
+++ b/cpl2epl/about.php
@@ -1,61 +1,32 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "About File Template";
-	$pageKeywords	= "legal, about";
-	$pageAuthor		= "M. Milinkovich Nov 21/05";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+include ($App->getProjectCommon());
 
-	<div id="midcolumn">
-	<h1>$pageTitle</h1>
+$pageTitle = "About File Template";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, about");
+$Theme->setPageAuthor("M. Milinkovich Nov 21/05");
 
-      <h2>About This Content</h2>
- 
-      <p>20th June, 2002</p>	
-      <h3>License</h3>
-        <p>Eclipse.org 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
-        Common Public License Version 1.0 (&quot;CPL&quot;).  A copy of the CPL is available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>.
-        For purposes of the CPL, &quot;Program&quot; will mean the Content.</p>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-      <h3>Contributions</h3>
-
-        <p>If this Content is licensed to you under the terms and conditions of the CPL, any Contributions, as defined in the CPL, uploaded, submitted, or otherwise
-        made available to Eclipse.org, members of Eclipse.org and/or the host of Eclipse.org web site, by you that relate to such
-        Content are provided under the terms and conditions of the CPL and can be made available to others under the terms of the CPL.</p>
-
-        <p>If this Content is licensed to you under license terms and conditions other than the CPL (&quot;Other License&quot;), any modifications, enhancements and/or
-        other code and/or documentation (&quot;Modifications&quot;) uploaded, submitted, or otherwise made available to Eclipse.org, members of Eclipse.org and/or the
-        host of Eclipse.org, by you that relate to such Content are provided under terms and conditions of the Other License and can be made available
-        to others under the terms of the Other License.  In addition, with regard to Modifications for which you are the copyright holder, you are also
-        providing the Modifications under the terms and conditions of the CPL and such Modifications can be made available to others under the terms of
-        the CPL.</p>
-    </div>
-    <div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-			<li><a href="about.html">CPL About.html in plain HTML</a></li>
-			<li><a href="index.php">CPL to EPL conversion</a></li>
-			<li><a href="../guidetolegaldoc.php">Guide to legal documents</a></li>
-			</ul>
-		</div>
-	</div>
-
-EOHTML;
-
-	$App->setOutDated('now');
-	# Generate the web page
-	$App->generatePage('solstice', $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/cpl2epl/content/en_about.php b/cpl2epl/content/en_about.php
new file mode 100644
index 0000000..4379fc4
--- /dev/null
+++ b/cpl2epl/content/en_about.php
@@ -0,0 +1,58 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <h2>About This Content</h2>
+  <p>20th June, 2002</p>
+  <h3>License</h3>
+  <p>
+    Eclipse.org 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 Common Public License
+    Version 1.0 (&quot;CPL&quot;). A copy of the CPL is available at <a
+      href="/legal/cpl-v10.html"
+    >http://www.eclipse.org/legal/cpl-v10.html</a>. For purposes of the CPL,
+    &quot;Program&quot; will mean the Content.
+  </p>
+  <h3>Contributions</h3>
+  <p>If this Content is licensed to you under the terms and conditions of the
+    CPL, any Contributions, as defined in the CPL, uploaded, submitted, or
+    otherwise made available to Eclipse.org, members of Eclipse.org and/or the
+    host of Eclipse.org web site, by you that relate to such Content are
+    provided under the terms and conditions of the CPL and can be made available
+    to others under the terms of the CPL.</p>
+  <p>If this Content is licensed to you under license terms and conditions other
+    than the CPL (&quot;Other License&quot;), any modifications, enhancements
+    and/or other code and/or documentation (&quot;Modifications&quot;) uploaded,
+    submitted, or otherwise made available to Eclipse.org, members of
+    Eclipse.org and/or the host of Eclipse.org, by you that relate to such
+    Content are provided under terms and conditions of the Other License and can
+    be made available to others under the terms of the Other License. In
+    addition, with regard to Modifications for which you are the copyright
+    holder, you are also providing the Modifications under the terms and
+    conditions of the CPL and such Modifications can be made available to others
+    under the terms of the CPL.</p>
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Related Links</h6>
+    <ul>
+      <li><a href="about.html">CPL About.html in plain HTML</a></li>
+      <li><a href="index.php">CPL to EPL conversion</a></li>
+      <li><a href="../guidetolegaldoc.php">Guide to legal documents</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/cpl2epl/content/en_cpl2eplfaq.php b/cpl2epl/content/en_cpl2eplfaq.php
new file mode 100644
index 0000000..5698ef3
--- /dev/null
+++ b/cpl2epl/content/en_cpl2eplfaq.php
@@ -0,0 +1,164 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="midcolumn">
+  <h1><?php print $pageTitle; ?></h1>
+  <h2>For informational purposes only</h2>
+  <p>
+    This FAQ provides answers to commonly asked questions related to the
+    transition of Eclipse projects from the <a
+      href="http://www.ibm.com/developerworks/library/os-cpl.html"
+      target="_blank"
+    >Common Public License version 1.0</a> to the <a
+      href="../../org/documents/epl-v10.php"
+    >Eclipse Public License (EPL)</a>.&nbsp; Details can be found in the <a
+      href="http://www.eclipse.org/legal/CPL2EPLTransitionPlan.pdf"
+    >CPL to EPL Transition Plan</a> (.pdf).&nbsp;
+  </p>
+  <p>This FAQ is provided for informational purposes only.&nbsp; It is not part
+    of, nor does it modify, amend, or supplement the terms of the CPL or
+    EPL.&nbsp; The CPL and EPL are legal agreements that govern the rights
+    granted to material licensed under it, so please read them carefully.&nbsp;
+    This FAQ should not be regarded as legal advice.&nbsp; If you need legal
+    advice, you must contact your own lawyer. This document was last updated on
+    August 26, 2004.</p>
+  <ol>
+    <li><strong>Why is the Eclipse Foundation changing licenses?</strong><br />
+      The EPL was written specifically for the <a href="../../org/">Eclipse
+        Foundation</a>.&nbsp; First, it changes the Agreement Steward, formerly
+      IBM for the CPL, to now be the Eclipse Foundation for the EPL.&nbsp;
+      Second, it addresses concerns that some Eclipse Foundation members had
+      with a clause in the CPL that deals with possible patent litigation.&nbsp;
+      Many members and prospective members had concerns with this clause, and
+      viewed it as overly broad.&nbsp; For more information on this please refer
+      to the <a href="../eplfaq.php">EPL FAQ</a>.</li>
+    <li><strong>Can you summarize the plan briefly?</strong><br /> The plan is
+      to license the current release of each Eclipse project, together with any
+      maintenance updates, under both the CPL and EPL for approximately 6-8
+      months. This transition period will be roughly aligned with major releases
+      of the Eclipse Platform.&nbsp; This will give the community adequate time
+      to adjust to the changes.&nbsp;</li>
+    <br />
+    <li><strong>What if a project can&#8217;t meet the timelines in the plan?</strong><br />
+      If any projects find the timeframes to be impractical or feel the plan
+      imposes an unreasonable burden for other reasons, they should request an
+      exception to the plan from the EMO.&nbsp; The EMO is prepared to work with
+      projects, and with the Eclipse community generally, to mitigate the impact
+      of the license transition process.</li>
+    <br />
+    <li><strong>How will inbound contributions be handled?</strong><br /> Under
+      the plan, the <a href="../termsofuse.php">Web Site Terms of Use</a> will
+      be changed to specify that by default, inbound contributions will be
+      contributed under both EPL and CPL during the transition period.&nbsp;
+      This is necessary to support dual licensed maintenance streams of current
+      releases.&nbsp;</li>
+    <br />
+    <li><strong>What if I want to contribute code under only the EPL or CPL to a
+        dual licensed stream?</strong><br /> Contributions under a single
+      license will be possible but not encouraged and will be handled as special
+      cases (similar to the process currently used by the PMCs and EMO to deal
+      with third party code contributed under a license other than the
+      CPL).&nbsp; Approval requires a strong technical argument for including
+      the code, explaining what the functionality is, why it is needed, and why
+      other options that fit the dual license framework are infeasible.</li>
+    <br />
+    <li><strong>What about previous releases like Eclipse Platform 2.x?</strong><br />
+      Past release streams that were licensed under CPL only and are still in
+      use (e.g. Eclipse 2.x), will continue to be supported as CPL only.</li>
+    <br />
+    <li><strong>Will new development streams be dual licensed also?</strong><br />
+      No, all new development streams going forward (e.g. Eclipse 3.1) will
+      operate under EPL only.&nbsp;</li>
+    <br />
+    <li><strong>When will the re-licensing process be completed and the
+        transition period end?</strong><br /> This is a two-stage process, with
+      two important dates.&nbsp; The plan for the re-licensing process is for it
+      to be completed for all projects by December 31 2004.&nbsp; By that date,
+      and for every project, CPL only development will cease, the current
+      release will be offered under dual license, and new development will be
+      EPL only. At some <strong>switchover date</strong> (currently expected to
+      be in 1H05), all Eclipse development (including maintenance) will move to
+      EPL only.&nbsp; The exact date of the switchover will depend on individual
+      project schedules.</li>
+    <br />
+    <li><strong>When will we see EPL versions of major Eclipse projects?</strong><br />
+      For now, major projects will prepare dual licensed releases.&nbsp; The
+      Eclipse Foundation will be contacting all contributors to obtain their
+      agreement to publish under both EPL and CPL.</li>
+    <br />
+    <li><strong>What is the Re-Licensing Committee?</strong><br /> The Eclipse
+      Foundation Board of Directors has created a committee called the
+      Re-Licensing Committee to monitor the progress of the transition.&nbsp;</li>
+    <br />
+    <li><strong>I am a committer and I received an email asking me to identify
+        contributors whose code I committed.&nbsp; Why am I getting this?</strong><br />
+      Contributors to an Eclipse project provided their contribution under the
+      CPL.&nbsp; We are seeking their agreement to dual license their
+      contribution under both the CPL and EPL.&nbsp; To facilitate this process
+      Eclipse is asking all committers to identify the contributors they
+      personally know about.&nbsp; We would like to get their contact
+      information (employer, address, etc.), and also would like to know what
+      they worked on and roughly how much code they contributed.&nbsp; All of
+      this will help us to first, decide exactly who needs to be contacted and
+      second, collect the required agreements.</li>
+    <br />
+    <li><strong>What is the Eclipse Foundation going to do with the personal
+        data it is collecting?</strong><br /> We intend to build a contributor
+      database so that in future we can do a better job of managing and
+      recognizing contributions.</li>
+    <br />
+    <li><strong>What is an &quot;individual committer&quot;?</strong><br /> Most
+      committers working on Eclipse projects currently are employed by an
+      Eclipse Member Organization, and are working on Eclipse in the course of
+      their regular employment.&nbsp; Individual committers are those who fall
+      outside this category.&nbsp; If the individual committer personally owns
+      his/her contributions, then he/she may simply agree to re-contribute under
+      the EPL.&nbsp; If some other entity owns the contribution, such as their
+      employer, then he/she must obtain the permission of that entity to
+      re-license the contribution.</li>
+    <br />
+    <li><strong>Once all the required agreements are obtained, what options does
+        a project have to actually implement the re-licensing for
+        projects/builds that will be licensed under the EPL?</strong><br /> The
+      Eclipse Foundation is currently suggesting projects use one of two
+      options.&nbsp; </span><span style='font-family: Arial'>Option #1 is to
+        modify <strong>all files including source files</strong> to change all
+        legal notices, abouts, feature licenses, feature update licenses, and
+        the Software User Agreement, to refer to &quot;EPL&quot;; rather than
+        &quot;CPL&quot; but only for those projects/builds that will be licensed
+        under the EPL. &nbsp; For those projects/builds that will be licensed
+        under the CPL, no changes are required.&nbsp; Option #2 is similar to
+        Option #1 except <strong>source files will NOT BE UPDATED</strong>.&nbsp;
+        This means that the CVS repository and source builds for the stream will
+        contain source files with effectively &quot;incorrect&quot; license
+        notices that will be &quot;overridden&quot; by the Abouts, Software User
+        Agreement and other legal documentation.&nbsp; The use of this mechanism
+        and the status of each project will be well publicized and documented on
+        the website </li>
+    <br />
+    <li><strong>What if I&rsquo;m still confused about what my options are with
+        respect to the re-licensing process?</strong><br /> Contact your PMC
+      Lead or the EMO, they will help you sort things out.</li>
+    <br />
+    <li><strong>What if a project can&rsquo;t get this all done by the December
+        31 deadline?</strong><br /> The Re-Licensing Committee has the authority
+      to approve exceptions to the plan, on the recommendation of the EMO, that
+      would allow a project more time.&nbsp; The criteria for considering an
+      exception are: the size of the project; cost to completely change all
+      source files; project schedules; available resources; and impact on the
+      Eclipse community.</li>
+    <br />
+  </ol>
+</div>
\ No newline at end of file
diff --git a/cpl2epl/content/en_cpl_copyrightandlicensenotice.php b/cpl2epl/content/en_cpl_copyrightandlicensenotice.php
new file mode 100644
index 0000000..6d67230
--- /dev/null
+++ b/cpl2epl/content/en_cpl_copyrightandlicensenotice.php
@@ -0,0 +1,98 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="maincontent">
+  <div id="midcolumn">
+    <h1><?php print $pageTitle; ?></h1>
+    <p>Last updated September 8th, 2004</p>
+    <p>
+      With the Eclipse Foundation transitioning from the CPL to the EPL (for
+      further information see the <a href="CPL2EPLTransitionPlan.pdf">CPL to EPL
+        Transition Plan</a> (.pdf) and matching <a href="cpl2eplfaq.php">FAQ</a>),
+      the default license for a project will either be the CPL or the EPL. For
+      CPL projects, the notice template is:
+    </p>
+    <p>
+      /*******************************************************************************<br>
+      &nbsp;* Copyright (c) {DATE} {INITIAL COPYRIGHT OWNER} {OTHER COPYRIGHT
+      OWNERS}.<br> &nbsp;* All rights reserved. This program and the
+      accompanying materials<br> &nbsp;* are made available under the terms of
+      the Common Public License v1.0<br> &nbsp;* which accompanies this
+      distribution, and is available at<br> &nbsp;*
+      http://www.eclipse.org/legal/cpl-v10.html<br> &nbsp;*<br> &nbsp;*
+      Contributors:<br> &nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;{INITIAL AUTHOR} -
+      initial API and implementation<br>
+      &nbsp;*******************************************************************************/
+    </p>
+    <p>For EPL projects, the notice template is:</p>
+    <p>
+      /*******************************************************************************<br>
+      &nbsp;* Copyright (c) {DATE} {INITIAL COPYRIGHT OWNER} {OTHER COPYRIGHT
+      OWNERS}.<br> &nbsp;* All rights reserved. This program and the
+      accompanying materials<br> &nbsp;* are made available under the terms of
+      the Eclipse Public License v1.0<br> &nbsp;* which accompanies this
+      distribution, and is available at<br> &nbsp;*
+      http://www.eclipse.org/legal/epl-v10.html<br> &nbsp;*<br> &nbsp;*
+      Contributors:<br> &nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;{INITIAL AUTHOR} -
+      initial API and implementation<br>
+      &nbsp;*******************************************************************************/
+    </p>
+    <p>NOTE: While the CPL to EPL Transition Plan is in effect, do NOT use the
+      EPL notice unless you know for certain that your project has transitioned
+      fully to the EPL.</p>
+    <p>If the contents of the file are to be governed by another license,
+      different text will be required. Contact the relevant PMC for assistance
+      with this.</p>
+    <p>
+      <strong>{DATE}</strong> is either a year or a range of years with the
+      first and last years of the range separated by a comma. So for example:
+      &quot;2004&quot; or &quot;2000, 2004&quot;. The first year is when the
+      contents of the file were first created and the last year is the last year
+      is when the contents were last modified.
+    </p>
+    <p>
+      <strong>{INITIAL COPYRIGHT OWNER}</strong> is the copyright owner that
+      created the initial content. If the content is subsequently modified and
+      appended to by other copyright owners, the words &quot;and others&quot;
+      are typically appended. So for example: &quot;XYZ Corp.&quot; or &quot;XYZ
+      Corp. and others&quot;. The words &quot;and others&quot; are used to avoid
+      having to list every copyright owner and because often, most of the
+      content in the file was contributed the by initial copyright owner with
+      subsequent modifications by others being smaller. However especially if
+      the number of copyright owners is small (e.g. two), there is nothing wrong
+      with listing all of them especially if their contributions are more
+      proportionately equal. For example: &quot;XYZ Corp., John Smith, and ABC
+      Enterprises.&quot;
+    </p>
+    <p>NOTE: Do not confuse copyright owners with authors (which is explained
+      below). A copyright owner may be either an individual or an entity. If a
+      person is making their contributions on behalf of their employer, then the
+      copyright owner is usually the employer (i.e. &quot;XYZ Corp.&quot; and
+      not &quot;John Smith&quot;).</p>
+    <p>
+      <strong>{INITIAL AUTHOR}</strong> is the name of the person that wrote the
+      initial content. Subsequent authors are listed on proceding lines with a
+      short description of the contribution. If there is an associated Bugzilla
+      report number, then it is good practice to include it here. Over time,
+      this section actually becomes a log of the contributions. Although it
+      could become quite lengthy in some cases, it should be maintained for two
+      important reasons - to acknowledge the contributions of individuals
+      (especially when their contribution is owned by their employer), and to
+      assist with tracking the pedigree of the code (who wrote what). It is good
+      practice to list the name of the author with their employer if the latter
+      owns the copyright. For example: &quot;John Smith (XYZ Corp.)&quot;.
+    </p>
+  </div>
+</div>
\ No newline at end of file
diff --git a/cpl2epl/content/en_index.php b/cpl2epl/content/en_index.php
new file mode 100644
index 0000000..16eb9ba
--- /dev/null
+++ b/cpl2epl/content/en_index.php
@@ -0,0 +1,94 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+<div id="maincontent">
+  <div id="midcolumn">
+    <h1><?php print $pageTitle; ?></h1>
+    <p>
+      As part of the formation of the Eclipse Foundation, the Eclipse community
+      migrated from the Common Public License (<a
+        href="http://www.ibm.com/developerworks/library/os-cpl.html"
+        target="blank"
+      >CPL</a>) to the Eclipse Public License (<a
+        href="../../org/documents/epl-v10.php"
+      >EPL</a>). This conversion resulted in changes to quite a few legal
+      documents on our website. This page maintains the transition plan and the
+      old versions of the eclipse.org documents which reference the CPL.
+    </p>
+    <p>
+      <a href="http://www.opensource.org/licenses/eclipse-1.0.php"
+        target="blank"
+      ><img align="absbottom" src="../../images/osi-certified-60x50.gif"
+        border="0"
+      /></a> &nbsp; &nbsp; The Eclipse Public License is an OSI-approved open
+      source license.
+    </p>
+    <p>The Eclipse Foundation began the transition from the CPL to the EPL on
+      September 9th, 2004. It was substantially completed with the release of
+      Eclipse 3.1 on June 28, 2005.</p>
+    <div class="homeitem3col">
+      <h3>CPL to EPL Transition</h3>
+      <ul>
+        <li><A href="cpl2eplfaq.php">CPL to EPL Transition Plan Frequently Asked
+            Questions</a><br /> This FAQ answers some of the commonly asked
+          questions about transition from the <a
+          href="http://www.ibm.com/developerworks/library/os-cpl.html"
+          target="_blank"
+        >Common Public License (CPL)</a> to the <a
+          href="../../org/documents/epl-v10.php"
+        >Eclipse Public License (EPL)</a>.</li>
+        <li><A href="CPL2EPLTransitionPlan.pdf">CPL to EPL Transition Plan</A>
+          The detailed plan (.pdf) for transitioning from the Common Public
+          License (CPL) to the Eclipse Public License (EPL).</li>
+      </ul>
+    </div>
+    <div class="homeitem3col">
+      <h3>Agreements and Licenses</h3>
+      <li><A href="notice.php">Eclipse.org Software User Agreement</A> By
+        downloading builds or accessing the CVS repository, you acknowledge that
+        you have read, understood, and agree to be bound by the terms and
+        conditions contained in this agreement. This agreement is used for
+        projects that default to the Common Public License (CPL).</li>
+    </div>
+    <div class="homeitem3col">
+      <h3>Frequently Asked Questions</h3>
+      <li><A
+        href="http://www.ibm.com/developerworks/opensource/library/os-cplfaq/index.html"
+        target="_blank"
+      >CPL Frequently Asked Questions</A> Written by IBM and hosted at
+        IBM&rsquo;s developerWorks site, this FAQ answers some of the commonly
+        asked questions about the Common Public License (CPL).</li>
+    </div>
+    <div class="homeitem3col">
+      <h3>Resources for Committers</h3>
+      <li><A href="about.php">&quot;About&quot; Template (CPL References)</A>
+        This is a template for an &quot;about.html&quot; (&quot;About&quot;)
+        file that describes CPL-licensed content. Abouts contain legal
+        documentation and are maintained in the CVS repository and subsequently
+        included in builds in plug-in and other directories. They usually
+        contain information about licensing and sometimes also information about
+        any use of cryptography. By convention, every plug-in usually has an
+        About. If all the content in a plug-in, directory or module can be
+        correctly licensed under the CPL then this template can be used without
+        modification. Any other About should be approved by the relevant PMC who
+        can also assist committers with drafting an About.</li>
+      <li><A href="cpl_copyrightandlicensenotice.php">Default Copyright and
+          License Notice</A> The standard copyright and license notice should
+        appear in all source files where possible. Variations on this notice may
+        be required (for example where a license other than the CPL or EPL
+        governs the use of the file).</li>
+    </div>
+  </div>
+</div>
\ No newline at end of file
diff --git a/cpl2epl/content/en_notice.php b/cpl2epl/content/en_notice.php
new file mode 100644
index 0000000..9c04a31
--- /dev/null
+++ b/cpl2epl/content/en_notice.php
@@ -0,0 +1,126 @@
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+
+<h1><?php print $pageTitle; ?></h1>
+<div id="midcolumn">
+  <p>ECLIPSE.ORG 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 Eclipse.org is
+    provided to you under the terms and conditions of the Common Public License
+    Version 1.0 (&quot;CPL&quot;). A copy of the CPL is provided with this
+    Content and is also available at <a href="../cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>.
+    For purposes of the CPL, &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 Eclipse.org 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
+    CPL 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>Eclipse Public License Version 1.0 (available at <a
+      href="http://www.eclipse.org/legal/epl-v10.html"
+    >http://www.eclipse.org/legal/epl-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://www-128.ibm.com/developerworks/opensource/library/os-ipl.html"
+    >http://www-128.ibm.com/developerworks/opensource/library/os-ipl.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 Eclipse.org 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 countrys laws, regulations and
+    policies concerning the import, possession, or use, and re-export of
+    encryption software, to see if this is permitted.</p>
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>Related Links</h6>
+    <ul>
+      <li><a href="notice.html">CPL Software User Agreement in plain HTML</a></li>
+      <li><a href="index.php">CPL to EPL conversion</a></li>
+      <li><a href="../guidetolegaldoc.php">Guide to legal documents</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/cpl2epl/cpl2eplfaq.php b/cpl2epl/cpl2eplfaq.php
index 4c0b3db..3ee7bba 100644
--- a/cpl2epl/cpl2eplfaq.php
+++ b/cpl2epl/cpl2eplfaq.php
@@ -1,189 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "CPL To EPL Transition Plan Frequently Asked Questions";
-	$pageKeywords	= "cpl, epl, license, transition";
-	$pageAuthor		= "Mike Milinkovich, Nov 24, 2005";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	<div id="midcolumn">
-		<h1>$pageTitle</h1>
-		<h2>For informational purposes only</h2>
-		
-		<p>This FAQ provides answers to commonly asked
-		questions related to the transition of Eclipse projects from the 
-		<a href="http://www.ibm.com/developerworks/library/os-cpl.html" target="_blank">Common Public License version
-		1.0</a> to the <a href="../../org/documents/epl-v10.php">Eclipse
-		Public License (EPL)</a>.&nbsp; Details can be found in the 
-		<a href="http://www.eclipse.org/legal/CPL2EPLTransitionPlan.pdf">CPL to EPL Transition Plan</a> (.pdf).&nbsp;
-		</p><p>This FAQ is provided for informational purposes
-		only.&nbsp; It is not part of, nor does it modify, amend, or supplement the
-		terms of the CPL or EPL.&nbsp; The CPL and EPL are legal
-		agreements that govern the rights granted to material licensed under it, so
-		please read them carefully.&nbsp; This FAQ should not be regarded as legal
-		advice.&nbsp; If you need legal advice, you must contact your own lawyer.
-		This document was last updated on August 26, 2004. </p>
-		<ol>
-		<li><strong>Why is the Eclipse Foundation changing licenses?</strong><br/>
-		The EPL was written specifically for
-		the <a href="../../org/">Eclipse Foundation</a>.&nbsp; First,
-		it changes the Agreement Steward, formerly IBM for the CPL, to now be the Eclipse
-		Foundation for the EPL.&nbsp; Second, it addresses concerns that some Eclipse Foundation
-		members had with a clause in the CPL that deals with possible patent
-		litigation.&nbsp; Many members and
-		prospective members had concerns with this clause, and viewed it as overly broad.&nbsp; For more
-		information on this please refer to the <a href="../eplfaq.php">EPL FAQ</a>.</li>
-		<li><strong>Can you summarize the plan briefly?</strong><br/>
-		The plan is to license the current
-		release of each Eclipse project, together with any maintenance updates, under
-		both the CPL and EPL for approximately 6-8 months.  This transition period will be 
-		roughly aligned with major releases of the
-		Eclipse Platform.&nbsp; This will give
-		the community adequate time to adjust to the changes.&nbsp;
-		</li><br/>
-		<li><strong>What if a project can&#8217;t meet the timelines in the plan?</strong><br/>
-		If any projects find the timeframes
-		to be impractical or feel the plan imposes an unreasonable burden for other
-		reasons, they should request an exception to the plan from the EMO.&nbsp; The EMO is prepared to work with
-		projects, and with the Eclipse community generally, to mitigate the impact of
-		the license transition process. 
-		</li><br/>
-		<li><strong>How will inbound contributions be handled?</strong><br/>
-		Under the plan, the <a href="../termsofuse.php">Web Site Terms of Use</a> 
-		will be changed to specify that by default, inbound contributions will be
-		contributed under both EPL and CPL during the transition period.&nbsp; This is necessary to support dual
-		licensed maintenance streams of current releases.&nbsp;
-		</li><br/>				
-		<li><strong>What if I want to contribute code under only the EPL or CPL to a dual licensed stream?</strong><br/>
-		Contributions under a single license
-		will be possible but not encouraged and will be handled as special cases
-		(similar to the process currently used by the PMCs and EMO to deal with third
-		party code contributed under a license other than the CPL).&nbsp; Approval requires a
-		strong technical argument for including the code, explaining what the
-		functionality is, why it is needed, and why other options that fit the dual
-		license framework are infeasible.
-		</li><br/>
-		<li><strong>What about previous releases like Eclipse Platform 2.x?</strong><br/>
-		Past release streams that were
-		licensed under CPL only and are still in use (e.g. Eclipse 2.x), will continue
-		to be supported as CPL only.
-		</li><br/>
-		<li><strong>Will new development streams be dual licensed also?</strong><br/>
-		No, all new development streams
-		going forward (e.g. Eclipse 3.1) will operate under EPL only.&nbsp; 
-		</li><br/>
-		<li><strong>When will the re-licensing process be completed and the transition period end?</strong><br/>
-		This is a two-stage process, with two important dates.&nbsp;
-		The plan for the re-licensing process is for it to be completed for all projects by December
-		31 2004.&nbsp; By that date, and for every project, CPL only development will cease,
-		the current release will be offered under dual license, and new development
-		will be EPL only. At some <strong>switchover
-		date</strong> (currently expected to be in 1H05), all Eclipse development (including
-		maintenance) will move to EPL only.&nbsp;
-		The exact date of the switchover will depend on individual project
-		schedules.
-		</li><br/>		
-		<li><strong>When will we see EPL versions of major Eclipse projects?</strong><br/>
-		For now, major
-		projects will prepare dual licensed releases.&nbsp; The Eclipse Foundation
-		will be contacting all contributors to obtain their agreement to publish under both
-		EPL and CPL.
-		</li><br/>				
-		<li><strong>What is the Re-Licensing Committee?</strong><br/>
-		The Eclipse Foundation Board of
-		Directors has created a committee called the Re-Licensing Committee to
-		monitor the progress of the transition.&nbsp;
-		</li><br/>
-		<li><strong>I am a committer and I received an email asking me to
-		identify contributors whose code I committed.&nbsp; Why am I getting this?</strong><br/>
-		Contributors to an Eclipse project
-		provided their contribution under the CPL.&nbsp; We are seeking their agreement to dual license their
-		contribution under both the CPL and EPL.&nbsp; To facilitate this process Eclipse is
-		asking all committers to identify the contributors they personally know
-		about.&nbsp; We would like to get their
-		contact information (employer, address, etc.), and also would like to know what
-		they worked on and roughly how much code they contributed.&nbsp; All of this will help us to first,
-		decide exactly who needs to be contacted and second, collect the required
-		agreements.
-		</li><br/>
-		<li><strong>What is the Eclipse Foundation going to do with the
-		personal data it is collecting?</strong><br/>
-		We intend to build a contributor
-		database so that in future we can do a better job of managing and recognizing
-		contributions.
-		</li><br/>
-		<li><strong>What is an &quot;individual committer&quot;?</strong><br/>
-		Most committers working on Eclipse
-		projects currently are employed by an Eclipse Member Organization, and are
-		working on Eclipse in the course of their regular employment.&nbsp; Individual committers are those who
-		fall outside this category.&nbsp; If the individual committer personally
-		owns his/her contributions, then he/she may simply agree to re-contribute under
-		the EPL.&nbsp; If some other entity owns
-		the contribution, such as their employer, then he/she must obtain the permission of that entity to
-		re-license the contribution.
-		</li><br/>		
-		<li><strong>Once all the required agreements are obtained, what
-		options does a project have to actually implement the re-licensing for projects/builds that
-		will be licensed under the EPL?</strong><br/>
-		The
-		Eclipse Foundation is currently suggesting projects use one of two options.&nbsp; </span><span style='font-family:Arial'>Option
-		#1 is to modify <strong>all files including
-		source files</strong> to change all legal notices, abouts, feature licenses, feature
-		update licenses, and the Software User Agreement, to refer to &quot;EPL&quot;; rather than
-		&quot;CPL&quot; but only for those projects/builds that will be licensed under the EPL.
-		&nbsp; For those projects/builds that will be licensed under the CPL, no changes are
-		required.&nbsp; Option #2 is similar to Option #1 except <strong>source files will NOT BE UPDATED</strong>.&nbsp; 
-		This means that the CVS repository and
-		source builds for the stream will contain source files with effectively
-		&quot;incorrect&quot; license notices that will be &quot;overridden&quot; by
-		the Abouts, Software User Agreement and other legal documentation.&nbsp; The use of this mechanism and the
-		status of each project will be well publicized and documented on the website
-		</li><br/>				
-		<li><strong>What if I&rsquo;m still confused about what my options are with
-		respect to the re-licensing process?</strong><br/>
-		Contact your PMC Lead or the EMO, they will help you sort things out.
-		</li><br/>
-		<li><strong>What if a project can&rsquo;t get this all done by the December 31 deadline?</strong><br/>
-		The Re-Licensing Committee has the
-		authority to approve exceptions to the plan, on the recommendation of the EMO,
-		that would allow a project more time.&nbsp;
-		The criteria for considering an exception are: the size of the project;
-		cost to completely change all source files; project schedules; available
-		resources; and impact on the Eclipse community.
-		</li><br/>
-		</ol>
+include ($App->getProjectCommon());
 
+$pageTitle = "CPL To EPL Transition Plan Frequently Asked Questions";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("cpl, epl, license, transition");
+$Theme->setPageAuthor("Mike Milinkovich, Nov 24, 2005");
 
-	</div>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-EOHTML;
-
-
-	$App->setOutDated('now');
-	# Generate the web page
-	$App->generatePage('solstice', $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/cpl2epl/cpl_copyrightandlicensenotice.php b/cpl2epl/cpl_copyrightandlicensenotice.php
index d02d19f..cbe4bd6 100644
--- a/cpl2epl/cpl_copyrightandlicensenotice.php
+++ b/cpl2epl/cpl_copyrightandlicensenotice.php
@@ -1,100 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Default Eclipse Foundation Copyright and License Notice";
-	$pageKeywords	= "legal, documents, cpl, epl";
-	$pageAuthor		= "M. Milinkovich Nov 21/05";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+include ($App->getProjectCommon());
 
-<div id="maincontent">
-    <div id="midcolumn">
-    <h1>$pageTitle</h1>
-	<p>Last updated September 8th, 2004</p>
+$pageTitle = "Default Eclipse Foundation Copyright and License Notice";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, documents, cpl, epl");
+$Theme->setPageAuthor("M. Milinkovich Nov 21/05");
 
-	<p>With the Eclipse Foundation transitioning from the CPL to the EPL (for further information
-	see the <a href="CPL2EPLTransitionPlan.pdf">CPL to EPL Transition Plan</a> (.pdf) and matching <a href="cpl2eplfaq.php">FAQ</a>),
-	the default license for a project will either be the CPL or the EPL.  For CPL projects, the notice template is:
-	</p>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-	<p>
-	/*******************************************************************************<br>
-	&nbsp;* Copyright (c) {DATE} {INITIAL COPYRIGHT OWNER} {OTHER COPYRIGHT OWNERS}.<br>
-	&nbsp;* All rights reserved. This program and the accompanying materials<br>
-	&nbsp;* are made available under the terms of the Common Public License v1.0<br>
-	&nbsp;* which accompanies this distribution, and is available at<br>
-	&nbsp;* http://www.eclipse.org/legal/cpl-v10.html<br>
-	&nbsp;*<br>
-	&nbsp;* Contributors:<br>
-	&nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;{INITIAL AUTHOR} - initial API and implementation<br>
-	&nbsp;*******************************************************************************/
-	</p>
-
-	<p>For EPL projects, the notice template is:</p>
-
-	<p>
-	/*******************************************************************************<br>
-	&nbsp;* Copyright (c) {DATE} {INITIAL COPYRIGHT OWNER} {OTHER COPYRIGHT OWNERS}.<br>
-	&nbsp;* All rights reserved. This program and the accompanying materials<br>
-	&nbsp;* are made available under the terms of the Eclipse Public License v1.0<br>
-	&nbsp;* which accompanies this distribution, and is available at<br>
-	&nbsp;* http://www.eclipse.org/legal/epl-v10.html<br>
-	&nbsp;*<br>
-	&nbsp;* Contributors:<br>
-	&nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;{INITIAL AUTHOR} - initial API and implementation<br>
-	&nbsp;*******************************************************************************/
-	</p>
-	
-	<p>NOTE:  While the CPL to EPL Transition Plan is in effect, do NOT use the EPL notice unless you know for certain that your project
-	has transitioned fully to the EPL.</p>
-	
-	<p>If the contents of the file are to be governed by another license, different text will be required.
-	Contact the relevant PMC for assistance with this.</p>
-
-	<p><strong>{DATE}</strong> is either a year or a range of years with the first and last years
-	of the range separated by a comma.  So for example: &quot;2004&quot; or &quot;2000, 2004&quot;.
-	The first year is when the contents of the file were first created and the last year is the last
-	year is when the contents were last modified.</p>
-		
-	<p><strong>{INITIAL COPYRIGHT OWNER}</strong> is the copyright owner that created the initial content.
-	If the content is subsequently modified and appended to by other copyright owners, the words
-	&quot;and others&quot; are typically appended.  So for example: &quot;XYZ Corp.&quot; or &quot;XYZ Corp. and others&quot;.
-	The words &quot;and others&quot; are used to avoid having to list every copyright owner and because often,
-	most of the content in the file was contributed the by initial copyright owner with subsequent modifications by others
-	being smaller.  However especially if the number of copyright owners is small (e.g. two), there is nothing wrong with
-	listing all of them especially if their contributions are more proportionately equal.  For example:
-	&quot;XYZ Corp., John Smith, and ABC Enterprises.&quot;</p>
-	
-	<p>NOTE:  Do not confuse copyright owners with authors (which is explained below).  A copyright owner may be either
-	an individual or an entity.  If a person is making their contributions on behalf of their employer, then the copyright
-	owner is usually the employer (i.e. &quot;XYZ Corp.&quot; and not &quot;John Smith&quot;).</p>
-	
-	<p><strong>{INITIAL AUTHOR}</strong> is the name of the person that wrote the initial content.  Subsequent authors
-	are listed on proceding lines with a short description of the contribution.  If there is an associated Bugzilla report
-	number, then it is good practice to include it here.  Over time, this section actually
-	becomes a log of the contributions.  Although it could become quite lengthy in some cases, it should be maintained for
-	two important reasons - to acknowledge the contributions of individuals (especially when their contribution is 
-	owned by their employer), and to assist with tracking the pedigree of the code (who wrote what).  It is good practice to
-	list the name of the author with their employer if the latter owns the copyright.  For example: &quot;John Smith (XYZ Corp.)&quot;.</p>
-
-	</div>		
-  </div>
-
-EOHTML;
-
-	$App->setOutDated('now');
-	# Generate the web page
-	$App->generatePage('solstice', $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/cpl2epl/index.php b/cpl2epl/index.php
index 384050c..dc163b8 100644
--- a/cpl2epl/index.php
+++ b/cpl2epl/index.php
@@ -1,89 +1,34 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "CPL to EPL Conversion";
-	$pageKeywords	= "legal, documents, about, cpl, epl, conversion";
-	$pageAuthor		= "M. Milinkovich Nov 21/05";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+include ($App->getProjectCommon());
 
-<div id="maincontent">
-    <div id="midcolumn">
-    <h1>$pageTitle</h1>
-	<p>As part of the formation of the Eclipse Foundation, the Eclipse community migrated from 
-	the Common Public License (<a href="http://www.ibm.com/developerworks/library/os-cpl.html" target="blank">CPL</a>) to the 
-	Eclipse Public License (<a href="../../org/documents/epl-v10.php">EPL</a>). This conversion
-	resulted in changes to quite a few legal documents on our website. This page maintains the transition
-	plan and the old versions of the eclipse.org documents which reference the CPL.</p>
-	<p><a href="http://www.opensource.org/licenses/eclipse-1.0.php" target="blank"><img align="absbottom" src="../../images/osi-certified-60x50.gif" border="0"/></a> &nbsp; &nbsp; 
-	The Eclipse Public License
-	is an OSI-approved open source license.</p> 
-	<p>The Eclipse Foundation began the transition from the CPL to the EPL on September 9th, 2004.
-	It was substantially completed with the release of Eclipse 3.1 on June 28, 2005.</p>
-	
-          
-    <div class="homeitem3col">
-        <h3>CPL to EPL Transition</h3>
-          <ul>
-            <li><A href="cpl2eplfaq.php">CPL to EPL Transition Plan Frequently Asked Questions</a><br />
-  	          This FAQ answers some of the commonly asked questions about transition from the 
-  	          <a href="http://www.ibm.com/developerworks/library/os-cpl.html" target="_blank">Common Public License (CPL)</a> 
-  	          to the <a href="../../org/documents/epl-v10.php">Eclipse Public License (EPL)</a>.
-  	        </li>
-            <li><A href="CPL2EPLTransitionPlan.pdf">CPL to EPL Transition Plan</A>
-	           The detailed plan (.pdf) for transitioning from the Common Public License (CPL) to the Eclipse Public License (EPL).
-	        </li>
-	      </ul>
-	  </div>
-	 <div class="homeitem3col">
-	 	<h3>Agreements and Licenses</h3>
-	 	<li><A href="notice.php">Eclipse.org Software User Agreement</A> 
-            By downloading builds or accessing the CVS repository, you 
-            acknowledge that you have read, understood, and agree to be bound by the 
-            terms and conditions contained in this agreement.  This agreement is
-	        used for projects that default to the Common Public License (CPL).
-	      </li>
-	  </div>
-	<div class="homeitem3col">
-        <h3>Frequently Asked Questions</h3>
-        	<li><A href="http://www.ibm.com/developerworks/opensource/library/os-cplfaq/index.html" target="_blank">CPL Frequently Asked Questions</A> 
-            Written by IBM and hosted at IBM&rsquo;s developerWorks site, this FAQ answers some of the commonly asked questions about the Common Public License (CPL).
-          	</li>
-	</div>
-	<div class="homeitem3col">
-        <h3>Resources for Committers</h3>
-            <li><A href="about.php">&quot;About&quot; Template (CPL References)</A>
-	        This is a template for an &quot;about.html&quot; (&quot;About&quot;) file that describes 
-	        CPL-licensed content.  Abouts contain legal documentation and are maintained in the CVS repository
-	        and subsequently included in builds in plug-in and other directories.  They usually contain 
-	        information about licensing and sometimes also information
-	        about any use of cryptography.  By convention, every plug-in usually has an About.  If all the 
-	        content in a plug-in, directory or module can be correctly
-	        licensed under the CPL then this template can be used without modification.  Any other About 
-	        should be approved by the relevant PMC who can also assist committers with drafting an About.
-	        </li>
-            <li><A href="cpl_copyrightandlicensenotice.php">Default Copyright and License Notice</A>
-	        The standard copyright and license notice should appear in all source files where possible.  Variations on this notice may be required (for example where a license other than
-	        the CPL or EPL governs the use of the file).
-	        </li>
-	</div>
-	</div>		
-  </div>
+$pageTitle = "CPL to EPL Conversion";
 
-EOHTML;
-	$App->setOutDated('now');
-	# Generate the web page
-	$App->generatePage('solstice', $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, documents, about, cpl, epl, conversion");
+$Theme->setPageAuthor("M. Milinkovich Nov 21/05");
+
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
+
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/cpl2epl/notice.php b/cpl2epl/notice.php
index 6426874..b83260e 100644
--- a/cpl2epl/notice.php
+++ b/cpl2epl/notice.php
@@ -1,115 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Eclipse.org Software User Agreement";
-	$pageKeywords	= "legal, about";
-	$pageAuthor		= "M. Milinkovich Nov 21/05";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	<h1>$pageTitle</h1>
-	<div id="midcolumn">
-	
-	<p>ECLIPSE.ORG 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 Eclipse.org is provided to you under the terms and conditions of the Common Public License Version 1.0
-   	(&quot;CPL&quot;).  A copy of the CPL is provided with this Content and is also available at <a href="../cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>.
-   	For purposes of the CPL, &quot;Program&quot; will mean the Content.</p>
+include ($App->getProjectCommon());
 
-	<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>
+$pageTitle = "Eclipse.org Software User Agreement";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, about");
+$Theme->setPageAuthor("M. Milinkovich Nov 21/05");
 
-	<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>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-	<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 Eclipse.org 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 CPL 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>Eclipse Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-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://www-128.ibm.com/developerworks/opensource/library/os-ipl.html">http://www-128.ibm.com/developerworks/opensource/library/os-ipl.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 Eclipse.org 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 countrys 
-   	laws, regulations and policies concerning the import,
-   	possession, or use, and re-export of encryption software, to see if this is permitted.</p> 
-   	
-	</div>
-	<div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-			<li><a href="notice.html">CPL Software User Agreement in plain HTML</a></li>
-			<li><a href="index.php">CPL to EPL conversion</a></li>
-			<li><a href="../guidetolegaldoc.php">Guide to legal documents</a></li>
-			</ul>
-		</div>
-	</div>
-	
-EOHTML;
-
-	$App->setOutDated('now');
-	# Generate the web page
-	$App->generatePage('solstice', $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/dd/index.php b/dd/index.php
index 56e7fed..c1cfab2 100644
--- a/dd/index.php
+++ b/dd/index.php
@@ -1,2 +1,16 @@
-<?php 
+<?php
+/**
+ * Copyright (c) 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Wayne Beaton (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 header("Location: /legal/EclipseLegalProcessPoster.pdf");
\ No newline at end of file
diff --git a/ecafaq.php b/ecafaq.php
index 1d1c3bb..c5fb660 100644
--- a/ecafaq.php
+++ b/ecafaq.php
@@ -1,213 +1,35 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2016 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
+/**
+ * Copyright (c) 2016, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
- *    Mike Milinkovich (Eclipse Foundation) - Initial implementation
- *    Christopher Guindon (Eclipse Foundation)
- *******************************************************************************/
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Christopher Guindon (Eclipse Foundation)
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-  require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-  $App = new App();
-  $Nav = new Nav();
-  $Menu = new Menu();
-  include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+$App = new App();
+$Theme = $App->getThemeClass();
 
-  # Begin: page-specific settings.  Change these.
-  $pageTitle     = "Eclipse Contributor Agreement (ECA) FAQ";
-  $pageKeywords  = "legal, documents, about, contributor, license, agreement, IP, intellectual property, ECA";
-  $pageAuthor    = "Mike Milinkovich";
+include ($App->getProjectCommon());
 
-  ob_start();
-  ?>
-  <div id="midcolumn">
-    <h1><?php echo $pageTitle; ?></h1>
-    <p>Last updated August 10, 2016</p>
-    <p>The <a href="ECA.php">Eclipse Contributor Agreement</a> (ECA) is a key document in
-    the process of managing intellectual property contributions to Eclipse projects. This FAQ is
-    intended to help explain what they are, and how they are used.</p>
-    <div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingOne">
-          <h4 class="panel-title">
-            <a role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseOne" aria-expanded="true" aria-controls="collapseOne">
-              1. What does the ECA do?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseOne" class="panel-collapse collapse in" role="tabpanel" aria-labelledby="headingOne">
-          <div class="panel-body">
-            The purpose of the ECA is to provide a written record that you have agreed to
-            provide your contributions of code and documentation under the licenses used by
-            the Eclipse project(s) you're contributing to. It also makes it clear that you
-            are promising that what you are contributing to Eclipse is code that you wrote, and
-            you have the necessary rights to contribute it to our projects. And finally, it documents a
-            commitment from you that your open source contributions will be permanently on
-            the public record.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingTwo">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseTwo" aria-expanded="false" aria-controls="collapseTwo">
-              2. Why is a ECA necessary?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseTwo" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingTwo">
-          <div class="panel-body">
-            It's basically about documenting the provenance of all of the intellectual property coming
-            into Eclipse. We want to have a clear record that you have agreed to the terms under which
-            the Eclipse community has agreed to accept contributions.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingThree">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseThree" aria-expanded="false" aria-controls="collapseThree">
-              3. Does this means that the Eclipse Foundation will own my code?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseThree" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingThree">
-          <div class="panel-body">
-            No. The ECA does not include a license or assignment to the Eclipse Foundation. Unlike
-            many other open source communities or projects, Eclipse simply wants you to license your
-            contributions under the open source license(s) used by the project. So you (or your employer)
-            will continue to own your code.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingFour">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseFour" aria-expanded="false" aria-controls="collapseFour">
-              4. Why do you need to know my personal information?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseFour" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingFour">
-          <div class="panel-body">
-            As part of our open source project recordkeeping, we want to be able to link every line
-            of code to the people who contributed them. In the unlikely event of a dispute over
-            authorship or copyright provenance, Eclipse needs to be able to demonstrate when the code
-            arrived at Eclipse, how we acquired the rights to that code, and who wrote it
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingFive">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseFive" aria-expanded="false" aria-controls="collapseFive">
-              5. How long is the ECA good for?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseFive" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingFive">
-          <div class="panel-body">
-            The ECA is good for three years, after which it will be expired and you will be asked
-            to complete a new one. However, if your personal information changes (e.g. your address
-            or your employer), we ask that you invalidate your current ECA and complete a new one.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingSix">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseSix" aria-expanded="false" aria-controls="collapseSix">
-              6. Does the ECA replace my committer agreement?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseSix" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingSix">
-          <div class="panel-body">
-            No. Your Committer Agreement is the agreement that allows you to have write access to the Eclipse Foundation
-            source code repositories. The ECA is intended for people who are not committers who wish to make
-            contributions to Eclipse projects.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingSeven">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseSeven" aria-expanded="false" aria-controls="collapseSeven">
-              7. I am an Eclipse committer. Do I need to sign a ECA?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseSeven" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingSeven">
-          <div class="panel-body">
-            Maybe. You do not need to sign a ECA to work on the projects for which you are a committer.
-            However, if you want to make contributions to an Eclipse project for which you are <strong>not</strong>
-            a committer, you will need a ECA.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingEight">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseEight" aria-expanded="false" aria-controls="collapseEight">
-              8. What happens if I don't sign the ECA?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseEight" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingEight">
-          <div class="panel-body">
-            Nothing, except you won't be allowed to contribute to open source
-            projects at Eclipse
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingNine">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseNine" aria-expanded="false" aria-controls="collapseNine">
-              9. Eclipse has been around a long time. Why are you doing ECAs now?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseNine" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingNine">
-          <div class="panel-body">
-            We want to make it easier for you to contribute to Eclipse projects. Previously, we have been asking contributors
-            to agree to the equivalent of the ECA via Bugzilla or Gerrit on each and every contribution.
-            Moving to ECAs is intended to streamline that process, and make it easier for contributions to
-            be accepted by Eclipse projects.
-          </div>
-        </div>
-      </div>
-      <div class="panel panel-info">
-        <div class="panel-heading" role="tab" id="headingTen">
-          <h4 class="panel-title">
-            <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseTen" aria-expanded="false" aria-controls="collapseTen">
-              10. How do I sign a ECA?
-            </a>
-          </h4>
-        </div>
-        <div id="collapseTen" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingTen">
-          <div class="panel-body">
-            Log into the <a href="http://www.eclipse.org/contribute/cla">Eclipse projects forge</a>
-            (you will need to create an account with the Eclipse Foundation if you have not
-            already done so); click on "Eclipse Contributor Agreement"; and Complete the form.
-            Be sure to use the same email address when you register for the
-            account that you intend to use on Git commit records.
-          </div>
-        </div>
-      </div>
-    </div>
-  </div>
-<?php
-  include('content/eca_sidebar.php');
-  $html = ob_get_contents();
-  ob_end_clean();
+$pageTitle = "Eclipse Contributor Agreement (ECA) FAQ";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, documents, about, contributor, license, agreement, IP, intellectual property, ECA");
+$Theme->setPageAuthor("Mike Milinkovich");
 
-  # Generate the web page
-  $App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
+
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/epl-2.0/faq.php b/epl-2.0/faq.php
index afc2f72..ebbea46 100644
--- a/epl-2.0/faq.php
+++ b/epl-2.0/faq.php
@@ -1,24 +1,26 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2017 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://eclipse.org/legal/epl-v10.html
- *******************************************************************************/
+/**
+ * Copyright (c) 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Wayne Beaton (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
 
 $App = new App();
-$Nav = new Nav();
-$Menu = new Menu();
+$Theme = $App->getThemeClass();
 
 require_once ($App->getProjectCommon());
 
 $pageTitle = "EPL-2.0 FAQ";
-$pageKeywords = "eclipse public license, epl";
-$pageAuthor = "Wayne Beaton";
 
 // FIXME Workaround because I can't get Asciidoctor to generate embeddable HTML
 function getBodyContent($path)
@@ -43,5 +45,11 @@
 <?php
 $html = ob_get_clean();
 
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("eclipse public license, epl");
+$Theme->setPageAuthor("Wayne Beaton");
+
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
 
diff --git a/epl-2.0/index.php b/epl-2.0/index.php
index fcdeb8f..152b81c 100644
--- a/epl-2.0/index.php
+++ b/epl-2.0/index.php
@@ -1,24 +1,27 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2017 Eclipse Foundation and others.
- * 
- * This program and the accompanying materials are made available 
- * under the terms of the Eclipse Public License 2.0 which accompanies 
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+/**
+ * Copyright (c) 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Wayne Beaton (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
 require_once ($_SERVER['DOCUMENT_ROOT'] . "/projects/classes/Project.class.php");
 
 $App = new App();
-$Menu = new Menu();
-$Nav = new Nav();
+$Theme = $App->getThemeClass();
 
 include($App->getProjectCommon());
 
 $pageTitle ="Eclipse Public License 2.0";
-$pageAuthor = "Wayne Beaton";
 
 $source = dirname(__FILE__) . "/../../org/documents/epl-2.0/EPL-2.0.html";
 
@@ -56,7 +59,7 @@
           <ul>
           <?php 
             foreach(Project::getProjectsWithLicense('EPL-2.0') as $project) {
-              echo "<li><a href=\"{$project->getUrl()}\">{$project->getFormalName()}</a></li>";
+              //echo "<li><a href=\"{$project->getUrl()}\">{$project->getFormalName()}</a></li>";
             }
           ?>
           </ul>
@@ -67,5 +70,10 @@
 <?php
 $html = ob_get_clean();
 
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("");
+$Theme->setPageAuthor("Wayne Beaton");
+
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/epl/about.php b/epl/about.php
index 1fe6c18..adb2b39 100644
--- a/epl/about.php
+++ b/epl/about.php
@@ -1,22 +1,26 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2005, 2017 Eclipse Foundation and others.
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
+
 $App = new App();
-$Nav = new Nav();
-$Menu = new Menu();
+$Theme = $App->getThemeClass();
+
 include ($App->getProjectCommon());
 
-$pageTitle = "About File Templates";
-$pageKeywords = "about, legal, foundation";
-$pageAuthor = "Wayne Beaton, Nov. 30, 2017";
+
 
 function getBodyContent($path)
 {
@@ -30,184 +34,16 @@
     return $content;
 }
 
+$pageTitle = "About File Templates";
+$Theme->setPageTitle($pageTitle);
+
+$Theme->setPageKeywords("about, legal, foundation");
+$Theme->setPageAuthor("Wayne Beaton, Nov. 30, 2017");
+
 ob_start();
-?>
-<style>
-.html-content {
-	border-style: solid;
-	border-width: 1px;
-	padding: 3px;
-	margin: 5px;
-}
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-.html-content h2 {
-	margin-top: 0;
-	font-size: 120%;
-	border-style: none;
-	font-size: 120%;
-}
-
-.html-content h3 {
-	font-size: 110%;
-	border-style: none;
-}
-</style>
-
-<div id="midcolumn">
-	<h1>
-		<a name="top"></a><?php print $pageTitle; ?></h1>
-	<p>
-		<em>Abouts</em> contain legal documentation and are maintained in the
-		source code repository and subsequently included in builds in <em>Eclipse
-			Platform Plug-in and Fragments</em> and other directories. They
-		usually contain information about licensing and sometimes also
-		information about any use of cryptography. By convention, every
-		Eclipse Platform Plug-in and Fragment usually has an <em>About</em>.
-	</p>
-	<blockquote>
-		<p>
-			<em>About</em> files are generally only applicable for content that
-			that is delivered as <em>Eclipse Platform Plug-ins and Fragments</em>.
-			For more information, please see <a
-				href="/projects/handbook/#legaldoc">The Eclipse Project Handbook</a>
-		</p>
-	</blockquote>
-
-	<p>
-		All <em>Abouts</em> will be reviewed and approved by the EMO during
-		the <a href="/projects/handbook/#release-review">Release Review</a>
-		for your project.
-	</p>
-	<p>
-		If you have any questions, please send an email to <a
-			href="mailto:license@eclipse.org">license@eclipse.org</a>.
-	</p>
-	<p>
-		There are two <em>About</em> file templates that committers can choose
-		from. The <a href="#short">first</a> one is for plug-ins where all of
-		the content is to be licensed under the Eclipse Public License (<a
-			href="/legal/epl-2.0">EPL</a>). If all the content in an Eclipse
-		Platform Plug-in or Fragment, directory or module can be correctly
-		licensed under the EPL then this simple (short) template can be used
-		without modification.
-	</p>
-	<p>
-		The <a href="#long">second</a> template should be used when at least
-		some of the content of the Eclipse Platform Plug-in or Fragment is
-		licensed under a license other than the <a href="/legal/epl-2.0">EPL</a>.
-		When using this longer template, your <em>Abouts</em> should be
-		reviewed and approved by the relevant PMC, who can also assist
-		committers with drafting an <em>About</em>.
-	</p>
-	<p>
-		If your project content makes use of Cryptography, please send an
-		email to <a href="mailto:license@eclipse.org">license@eclipse.org</a>
-		to request assistance in creating the <em>About</em> file.
-	</p>
-
-	<h2>
-		<a name="short"></a><em>About</em> File Template for EPL 2.0 Content
-	</h2>
-
-	<p>
-		Here is a relatively simple <a href="epl-2.0/about.html">template
-			about.html</a> file that should suffice in most cases where the
-		plug-in contains all Eclipse project-produced EPL 2.0 code.
-	</p>
-
-	<div class="html-content">
-	<?php print getBodyContent('epl-2.0/about.html');?>
-	</div>
-	
-	<p>
-		For further information on the use of <em>Abouts</em>, and how these
-		files should be included in your software distribution, please read
-		the relevant section in the <a
-			href="/projects/handbook/#legaldoc-plugins">Legal Documentation for
-			Eclipse Platform Plug-ins and Fragments</a> (under the EPL-2.0).
-	</p>
-
-	<h2>
-		<a name="short-1.0"></a><em>About</em> File Template for EPL 1.0
-		Content
-	</h2>
-
-	<p>
-		Here is a relatively simple <a href="about.html">template about.html</a>
-		file that should suffice in most cases where the plug-in contains all
-		Eclipse project-produced EPL 1.0 code.
-	</p>
-
-	<div class="html-content">
-	<?php print getBodyContent('about.html'); ?>
-	</div>
-
-	<p>
-		For further information on the use of <em>Abouts</em>, and how these
-		files should be included in your software distribution, please read
-		the relevant section in the <a
-			href="../guidetolegaldoc-EPL-1.0.php#Abouts">Guide to Legal
-			Documentation under the EPL 1.0</a>.
-	</p>
-
-	<h2>
-		<a name="long"></a>Third-Party Content <em>About</em> File Template
-		for EPL 2.0
-	</h2>
-
-	<p>
-		Here is an <a href="epl-2.0/longabout.html">template about.html</a>
-		file that contains third-party content.
-	</p>
-
-	<div class="html-content">
-	<?php print getBodyContent('epl-2.0/longabout.html');?>
-	</div>
-
-	<h2>
-		<a name="long-1.0"></a>Third-Party Content <em>About</em> File
-		Template for EPL 1.0
-	</h2>
-
-	<p>
-		Here is an <a href="longabout.html">template about.html</a> file that
-		contains third-party content.
-	</p>
-
-	<div class="html-content">
-	<?php print getBodyContent('longabout.html'); ?>
-	</div>
-</div>
-<div id="rightcolumn">
-	<div class="sideitem">
-		<h6>EPL 2.0 Links</h6>
-		<ul>
-			<li><a href="epl-2.0/about.html"><code>about.html</code> in plain
-					HTML</a></li>
-			<li><a href="epl-2.0/longabout.html">Third-Party Content <code>about.html</code>
-					in plain HTML
-			</a></li>
-			<li><a href="/projects/handbook/#legaldoc-plugins">Legal
-					Documentation for Eclipse Platform Plug-ins and Fragments</a>
-				(under the EPL-2.0)</li>
-		</ul>
-	</div>
-	<div class="sideitem">
-		<h6>EPL 1.0 Links</h6>
-		<ul>
-			<li><a href="about.html"><code>about.html</code> in plain HTML</a></li>
-			<li><a href="longabout.html">Third-Party Content <code>about.html</code>
-					in plain HTML
-			</a></li>
-			<li><a href="../guidetolegaldoc-EPL-1.0.php#Abouts">Guide to the
-					Legal Documentation for Eclipse Plug-ins and Features under the
-					EPL-1.0</a></li>
-		</ul>
-	</div>
-</div>
-
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/epl/content/en_about.php b/epl/content/en_about.php
new file mode 100644
index 0000000..fb552b2
--- /dev/null
+++ b/epl/content/en_about.php
@@ -0,0 +1,189 @@
+<?php
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+
+<style>
+.html-content {
+  border-style: solid;
+  border-width: 1px;
+  padding: 3px;
+  margin: 5px;
+}
+
+.html-content h2 {
+  margin-top: 0;
+  font-size: 120%;
+  border-style: none;
+  font-size: 120%;
+}
+
+.html-content h3 {
+  font-size: 110%;
+  border-style: none;
+}
+</style>
+
+<div id="midcolumn">
+  <h1>
+    <a name="top"></a><?php print $pageTitle; ?></h1>
+  <p>
+    <em>Abouts</em> contain legal documentation and are maintained in the
+    source code repository and subsequently included in builds in <em>Eclipse
+      Platform Plug-in and Fragments</em> and other directories. They
+    usually contain information about licensing and sometimes also
+    information about any use of cryptography. By convention, every
+    Eclipse Platform Plug-in and Fragment usually has an <em>About</em>.
+  </p>
+  <blockquote>
+    <p>
+      <em>About</em> files are generally only applicable for content that
+      that is delivered as <em>Eclipse Platform Plug-ins and Fragments</em>.
+      For more information, please see <a
+        href="/projects/handbook/#legaldoc">The Eclipse Project Handbook</a>
+    </p>
+  </blockquote>
+
+  <p>
+    All <em>Abouts</em> will be reviewed and approved by the EMO during
+    the <a href="/projects/handbook/#release-review">Release Review</a>
+    for your project.
+  </p>
+  <p>
+    If you have any questions, please send an email to <a
+      href="mailto:license@eclipse.org">license@eclipse.org</a>.
+  </p>
+  <p>
+    There are two <em>About</em> file templates that committers can choose
+    from. The <a href="#short">first</a> one is for plug-ins where all of
+    the content is to be licensed under the Eclipse Public License (<a
+      href="/legal/epl-2.0">EPL</a>). If all the content in an Eclipse
+    Platform Plug-in or Fragment, directory or module can be correctly
+    licensed under the EPL then this simple (short) template can be used
+    without modification.
+  </p>
+  <p>
+    The <a href="#long">second</a> template should be used when at least
+    some of the content of the Eclipse Platform Plug-in or Fragment is
+    licensed under a license other than the <a href="/legal/epl-2.0">EPL</a>.
+    When using this longer template, your <em>Abouts</em> should be
+    reviewed and approved by the relevant PMC, who can also assist
+    committers with drafting an <em>About</em>.
+  </p>
+  <p>
+    If your project content makes use of Cryptography, please send an
+    email to <a href="mailto:license@eclipse.org">license@eclipse.org</a>
+    to request assistance in creating the <em>About</em> file.
+  </p>
+
+  <h2>
+    <a name="short"></a><em>About</em> File Template for EPL 2.0 Content
+  </h2>
+
+  <p>
+    Here is a relatively simple <a href="epl-2.0/about.html">template
+      about.html</a> file that should suffice in most cases where the
+    plug-in contains all Eclipse project-produced EPL 2.0 code.
+  </p>
+
+  <div class="html-content">
+  <?php print getBodyContent('epl-2.0/about.html');?>
+  </div>
+  
+  <p>
+    For further information on the use of <em>Abouts</em>, and how these
+    files should be included in your software distribution, please read
+    the relevant section in the <a
+      href="/projects/handbook/#legaldoc-plugins">Legal Documentation for
+      Eclipse Platform Plug-ins and Fragments</a> (under the EPL-2.0).
+  </p>
+
+  <h2>
+    <a name="short-1.0"></a><em>About</em> File Template for EPL 1.0
+    Content
+  </h2>
+
+  <p>
+    Here is a relatively simple <a href="about.html">template about.html</a>
+    file that should suffice in most cases where the plug-in contains all
+    Eclipse project-produced EPL 1.0 code.
+  </p>
+
+  <div class="html-content">
+  <?php print getBodyContent('about.html'); ?>
+  </div>
+
+  <p>
+    For further information on the use of <em>Abouts</em>, and how these
+    files should be included in your software distribution, please read
+    the relevant section in the <a
+      href="../guidetolegaldoc-EPL-1.0.php#Abouts">Guide to Legal
+      Documentation under the EPL 1.0</a>.
+  </p>
+
+  <h2>
+    <a name="long"></a>Third-Party Content <em>About</em> File Template
+    for EPL 2.0
+  </h2>
+
+  <p>
+    Here is an <a href="epl-2.0/longabout.html">template about.html</a>
+    file that contains third-party content.
+  </p>
+
+  <div class="html-content">
+  <?php print getBodyContent('epl-2.0/longabout.html');?>
+  </div>
+
+  <h2>
+    <a name="long-1.0"></a>Third-Party Content <em>About</em> File
+    Template for EPL 1.0
+  </h2>
+
+  <p>
+    Here is an <a href="longabout.html">template about.html</a> file that
+    contains third-party content.
+  </p>
+
+  <div class="html-content">
+  <?php print getBodyContent('longabout.html'); ?>
+  </div>
+</div>
+<div id="rightcolumn">
+  <div class="sideitem">
+    <h6>EPL 2.0 Links</h6>
+    <ul>
+      <li><a href="epl-2.0/about.html"><code>about.html</code> in plain
+          HTML</a></li>
+      <li><a href="epl-2.0/longabout.html">Third-Party Content <code>about.html</code>
+          in plain HTML
+      </a></li>
+      <li><a href="/projects/handbook/#legaldoc-plugins">Legal
+          Documentation for Eclipse Platform Plug-ins and Fragments</a>
+        (under the EPL-2.0)</li>
+    </ul>
+  </div>
+  <div class="sideitem">
+    <h6>EPL 1.0 Links</h6>
+    <ul>
+      <li><a href="about.html"><code>about.html</code> in plain HTML</a></li>
+      <li><a href="longabout.html">Third-Party Content <code>about.html</code>
+          in plain HTML
+      </a></li>
+      <li><a href="../guidetolegaldoc-EPL-1.0.php#Abouts">Guide to the
+          Legal Documentation for Eclipse Plug-ins and Features under the
+          EPL-1.0</a></li>
+    </ul>
+  </div>
+</div>
\ No newline at end of file
diff --git a/epl/content/en_notice.php b/epl/content/en_notice.php
new file mode 100644
index 0000000..1817934
--- /dev/null
+++ b/epl/content/en_notice.php
@@ -0,0 +1,31 @@
+<?php
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+?>
+
+<div id="maincontent">
+  <div id="midcolumn">
+    <?php print $epl; ?>
+  </div>
+    <div id="rightcolumn">
+        <div class="sideitem">
+            <h6>Related Links</h6>
+            <ul>
+            <li><a href="notice.html">Software User Agreement in plain HTML</a></li>
+            <li><a href="feature.properties.txt">Software User Agreement in Java properties format</a></li>
+            <li><a href="../guidetolegaldoc.php">Guide to legal documents</a></li>
+            </ul>
+        </div>
+    </div>
+</div>
\ No newline at end of file
diff --git a/epl/notice.php b/epl/notice.php
index 81720c5..0d30195 100644
--- a/epl/notice.php
+++ b/epl/notice.php
@@ -1,53 +1,43 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2005, 2017 Eclipse Foundation and others.
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
+
 $App = new App();
-$Nav = new Nav();
-$Menu = new Menu();
 
-include($App->getProjectCommon());
+include ($App->getProjectCommon());
 
-$pageTitle 		= "Eclipse Foundation Software User Agreement";
-$pageKeywords	= "eclipse, license, user, agreement, sua";
-$pageAuthor		= "Mike Milinkovich";
+$pageTitle = "Eclipse Foundation Software User Agreement";
 
 // Fetch notice.html content from <body></body>
-$DOMDocument = new DOMDocument;
+$DOMDocument = new DOMDocument();
 $DOMDocument->loadHTMLFile(dirname(__FILE__) . "/notice.html");
 $body = $DOMDocument->getElementsByTagName('body')->item(0);
 $epl = "";
 foreach ($body->childNodes as $childNode) {
-    $epl .= $DOMDocument->saveHTML($childNode);
+  $epl .= $DOMDocument->saveHTML($childNode);
 }
-ob_start();
-?>
-<div id="maincontent">
-  <div id="midcolumn">
-    <?php print $epl; ?>
-  </div>
-    <div id="rightcolumn">
-        <div class="sideitem">
-            <h6>Related Links</h6>
-            <ul>
-            <li><a href="notice.html">Software User Agreement in plain HTML</a></li>
-            <li><a href="feature.properties.txt">Software User Agreement in Java properties format</a></li>
-            <li><a href="../guidetolegaldoc.php">Guide to legal documents</a></li>
-            </ul>
-        </div>
-    </div>
-</div>
 
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav , $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("eclipse, license, user, agreement, sua");
+$Theme->setPageAuthor("Mike Milinkovich");
+
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
+
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/eplfaq.php b/eplfaq.php
index 2f4cf3f..57e85bc 100644
--- a/eplfaq.php
+++ b/eplfaq.php
@@ -1,463 +1,34 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2005,2017 Eclipse Foundation and others.
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
 
 $App = new App();
-$Nav = new Nav();
-$Menu = new Menu();
+$Theme = $App->getThemeClass();
+
 include ($App->getProjectCommon());
 
 $pageTitle = "Eclipse Public License 1.0 (EPL) Frequently Asked Questions";
-$pageKeywords = "epl, cpl, legal, faq, foundation, eclipse, license, licenses";
-$pageAuthor = "Mike Milinkovich, Nov. 21, 2005";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("epl, cpl, legal, faq, foundation, eclipse, license, licenses");
+$Theme->setPageAuthor("Mike Milinkovich, Nov. 21, 2005");
 
 ob_start();
-?>
-<div id="midcolumn">
-	<h1><?php echo $pageTitle; ?></h1>
-	<p>
-		<strong>Please see the <a
-			href="https://www.eclipse.org/org/documents/epl-2.0/faq.php">Eclipse
-				Public License 2.0 FAQ</a>.
-		</strong>
-	</p>
-	<p>
-		<strong>For informational purposes only.</strong>
-	</p>
-	<p>
-		This FAQ attempts to provide answers to commonly asked questions
-		related to <em>the <a href="../org/documents/epl-v10.php">Eclipse
-				Public License 1.0 (EPL)</a></em>. It is provided for informational
-		purposes only. It is not part of, nor does it modify, amend, or
-		supplement the terms of the EPL. The EPL is a legal agreement that
-		governs the rights granted to material licensed under it, so please
-		read it carefully. If there is any conflict between this FAQ and the
-		EPL, the terms of the EPL shall govern. This FAQ should not be
-		regarded as legal advice. If you need legal advice, you must contact
-		your own lawyer.
-	</p>
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-	<div class="homeitem3col">
-		<h3>Table of Contents</h3>
-		<ol>
-			<li><a href="#CPLEPL">What is the relationship between the CPL and
-					the EPL 1.0?</a></li>
-			<li><a href="#WHYEPL">Why was the EPL 1.0 written?</a></li>
-			<li><a href="#EPLDIFFER">Specifically how does the EPL 1.0 differ
-					from the CPL?</a></li>
-			<li><a href="#EPLVERSION">What is the latest version of the EPL</a></li>
-			<li><a href="#MEMAPPROVE">Do all Eclipse Foundation members approve
-					of the EPL?</a></li>
-			<li><a href="#TRANSITION">How and when will the Eclipse Foundation
-					transition from the CPL to the EPL 1.0?</a></li>
-			<li><a href="#EPLOSI">Is the EPL approved by the Open Source
-					Initiative (OSI)?</a></li>
-			<li><a href="#LICAPP">What is required for OSI license approval?</a></li>
-			<li><a href="#BUSADVOS">What are the business advantages of the Open
-					Source model?</a></li>
-			<li><a href="#TECHADVOS">What are the technical advantages of the
-					Open Source model?</a></li>
-			<li><a href="#PARTIESEPL">How are the parties defined in the EPL 1.0?</a></li>
-			<li><a href="#ANONCONTR">Can a Contributor remain anonymous?</a></li>
-			<li><a href="#RECRIGHTS">What rights do Contributors grant Recipients
-					under EPL 1.0?</a></li>
-			<li><a href="#USEINANOTHER">Does the EPL 1.0 allow me to take the
-					Source Code for a Program licensed under it and include all or part
-					of it in another program licensed under the GPL, BSD license or
-					other Open Source license?</a></li>
-			<li><a href="#COMPILEWOMOD">Can I take a Program licensed under the
-					EPL 1.0, compile it without modification, and commercially license
-					the result?</a></li>
-			<li><a href="#SOURCEWOBJ">Do I need to include the source code for
-					such Program with the object code distribution?</a></li>
-			<li><a href="#PROPPROD">When I incorporate a portion of a Program
-					licensed under the EPL 1.0 into my own proprietary product
-					distributed in object code form, can I use a single license for the
-					full product, in other words, covering the portion of the Program
-					plus my own code?</a></li>
-			<li><a href="#AGREESTEWARD">The EPL states that it can be changed by
-					the Agreement Steward. Does a Contributor have the choice of
-					redistributing a previously distributed Program under the old or
-					the new version of the EPL?</a></li>
-			<li><a href="#MODNODIST">If I modify a Program licensed under the
-					EPL, but never distribute it to anyone else, do I have to make my
-					modifications available to others?</a></li>
-			<li><a href="#MODDIST">If I modify a Program licensed under the EPL
-					and distribute the object code of the modified Program for free,
-					must I make the source code available?</a></li>
-			<li><a href="#MODULEDIST">If I write a module to add to a Program
-					licensed under the EPL and distribute the object code of the module
-					along with the rest of the Program, must I make the source code to
-					my module available in accordance with the terms of the EPL?</a></li>
-			<li><a href="#SRCREDIST">What are my obligations if I copy source
-					code obtained from Eclipse.org and licensed under the Eclipse
-					Public License and include it in my product that I then distribute?</a></li>
-			<li><a href="#EPLWARRANTY">Does the EPL offer any warranty with
-					regard to the Program?</a></li>
-			<li><a href="#GETANSWER">This document does not have the answer to my
-					question. How can I get my question answered?</a></li>
-			<li><a href="#DERIV">Some open source software communities specify
-					what they mean by a &quot;derivative work&quot;. Does the Eclipse
-					Foundation have a position on this?</a></li>
-			<li><a href="#LINK">Some free software communities say that linking
-					to their code automatically means that your program is a derivative
-					work. Is this the position of the Eclipse Foundation?</a></li>
-			<li><a href="#EXAMPLE">I&lsquo;m a programmer not a lawyer, can you
-					give me a clear cut example of when something is or is not a
-					derivative work?</a></li>
-			<li><a href="#USEEPL">I am starting my own open source software
-					project. Does the Eclipse Foundation allow me to use the EPL for my
-					project?</a></li>
-			<li><a href="#CODEGEN">Many Eclipse tools and wizards use code
-					templates which are included in the application that is generated.
-					Is the code generated by these tools considered a derivative work
-					that must be licensed under the EPL?</a></li>
-			<li><a href="#3RDPARTY">What licenses are acceptable for third-party
-					code redistributed by Eclipse projects?</a></li>
-			<li><a href="#OSICOMPLIANT">Is an OSI-compliant license a requirement
-					for all third-party code redistributed by Eclipse projects?</a></li>
-			<li><a href="#GPLCOMPATIBLE">Are the Eclipse Public License (EPL) 1.0
-					and the General Public License (GPL) compatible?</a></li>
-			<li><a href="#DUALLIC">For dual-licensed projects, which license
-					terms apply?</a></li>
-		</ol>
-	</div>
-	<h3>Frequently Asked Questions</h3>
-	</blockquote>
-	<ol>
-		<li><strong><a name="CPLEPL">What is the relationship between
-					IBM&rsquo;s Common Public License (CPL) and the Eclipse Public
-					License 1.0 (EPL)?</a></strong><br /> </b>The Eclipse SDK codebase was
-			originally distributed under the CPL. The EPL 1.0 was derived from <a
-			href="http://www-128.ibm.com/developerworks/library/os-cpl.html"
-			target="_blank">CPL version 1.0</a>. As a result, much of the
-			information provided in the <a
-			href="http://www.ibm.com/developerworks/opensource/library/os-cplfaq/index.html"
-			target="_blank">Common Public License (CPL) Frequently Asked
-				Questions</a> document is relevant to the EPL, as well. The purpose
-			of this FAQ is to highlight the differences.<br /> <br /></li>
-		<li><strong><a name="WHYEPL">Why was the EPL 1.0 written?</a></strong><br />
-			The EPL 1.0 was written specifically for the <a href="../org/"
-			target="_top">Eclipse Foundation</a>. First, it changes the Agreement
-			Steward, formerly IBM for the CPL, to now be the Eclipse Foundation
-			for the EPL. Second, it addresses concerns some Eclipse Foundation
-			members had with how the CPL deals with possible patent litigation.<br />
-			<br /></li>
-		<li><strong><a name="EPLDIFFER">Specifically how does the EPL 1.0
-					differ from the CPL?</a><br /> </strong>Section 7 of the CPL
-			contained the following language:<br /> <br /> <em>&quot;If Recipient
-				institutes patent litigation against a Contributor with respect to a
-				patent applicable to software (including a cross-claim or
-				counterclaim in a lawsuit), then any patent licenses granted by that
-				Contributor to such Recipient under this Agreement shall terminate
-				as of the date such litigation is filed. In addition, 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&rsquo;s patent(s), then such
-				Recipient&rsquo;s rights granted under Section 2(b) shall terminate
-				as of the date such litigation is filed.&quot;<br /> <br />
-		</em> The first sentence was removed in the EPL 1.0. Many members and
-			prospective members believed that the first sentence was overly broad
-			and viewed it as an inhibitor to the continued growth of the Eclipse
-			eco-system. The second sentence remains unchanged in the EPL 1.0.<br />
-			<br /> The current <a href="../org/documents/Eclipse_IP_Policy.pdf">Eclipse
-				Foundation Intellectual Property Policy</a> further clarifies the
-			general principles under which the Eclipse Foundation shall accept
-			contributions, license contributions, license materials owned by the
-			Eclipse Foundation, and manage other intellectual property matters.<br />
-			<br /></li>
-		<li><strong><a name="EPLVERSION">What is the latest version of the
-					EPL?</a><br /> </strong><a href="epl-2.0">Version 2.0</a> is the
-			latest version of the EPL. Please see the <a
-			href="https://www.eclipse.org/org/documents/epl-2.0/faq.php">Eclipse
-				Public License 2.0 FAQ</a>.<br /> <br /></li>
-		<li><strong><a name="MEMAPPROVE">Do all Eclipse Foundation members
-					approve of the EPL?</a><br /> </strong>Yes, the Eclipse Foundation
-			membership approved the EPL 1.0 unanimously. Future members must
-			agree to abide by the EPL and the Intellectual Property Policy as
-			part of joining the Eclipse Foundation and signing the <a
-			href="../org/documents/Eclipse%20MEMBERSHIP%20AGMT%202003_11_10%20Final.pdf">Eclipse
-				Foundation Membership Agreement</a>.<br /> <br /></li>
-		<li><strong><a name="TRANSITION">How and when will the Eclipse
-					Foundation transition from the CPL to the EPL 1.0?</a><br /> </strong>For
-			details, see the <a href="cpl2epl/CPL2EPLTransitionPlan.pdf">CPL to
-				EPL Transition Plan</a> (.pdf) and the <a
-			href="cpl2epl/cpl2eplfaq.php">CPL to EPL Transition Plan FAQ</a>.<br />
-			<br /></li>
-		<li><strong><a name="EPLOSI">Is the EPL approved by the Open Source
-					Initiative (OSI)?</a><br /></strong> Yes, the EPL has been
-			approved. Version 1.0 was approved in May 2004. See the complete <a
-			href="http://opensource.org/licenses/" target="_blank">list of
-				OSI-approved licenses</a>.<br /> <br /></li>
-		<li><strong><a name="LICAPP">What is required for OSI license
-					approval?</a><br /></strong> A license qualifies for OSI approval
-			if it conforms to the OSI&rsquo;s &quot;Open Source Definition&quot;
-			or &quot;OSD.&quot; The OSD covers nine topics of concern. Chief
-			among these is the requirement that a license not restrict any party
-			from selling or giving away the software. Further, the Program must
-			include source code, must allow distribution in source code as well
-			as compiled form, and must allow modifications and derived works.
-			Find more information on the <a
-			href="http://www.opensource.org/docs/definition.php" target="_blank">OSD</a>
-			at opensource.org.<br /> <br /></li>
-		<li><strong><a name="BUSADVOS">What are the business advantages of the
-					Open Source model?<br /></strong> </a>An Open Source community
-			provides a way for individuals and companies to collaborate on
-			projects that would be difficult to achieve on their own..<br /> <br />
-		</li>
-		<li><strong><a name="TECHADVOS">What are the technical advantages of
-					the Open Source model?</strong></a><br /> The Open Source model has
-			the technical advantage of turning users into potential
-			co-developers. With source code readily available, users will help
-			you debug quickly and promote rapid code enhancements. &quot;Given a
-			bit of encouragement, your users will diagnose problems, suggest
-			fixes, and help improve the code far more quickly than you could
-			unaided.&quot; (The Cathedral and the Bazaar, Eric Steven Raymond.
-			See <a href="http://tuxedo.org/~esr/writings/cathedral-bazaar/"
-			target="_blank">http://tuxedo.org/~esr/writings/cathedral-bazaar/</a>)<br />
-			<br /></li>
-		<li><strong><a name="PARTIESEPL">How are the parties defined in the
-					EPL 1.0?</strong></a><br /> There are two types of parties to the
-			EPL 1.0. They are &quot;Contributors&quot; and
-			&quot;Recipients.&quot; Contributors include an initial Contributor,
-			who is the person or entity that creates the initial code distributed
-			under the EPL 1.0, and subsequent Contributors, who originate changes
-			or additions to the code (the combination referred to as the
-			&quot;Program&quot;). Any person or entity that redistributes the
-			Program is also a Contributor. Recipients include anyone who receives
-			the Program under the EPL, including Contributors.<br /> <br /></li>
-		<li><strong><a name="ANONCONTR">Can a Contributor remain anonymous?</strong></a><br />
-			No. Except for those who simply redistribute the Program, each
-			Contributor must identify itself as the originator of its
-			Contribution in a way that later Recipients will be able to readily
-			see.<br /> <br /></li>
-		<li><strong><a name="RECRIGHTS">What rights do Contributors grant
-					Recipients under EPL?</strong></a><br /> Contributors license
-			Recipients under the rights that they have in their Contributions.<br />
-			<br /></li>
-		<li><strong><a name="USEINANOTHER">Does the EPL allow me to take the
-					Source Code for a Program licensed under it and include all or part
-					of it in another program licensed under the GNU General Public
-					License (GPL), Berkeley Software Distribution (BSD) license or
-					other Open Source license?</strong></a><br /> No. Only the owner of
-			software can decide whether and how to license it to others.
-			Contributors to a Program licensed under the EPL understand that
-			source code for the Program will be made available under the terms of
-			the EPL. Unless you are the owner of the software or have received
-			permission from the owner, you are not authorized to apply the terms
-			of another license to the Program by including it in a program
-			licensed under another Open Source license.<br /> <br /></li>
-		<li><strong><a name="COMPILEWOMOD">Can I take a Program licensed under
-					the EPL, compile it without modification, and commercially license
-					the result?</strong></a><br /> Yes. You may compile a Program
-			licensed under the EPL without modification and commercially license
-			the result in accordance with the terms of the EPL.<br /> <br /></li>
-		<li><strong><a name="SOURCEWOBJ">Do I need to include the source code
-					for such Program with the object code distribution?</strong></a><br />
-			No. But you do need to include a statement that the source code is
-			available from you and information on how to obtain it.<br /> <br />
-			</font></li>
-		<li><strong><a name="PROPPROD">When I incorporate a portion of a
-					Program licensed under the EPL into my own proprietary product
-					distributed in object code form, can I use a single license for the
-					full product, in other words, covering the portion of the Program
-					plus my own code?</strong></a><br /> Yes. The object code for the
-			product may be distributed under a single license as long as it
-			references the EPL portion and complies, for that portion, with the
-			terms of the EPL.<br /> <br /></li>
-		<li><strong><a name="AGREESTEWARD">The EPL states that it can be
-					changed by the Agreement Steward. Does a Contributor have the
-					choice of redistributing a previously distributed Program under the
-					old or the new version of the EPL?</strong></a><br /> While
-			Contributions are licensed under the version of the License under
-			which they are originally distributed, the EPL provides for the
-			ability of any Contributor to choose between that version or a later
-			version.<br /> <br /></li>
-		<li><strong><a name="MODNODIST">If I modify a Program licensed under
-					the EPL, but never distribute it to anyone else, do I have to make
-					my modifications available to others?</strong></a><br /> No. If you
-			do not distribute the modified Program, you do not have to make your
-			modifications available to others.<br /> <br /></li>
-		<li><strong><a name="MODDIST">If I modify a Program licensed under the
-					EPL and distribute the object code of the modified Program for
-					free, must I make the source code available?</strong></a><br />
-			Yes. By distributing the modified Program, even if it is only a free
-			version of the object code, you are obligated to make the source code
-			to the modified Program available to others.<br /> <br /></li>
-		<li><strong><a name="MODULEDIST">If I write a module to add to a
-					Program licensed under the EPL and distribute the object code of
-					the module along with the rest of the Program, must I make the
-					source code to my module available in accordance with the terms of
-					the EPL?</strong></a><br /> No, as long as the module is not a
-			derivative work of the Program.<br /> <br /></li>
-		<li><strong><a name="SRCREDIST">What are my obligations if I copy
-					source code obtained from Eclipse.org and licensed under the
-					Eclipse Public License and include it in my product that I then
-					distribute?</a></strong><br /> Source code licensed under the EPL
-			may only be redistributed under the EPL.<br /> <br /></li>
-		<li><strong><a name="EPLWARRANTY">Does the EPL offer any warranty with
-					regard to the Program?</strong></a><br /> No. The Program released
-			under the EPL is provided on an &quot;as is&quot; basis, without
-			warranties or conditions of any kind.<br /> <br /></li>
-		<li><strong><a name="GETANSWER">This document does not have the answer
-					to my question. How can I get my question answered?</a><br /> </strong>
-			You may want to check the <a href="legalfaq.php">Eclipse Foundation
-				Legal Frequently Asked Questions </a>document to see if your
-			question is answered there. If not, please send a note to the <a
-			href="mailto:license@eclipse.org">Eclipse Management Office</a> and
-			we will do our best to get back to you.<br /> <br /></li>
-		<li><strong><a name="DERIV">Some open source software communities
-					specify what they mean by a &quot;derivative work&quot;. Does the
-					Eclipse Foundation have a position on this?</a><br /></strong> As
-			described in article 1(b)(ii) of the Eclipse Public License,
-			&quot;...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.&quot; The definition of derivative
-			work varies under the copyright laws of different jurisdictions. The
-			Eclipse Public License is governed under U.S. law. Under the U.S.
-			Copyright Act, a &quot;derivative work&quot; is defined as <em>&quot;...a
-				work based upon one or more preexisting works, such as a
-				translation, musical arrangement, dramatization, fictionalization,
-				motion picture version, sound recording, art reproduction,
-				abridgment, condensation, or any other form in which a work may be
-				recast, transformed, or adapted. A work consisting of editorial
-				revisions, annotations, elaborations, or other modifications which,
-				as a whole, represent an original work of authorship, is a
-				&quot;derivative work&quot;.&quot;</em> The Eclipse Foundation
-			interprets the term &quot;derivative work&quot; in a way that is
-			consistent with the definition in the U.S. Copyright Act, as
-			applicable to computer software. You will need to seek the advice of
-			your own legal counsel in deciding whether your program constitutes a
-			derivative work. <br /> <br /></li>
-		<li><strong><a name="LINK">Some free software communities say that
-					linking to their code automatically means that your program is a
-					derivative work. Is this the position of the Eclipse Foundation?</a><br /></strong>
-			No, the Eclipse Foundation interprets the term &quot;derivative
-			work&quot; in a way that is consistent with the definition in the
-			U.S. Copyright Act, as applicable to computer software. Therefore,
-			linking to Eclipse project code might or might not create a derivative work,
-			depending on all of the other facts and circumstances. <br /> <br />
-		</li>
-		<li><strong><a name="EXAMPLE">I&lsquo;m a programmer not a lawyer, can
-					you give me a clear cut example of when something is or is not a
-					derivative work?</a><br /></strong> If you have made a copy of
-			existing Eclipse code and made a few minor revisions to it, that is a
-			derivative work. If you&quot;ve written your own Eclipse Platform
-			Plug-in with 100% your own code to implement functionality not
-			currently in Eclipse, then it is not a derivative work. Scenarios
-			between those two extremes will require you to seek the advice of
-			your own legal counsel in deciding whether your program constitutes a
-			derivative work.<br /> <br /> For clarity, merely interfacing or
-			interoperating with Eclipse Platform Plug-in APIs (without
-			modification) does not make an Eclipse Platform Plug-in a derivative
-			work.<br /> <br /></li>
-		<li><strong><a name="USEEPL">I am starting my own open source software
-					project. Does the Eclipse Foundation allow me to use the EPL for my
-					project?</a><br /></strong> Yes. The EPL is an OSI-approved open
-			source license and may be used unaltered by projects regardless of
-			where they are hosted.<br /> <br /></li>
-		<li><strong><a name="CODEGEN">Many Eclipse tools and wizards use code
-					templates which are included in the application that is generated.
-					Is the code generated by these tools considered a derivative work
-					that must be licensed under the EPL?</a><br /></strong>
-			Unfortunately, there is no clear answer to this question. To the
-			extent that the code generated by a wizard is purely functional in
-			nature and therefore not the proper subject matter for copyright
-			protection, it could be argued that it is not subject to copyright
-			protection, and therefore is not a derivative work. An example of
-			that type of code would include calls to APIs or other technical
-			instructions which are dictated by functional or technical
-			requirements. Moreover, to the extent the generated code is a very
-			small part of the final overall work, there is an argument that such
-			use would be di minimus, and the final product or application should
-			not be considered to be a derivative work. Finally, to the extent
-			developers who use the generated code make many changes and additions
-			to the code, there is also an argument that the resultant application
-			is not a derivative work. Of course, these are just arguments and not
-			"bright line" tests, and therefore each position could be subject to
-			differing viewpoints. The Eclipse Foundation cannot take a position on this issue,
-			as it will ultimately be a question of the facts and circumstances
-			associated with a particular use.<br /> <br /></li>
-		<li><strong><a name="3RDPARTY">What licenses are acceptable for
-					third-party code redistributed by Eclipse projects?</a><br /></strong>
-			The Eclipse Foundation views license compatibility through the lens of enabling
-			successful commercial adoption of Eclipse technology in software
-			products and services. We wish to create a commercial ecosystem based
-			on the redistribution of Eclipse software technologies in
-			commercially licensed software products. Determining whether a
-			license for third-party code is acceptable often requires the input
-			and advice of The Eclipse Foundation&rsquo;s legal advisors.<br /> <br />Please see
-			our <a href="http://www.eclipse.org/legal/licenses.php">list of the
-				most common licenses</a> approved for use by third-party code
-			redistributed by Eclipse Foundation Projects. This list is not
-			exhaustive. If you have any questions, please contact <a
-			href="mailto:license@eclipse.org">license@eclipse.org</a>.<br /> <br /></li>
-
-		<li><strong><a name="OSICOMPLIANT">Is an OSI-compliant license a
-					requirement for all third-party code redistributed by Eclipse
-					projects?</a><br /></strong> The Eclipse Foundation fully supports the Open Source
-			Initiative&rsquo;s certification of open source licenses, and the
-			Eclipse Public License is certified as such. However, there are
-			licenses for software content which meet The Eclipse Foundation&rsquo;s requirements
-			for compatibility with the EPL and downstream commercial
-			re-distribution that are not OSI certified, and Eclipse projects may
-			make use of such licenses after review and approval by the Eclipse
-			Foundation.<br /> <br /> The reverse is also true: there are
-			OSI-compliant licenses are not compatible with the EPL or do not
-			permit downstream commercial re-distribution. Such licenses are not
-			used by Eclipse projects.<br /> <br /></li>
-		<li><strong><a name="GPLCOMPATIBLE">Are the Eclipse Public License
-					(EPL) 1.0 and the General Public License (GPL) compatible?</a><br /></strong>
-			The EPL 1.0 and the GPL are not compatible in any combination where
-			the result would be considered either: (a) a &quot;derivative
-			work&quot; (which The Eclipse Foundation interprets consistent with the definition
-			of that term in the U.S. Copyright Act ) or (b) a work &quot;based
-			on&quot; the GPL code, as that phrase is used in the <a
-			href="http://www.gnu.org/licenses/old-licenses/gpl-2.0.html">GPLv2</a>,
-			<a href="http://www.fsf.org/licensing/licenses/gpl.html">GPLv3</a> or
-			the <a href="http://www.fsf.org/licensing/licenses/gpl-faq.html">GPL
-				FAQ</a> as applicable. Further, you may not combine EPL 1.0 and GPL
-			code in any scenario where source code under those licenses are both
-			the same source code module.<br /> <br /> Based upon the <a
-			href="http://www.fsf.org/licensing/licenses/">position</a> of the
-			Free Software Foundation, you may not combine EPL 1.0 and GPL code in
-			any scenario where linking exists between code made available under
-			those licenses. The above applies to both GPL version 2 and GPL
-			version 3.<br /> <br /></li>
-		<li><strong><a name="DUALLIC">For Eclipse projects which are
-					dual-licensed, your file headers state that the code is being made
-					available under two licenses. For example: "This program and the
-					accompanying materials are made available under the terms of the
-					Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
-					which accompanies this distribution." What is meant by the use of
-					the conjunction "and"?</a><br /></strong> The code is being made
-			available under both of the licenses. The consumer of the code can
-			select which license terms they wish to use, modify and/or further
-			distribute the code under.</li>
-	</ol>
-</div>
-<!-- remove the entire <div> tag to omit the right column!  -->
-<div id="rightcolumn">
-	<div class="sideitem">
-		<h6>Related Links</h6>
-		<ul>
-			<li><a href="legalfaq.php">Eclipse Legal FAQ</a></li>
-			<li><a href="epl/notice.php">Eclipse Software User Agreement</a></li>
-		</ul>
-	</div>
-</div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/guidetolegaldoc-EPL-1.0.php b/guidetolegaldoc-EPL-1.0.php
index 627cf46..9a3d781 100644
--- a/guidetolegaldoc-EPL-1.0.php
+++ b/guidetolegaldoc-EPL-1.0.php
@@ -1,534 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Guide to the Legal Documentation for Eclipse Plug-ins and Features under the EPL-1.0";
-	$pageKeywords	= "legal, guide, summary";
-	$pageAuthor		= "Mike Milinkovich";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+$App = new App();
+$Theme = $App->getThemeClass();
+include ($App->getProjectCommon());
 
-<style>
-.checklist {
-    border: 1px solid #ccc;
-    list-style: none;
-}
+$pageTitle = "Guide to the Legal Documentation for Eclipse Plug-ins and Features under the EPL-1.0";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, guide, summary");
+$Theme->setPageAuthor("Mike Milinkovich");
 
-.checklist, .checklist li { margin: 0; padding: 0; }
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-.checklist label {
-    display: block;
-    padding-left: 25px;
-    text-indent: -25px;
-}
-.postit {
-border: 1px dashed black;
-margin: 10px 0 10px 0;
-}
-.postitinner {
-margin: 0 5px 5px 5px;
-}
-</style>
-
-<form action="#" method="GET">
-
-	<div id="midcolumn">
-	<h1>$pageTitle</h1>
-    	<p>Last updated: March 31, 2008</p>
-		<h2><a name="Who"></a>1.0 Who should read this document</h2>
-		<p><strong>Committers or Contributors to <a href="/" target="_blank">Eclipse.org</a> 
-        	projects</strong></p>
-      	<blockquote> 
-        	<p>Reading this document will help you understand the legal documentation 
-          	requirements of your project. While committers are ultimately responsible 
-          	for ensuring that content in the Eclipse.org projects contains the appropriate 
-          	legal documentation, it is always appreciated when contributors can 
-          	deliver content that requires minimal work to be integrated into the 
-          	codebase.</p>
-      	</blockquote>
-      	<p><strong>Redistributors of Eclipse.org content</strong></p>
-      	<blockquote> 
-        	<p>Reading this document will help you choose whether you need to modify, 
-          	remove, or add to any of the Eclipse.org legal documentation. You may 
-          	be redistributing Eclipse.org content as part of your product.</p>
-      	</blockquote>
-      	<p><strong>Developers of Eclipse-based content or products</strong></p>
-      	<blockquote> 
-        	<p>Even if you are not necessarily redistributing Eclipse.org content 
-          	itself, reading this document will help you to determine whether or 
-          	not you wish to adopt some or all of the described framework, for documenting 
-         	your own content.</p>
-      	</blockquote>
-      	<p> <strong>Users of Eclipse-based content or products</strong></p>
-      	<blockquote>
-        	<p>Reading this document will help you to locate the various legal notices 
-          	and agreements that govern your use of the content.</p>
-      	</blockquote>
-      	
-		<h2><a name="What"></a>2.0 What will this document explain?</h2>
-      	<p> In this document you will be introduced to the basic Eclipse.org legal 
-        documentation styles; Agreements, Abouts, Licenses and Notices. For each 
-        of these styles, we have provided a brief overview, some background information 
-        and instructions pertaining to where you can find them as well as where 
-        you should place them. After describing the framework used for legal documentation 
-        in Eclipse-based content, this document will explain how you should redistribute 
-        Eclipse.org content and will offer suggestions as to how you may wish 
-        to deal with the delivery of legal documentation when including non-Eclipse.org 
-        content in your product.</p>
-		
-	<h2><a name="Why"></a>3.0 Why so many notices?</h2>
-      <p>Most software products are delivered with a single license file. This 
-        file is usually found in the root directory of the installation or in 
-        some obviously-named directory such as &quot;license&quot; or &quot;legal.&quot; 
-        This straightforward mechanism is used even if there are differently licensed 
-        components in the product. In those cases, the single license file may 
-        actually contain multiple licenses or notices and it is usually clear 
-        which parts of the product each license or notice applies to.</p>
-      <p>Eclipse-based content is highly modularized to facilitate ease of delivery, 
-        extensibility, and upgradeability. Important modular concepts in the Eclipse 
-        space include <i>plug-ins</i>, <i>plug-in fragments</i> (herein called 
-        &quot;fragments&quot;), and <i>features</i>. A typical Eclipse installation 
-        may potentially include plug-ins and features authored and/or distributed 
-        by many different parties including the Eclipse Foundation, other open-source 
-        organizations, and commercial vendors.</p>
-      <p>The content that is developed and maintained at Eclipse.org is a very 
-        large codebase that is continuously evolving and may be accessed in a 
-        multitude of ways. </p>
-      <p>For example:</p>
-      <blockquote>
-      <ul>
-        <li>Some parts of the content are constantly changing with updates being 
-          committed on an almost continuous basis. With committers on a single 
-          project spread across many time zones development may be occurring 24x7.</li>
-        <li>Most of the content is licensed under the <a href="../org/documents/epl-v10.php">Eclipse 
-          Public License Version 1.0 (&quot;EPL&quot;)</a>, although
-          at the discretion of the Board of Directors a project may be dual-licensed, 
-          or even be maintained under another license altogether. However, the codebase 
-          also contains redistributions of many packages maintained at sites other 
-          than Eclipse.org, or content based on such packages. For example, there 
-          may be redistributions of packages from the <a href="http://www.apache.org" target="_blank">Apache 
-          Software Foundation</a> such as Ant and Tomcat, or code based on parts 
-          of such packages. These packages may be offered under licenses other 
-          than the EPL.</li>
-        <li>The content at Eclipse.org may be accessed and downloaded in many 
-          ways. Most projects create builds on a regular basis. Some projects 
-          create many builds for different platforms and configurations on a daily 
-          basis. Because these builds are created straight from the Eclipse.org 
-          source code repositories, recently committed updates are found in the builds. 
-          It is also possible to access content directly from the source code repositories 
-          or to download new or updated features using the Eclipse Update Manager.</li>
-      </ul>
-      </blockquote>
-      <p>All of these content characteristics call for a modular approach to legal 
-        documentation. Consequently, any distribution of content originating from 
-        Eclipse.org should contain notices as described in the following sections.</p>
-        
-      <h2><a name="LegalDoc"></a>4.0 Eclipse.org legal documentation</h2>
-      
-      <h3>4.1 Software User Agreement</h3>
-      <p><strong>The Basics:</strong></p>
-      <p>The top-level umbrella agreement is the <a href="epl/notice.php" target="_blank">Eclipse 
-        Foundation Software User Agreement</a>. The Software User Agreement, to 
-        be called &quot;SUA&quot; herein, is not actually a license - it does 
-        not grant any rights to use the software and that is why it must reference 
-        other legal notices and agreements. The main purpose of the SUA is to 
-        describe the potential layout of the legal documentation in the accompanying 
-        content.</p>
-      <p><strong>The Details:</strong></p>
-      <p>The most important wording is that which says that the EPL applies to all the 
-        content unless otherwise indicated. Note that although the EPL is used by all 
-        projects at the Eclipse Foundation, at the discretion of the Board of Directors a 
-        project may be dual-licensed, or even be maintained under another license altogether.</p>
-      <p>The rest of the text describes the 
-        other kinds of notices or licenses that may be found in the content. There 
-        is also a short paragraph under the heading &quot;Cryptography&quot; which 
-        lets you know that the content may contain cryptography.</p>
-      <p> You will also often see on many of the download pages at Eclipse.org, 
-        text that says:</p>
-      <blockquote>
-        <p>All downloads are provided under the terms and conditions of the <a href="epl/notice.php" target="_blank">Eclipse 
-          Foundation Software User Agreement</a> unless otherwise specified.</p>
-      </blockquote>
-      <p><strong>The Location:</strong></p>
-
-      <p>The SUA usually appears in the root directory of Eclipse builds as the 
-        file named &quot;notice.html&quot;. A copy of the 
-        Project's primary license(s) must appear in the same location as the SUA.  
-        In most cases this will be the Eclipse Public License alone.</p>
-      <p><strong>Note:</strong> The appropriate SUA and a copy of any referenced 
-        license <strong>must</strong> be located in the root directory of any 
-        Eclipse.org distributed build (typically distributed as a ZIP file). Any 
-        web page that makes builds available <strong>must </strong>have a link 
-        to the appropriate SUA with appropriate wording.</p>
-        
-      <p><em>The SUA Checklist</em></p>
-      <ul class="checklist">
-    	<li><label for="o31"><input id="o31" name="o31" type="checkbox" />Every build distribution has the standard SUA in the root as &quot;notice.html&quot;</label></li>
-    	<li><label for="o32"><input id="o32" name="o32" type="checkbox" />Every build distribution 
-    	has a copy of the primary license(s) in the root, e.g., &quot;epl-v10.html&quot;</label></li>
-      </ul>
-        
-        
-      <h3><a name="Abouts"></a>4.2 Abouts</h3>
-	  <p><strong>The Basics:</strong> </p>
-      <p>Any directory containing content that is licensed under different terms 
-        than the license(s) referred to by the SUA, should be detailed in a file 
-        named &quot;about.html.&quot; We 
-        call these files &quot;Abouts.&quot; Abouts usually contain licensing 
-        terms as well as other information such as whether content contains cryptographic 
-        functionality that may be subject to export controls.</p>
-      <p><strong>The Details:</strong> </p>
-      <p>Most plug-ins will contain a default About that simply confirms that 
-        all the content in that plug-in is made available under the EPL. 
-        There are other plug-ins, however, that will contain content licensed under licenses 
-        other than or in addition to the EPL and/or third party content provided under other licenses.  
-        If you are the maintainer of a plug-in for an Eclipse.org project, please see the 
-		<a href="epl/about.php" target="_blank"> 
-        About templates for plugins</a>.</p> 
-      <p>Since most plug-ins do NOT contain specially-licensed content, most plug-ins 
-        will contain only the default About. The plug-ins with the special Abouts 
-        are the &quot;interesting&quot; ones that most users will want to read.</p>
-      <p><strong>Note:</strong> All plug-ins and fragments should contain an 
-        About. All Eclipse.org plug-ins and fragments must contain either one 
-        of the default Abouts or a special About written and/or approved by the 
-        Eclipse Foundation. In JAR&rsquo;ed plug-ins, any local files linked from the 
-        About such as copies of licenses, must be located in a directory called 
-        &quot;about_files.&quot;</p>
-      <p><strong>The Location:</strong></p>
-      <p>Although Abouts may be found potentially in any directory, they should 
-        always be found in plug-ins and fragments. Previously, plug-ins and fragments 
-        were usually packaged as sub-directories of a directory named &quot;plugins.&quot; 
-        Currently, plug-ins and fragments may also be packaged as JARs (Java&trade; 
-        ARchives). For JAR&rsquo;ed plug-ins, any local files linked from an About such 
-        as copies of licenses, must be located in a directory called &quot;about_files.&quot; 
-        The contents of the &quot;about_files&quot; directory are handled specially 
-        so that links resolve correctly when the About in a JAR&rsquo;ed plug-in is 
-        viewed in an external browser spawned from the About dialog.</p>
-      <p>As an example:</p>
-      <blockquote> 
-        <table cellspacing="4">
-          <tr> 
-            <td><i>eclipse</i></td>
-            <td>(installation root directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>notice.html</i></td>
-            <td>Software User Agreement</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>epl-v10.html</i></td>
-            <td>the project&rsquo;s primary licenses(s) (typically the EPL alone) referenced by the SUA</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
-            <td>(plug-ins and fragments directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.apache.ant_1.6.2</i></td>
-            <td>(plug-in packaged as a directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
-            <td>About</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
-            <td>Apache Software License referenced by About</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>LICENSE.dom.html</i></td>
-            <td>W3C License referenced by About</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.core.runtime_3.1.0.jar</i></td>
-            <td>(plug-in packaged as a JAR)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
-            <td>About</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about_files</i></td>
-            <td>(directory for any local files linked from About)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
-            <td>Apache Software License referenced by About</td>
-          </tr>
-        </table>
-      </blockquote>
-      <p>Users looking for legal documentation may find the Abouts by browsing 
-        the directory structure of an Eclipse installation but the files are also 
-        viewable from the &quot;About plug-ins&quot; dialog in the Eclipse workbench. 
-        To view the Abouts, go to the menu item <strong>Help -> About Eclipse 
-        Platform</strong> and then click on the button &quot;Plug-in Details&quot; 
-        and then select a plug-in and click on the button &quot;More Info.&quot;</p>
-        
-      <p><em>The Abouts Checklist</em></p>        
-      <ul class="checklist">
-    	<li><label for="o51"><input id="o51" name="o51" type="checkbox" />Every plug-in has an &quot;about.html&quot;, usually the standard one.</label></li>
-    	<li><label for="o53"><input id="o53" name="o53" type="checkbox" />Every plug-in with a non-standard &quot;about.html&quot; contains the additional referenced license files.</label></li>
-    	<li><label for="o52"><input id="o52" name="o52" type="checkbox" />Every JAR&rsquo;ed plug-in stores linked files in &quot;about_files&quot;</label></li>
-      </ul>
-      <br/>
-        
-      <img src="guidetolegaldoc_files/About_plugins_dialog.jpg" width="598" height="447">
-      <p>&nbsp;</p>
-      <h3>4.3 Features Licenses and Feature Update Licenses</h3>
-      <p><strong>The Basics:</strong> </p>
-      <p>A feature is a set of one or more related plug-ins and/or fragments that 
-        can be installed and upgraded together. There are three important legal 
-        documentation files for features, the Feature License (license.html), 
-        the Feature Update License (feature.properties &gt; license) and the Feature 
-        Blurb (about.properties &gt; blurb). </p>
-      <p><strong>The Details:</strong> </p>
-      <p><em>The Feature License</em></p>
-      <p>Each feature has a file named &quot;license.html.&quot; We call this 
-        a &quot;Feature License.&quot; In Eclipse.org builds, this file is an 
-        exact copy of the file &quot;notice.html&quot; that is found in the root 
-        directory of the distribution. In other words, it is the SUA.</p>
-      <p><em>The Feature Update License</em></p>
-      <p>Each feature has a file named &quot;feature.properties.&quot; In that 
-        file is a property named &quot;license&quot. This is known as the &quot;Feature 
-        Update License.&quot; For Eclipse.org builds, the Feature Update License 
-        is an exact copy of the SUA in PLAIN TEXT format. 
-        Feature Update Licenses must be delivered in that format whereas all the 
-        other files we&rsquo;ve covered so far have been HTML files.</p>
-      <p><em>The Feature Blurb</em></p>
-      <p>Each feature has at least one plug-in associated with it which is the 
-        &quot;feature plug-in&quot; for that feature. Not surprisingly, this plug-in 
-        usually has the same name as the feature. The property named &quot;blurb&quot; 
-        contains text that appears in the &quot;About features&quot; dialog in 
-        the Eclipse workbench. This is known as a &quot;Feature Blurb.&quot; Blurbs 
-        often contain copyright notices and any other statements of attribution 
-        that may be required by licenses.</p>
-      <p><em>What&rsquo;s the difference?</em></p>
-      <p>The difference between the Feature License and Feature Update License 
-        is when they are shown to the user. The Feature License is only available 
-        once a feature has been installed. The Feature Update License is seen 
-        when a user is using the Eclipse Update Manager to install or upgrade 
-        a feature and must agree to an agreement before proceeding with the installation. 
-        One thing that is important to note is that with the distributed licensing 
-        model used by plug-ins, unless a Feature Update License contains an aggregation 
-        of all the notices from the plug-ins for a feature, a user will not be 
-        able to see these notices before installing the feature. It is for this 
-        reason that the maintainer of a feature may choose to have different text 
-        for the Feature License and Feature Update License.</p>
-      <p><strong>Note: </strong>All features must contain a Feature License and 
-        a Feature Update License in the directory for that feature. The feature&rsquo;s 
-        plug-in must contain a Feature Blurb.</p>
-      <p><strong>The Location:</strong></p>
-      <p><em>The Feature License</em></p>
-      <p> The Feature License is found in the feature directory which is usually 
-        a sub-directory of the directory named &quot;features.&quot; Any referenced 
-        files (for example, the EPL or the SUA) are located in 
-        the same location.</p>
-      <p><em>The Feature Update License</em></p>
-      <p>The Feature Update License is found in the feature directory which is 
-        usually a sub-directory of the directory named &quot;features.&quot; Any 
-        referenced files (for example, the EPL or the SUA) are 
-        located in the same location. </p>
-      <p><em>The Feature Blurb</em></p>
-      <p>The Feature Blurb resides in the &quot;plugins&quot; directory as either 
-        a sub-directory or a JAR. In the feature plug-in there is a file named 
-        &quot;about.properties.&quot;, the Feature Blurb is the property named 
-        &quot;blurb&quot;. To view the blurb for each installed feature, go to 
-        the menu item <strong>Help > About Eclipse Platform</strong> and then 
-        click &quot;Feature Details&quot; and then select a feature. The blurb 
-        will appear in the bottom half of the dialog. </p>
-      <p><em>The Feature Checklist</em></p>
-      <ul class="checklist">
-    	<li><label for="o41"><input id="o41" name="o41" type="checkbox" />Every feature has the standard SUA in <u>HTML</u> in &quot;license.html&quot;</label></li>
-    	<li><label for="o42"><input id="o42" name="o42" type="checkbox" />Every feature has the 
-    	Project&rsquo;s primary license(s) (e.g., typically the EPL in &quot;epl-v10.html&quot;)</label></li>
-    	<li><label for="o43"><input id="o43" name="o43" type="checkbox" />Every feature has the standard SUA in <u>plain text</u> in &quot;feature.xml &lt;license&gt;&quot; or &quot;feature.properties / license&quot;</label></li>
-    	<li><label for="o44"><input id="o44" name="o44" type="checkbox" />Every feature plug-in has copyright notices, etc. in the &quot;blurb&quot; property of &quot;about.properties&quot;</label></li>
-   	  </ul>
-   	  <br/>
-        
-      <img src="guidetolegaldoc_files/About_features_dialog.jpg" width="598" height="536">
-      <p>An example directory structure corresponding to the above description:</p>
-      <blockquote> 
-        <table cellspacing="4">
-          <tr> 
-            <td><i>eclipse</i></td>
-            <td>(installation root directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>features</i></td>
-            <td>(features directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
-            <td>(feature directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>license.html</i></td>
-            <td>(Feature License)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>epl-v10.html</i></td>
-            <td>the project&rsquo;s primary licenses(s) (typically the EPL alone) referenced by the SUA/Feature License)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>feature.properties</i></td>
-            <td>(Feature Update License in &quot;license&quot; property)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
-            <td>(plug-ins and fragments directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
-            <td>(plug-in packaged as a directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.properties</i></td>
-            <td>(Feature Blurb in &quot;blurb&quot; property)</td>
-          </tr>
-        </table>
-      </blockquote>
-      <p>&nbsp;</p>
-      
-      <h3>4.4 Notices in source code</h3>
-      <p><strong>The Basics:</strong> </p>
-      <p>Where practical, all source code (which includes Java source as well 
-        other types of files such as XML, HTML, etc.) should contain appropriate 
-        copyright and license notices as well information on each contribution.</p>
-      <p><strong>The Details:</strong> </p>
-      <p>The standard format for these notices can be found at www.eclipse.org 
-        &gt; Legal Stuff &gt; <a href="copyrightandlicensenotice.php" target="_blank"> 
-        Default Copyright and License Notice</a>.</p>
-      <p>If the source is to be licensed under a license other than 
-        or in addition to the EPL, you must ensure that the Eclipse 
-        Foundation has approved the notice.</p>
-      <p><strong>The Location:</strong></p>
-      <p>In the source code.</p>
-      <h3>4.5 Notices in documentation</h3>
-      <p><strong>The Basics:</strong> </p>
-      <p>The Legal page has a copyright notice and a link to the About in the 
-        plug-in that contains the book. </p>
-      <p>An example is shown below:</p>
-      <img src="guidetolegaldoc_files/Help_legal_page.jpg" width="598" height="260">
-      <p>&nbsp;</p>
-	  <strong>The Location:</strong>
-      <p>Documentation books usually contain a &quot;Legal&quot; page as the last 
-        page in the book. </p>
-      <h2><a name="Redistribution"></a>5.0 Redistribution of Eclipse.org content</h2>
-      <p>There are a number of considerations when redistributing an Eclipse.org 
-        build in or with your own products. Such redistribution also covers redistribution 
-        of a subset of an Eclipse.org build such as one or more plug-ins or features 
-        from the build. Specifically:</p>
-      <ol>
-        <li>All of the legal documentation is written on behalf of the Eclipse 
-          Foundation as if it were the distributor of the content. If you redistribute 
-          the content then it is no longer true that Eclipse Foundation is providing 
-          the content.  In this case, the content originated with the 
-          Eclipse Foundation and you are redistributing it.</li>
-        <li>If you are redistributing the object code under your own license as 
-          the EPL, and other licenses used by the Eclipse.org projects allow 
-          you to do (there may be exceptions), then the existing Eclipse.org legal 
-          documentation can be very misleading to readers since it states that 
-          use of the object code is governed by various open source licenses.</li>
-        <li>Although the distributed model of the SUA, Abouts, Feature License, 
-          and Feature Update Licenses is necessary for the dynamic model of content 
-          distribution from Eclipse.org, it may not suit your situation. The downside 
-          of this model is that users have to locate and read many files to find 
-          all the terms and conditions. In most cases, redistributors want to 
-          present a single license although you may want to consider how you will
-		  updates provided through the Eclipse Update Manager for example.</li>
-		<li>Changing any of the existing legal documentation 
-	      requires a change in the version number of any affected component. Soon, 
-          the Eclipse Foundation will begin to digitally sign JAR&rsquo;ed plug-ins and 
-          features and we will likely see developers of Eclipse-based content do 
-          the same thing. Thus it&rsquo;s pretty clear that altering or removing any of 
-          the legal documentation is not really an option. Instead it is better 
-          to put appropriate wording in your license explaining that the content 
-          was originally obtained from the Eclipse Foundation under open source 
-          licenses including the EPL, and that you are redistributing it 
-          and potentially relicensing it. Such an explanation will provide the opportunity 
-          and context for the flowdowns in 3 b) of the EPL.</li>
-      </ol>
-      <p>If you wish to cover the entire redistribution with a single license 
-        then you will likely want to locate the necessary licenses for the &quot;special&quot; 
-        Abouts and fulfill the obligations of those licenses such as flowing down 
-        disclaimers, etc.</p>
-        
-      <h2><a name="3rdParty"></a>6.0 Legal documentation in non-Eclipse.org content</h2>
-      <p>If you are delivering your own Eclipse-based content then it will likely 
-        be packaged as plug-ins and features. In these cases it is desirable to 
-        follow the framework described above so that users can view Abouts, Feature 
-        Licenses, and Feature Update Licenses. You will likely want a single license 
-        to cover the entire package of your own content plus the redistributed 
-        Eclipse.org code. You may therefore wish to point out which plug-ins and/or 
-        features are being redistributed from the Eclipse Foundation and which 
-        are originating from you. You may wish to have the Abouts, Feature Licenses, 
-        and Feature Update Licenses in your own plug-ins and features, simply 
-        point the user back to the single license in the root directory of the 
-        installation rather than duplicating the text everywhere. Of course if 
-        you deliver additional or updated features packaged on an update site 
-        for download and installation with the Eclipse Update Manager (in which 
-        case you should read the <a href="updatemanager.php" target="_blank">Eclipse 
-        Foundation Update Manager Agreement</a> found on the Legal Stuff page 
-        at eclipse.org) you will probably want to make the user aware of any additional 
-        terms and conditions by adding them to the relevant documents.</p>
-        
-      <h2><a name="Summary"></a>7.0 Summary</h2>
-      <p>There are many legal documentation issues to consider when redistributing 
-        Eclipse.org content and delivering Eclipse-based content. It is important 
-        that you fully understand what you are redistributing and delivering, 
-        and how it will be delivered and thus how your users will encounter (and 
-        where necessary agree to) legal documentation, so that you can ensure 
-        your conformity with, and their acceptance of, the requirements set forth 
-        in the applicable license agreements.</p>
-      <p>If you have any questions or concerns, please <a href="mailto:license@eclipse.org">contact</a>
-        the staff of the Eclipse Foundation.</p>
-      <small>Java and all Java-based trademarks are trademarks of Sun Microsystems, 
-      Inc. in the United States, other countries, or both.</small> 
-	</div>
-	<!-- remove the entire <div> tag to omit the right column!  -->
-	<!-- remove the entire <div> tag to omit the right column!  -->
-	<div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Quick Links</h6>
-			<ul>
-				<li><a href="#Who">Who Should Read This?</a></li>
-				<li><a href="#What">What Will This Explain?</a></li>
-				<li><a href="#Why">Why So Many Notices?</a></li>
-				<li><a href="#LegalDoc">The Legal Documents</a></li>
-				<li><a href="#Redistribution">Redistribution</a></li>
-				<li><a href="#3rdParty">Documenting Your Products</a></li>
-				<li><a href="#Summary">Summary</a></li>
-			</ul>
-		</div>
-	</div>
-
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/guidetolegaldoc.php b/guidetolegaldoc.php
index 0fb0b4e..b6ad6ab 100644
--- a/guidetolegaldoc.php
+++ b/guidetolegaldoc.php
@@ -1,9 +1,16 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2017 Eclipse Foundation and others.
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 header('Location: /projects/handbook#legaldoc');
diff --git a/guidetolegaldoc2.php b/guidetolegaldoc2.php
index 73424e5..89232f5 100644
--- a/guidetolegaldoc2.php
+++ b/guidetolegaldoc2.php
@@ -1,323 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-$pageTitle 		= "A Guide to the Legal Documentation for Eclipse-Based Content";
-$html = <<<EOHTML
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-<style>
-.checklist {
-    border: 1px solid #ccc;
-    list-style: none;
-}
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-.checklist, .checklist li { margin: 0; padding: 0; }
+$App = new App();
+$Theme = $App->getThemeClass();
 
-.checklist label {
-    display: block;
-    padding-left: 25px;
-    text-indent: -25px;
-}
-.postit {
-border: 1px dashed black;
-margin: 10px 0 10px 0;
-}
-.postitinner {
-margin: 0 5px 5px 5px;
-}
-</style>
-<form action="#" method="GET">
+include ($App->getProjectCommon());
 
-<div id="midcolumn">
-<h1>$pageTitle</h1>
-   	<p>Last updated: September 25, 2007</p>
-	<p>
-	This document is intended to assist the Eclipse committers in fulfilling their 
-	obligations to implement the <a href="/org/documents/Eclipse_IP_Policy.pdf">Eclipse IP Policy</a>. 
-	In addition to their role as 
-	the leading developers on Eclipse projects, Committers are also charged with 
-	the responsibility of ensuring that the software distributed by the Eclipse 
-	Foundation meets the expectations of the community with respect to 
-	intellectual property. This document provides 
-	a set of specific checklists for developers on Eclipse Projects to follow regarding 
-	the legal documentation required in all source files, builds, and releases. 
-	While these checklists should cover most projects, there will obviously be cases 
-	where additional advice is needed: if so, please contact <a href="mailto:emo@eclipse.org">the
-	Eclipse Management Organization</a>.
-	
-<h2>1. Source Code</h2>
-	<p>
-	Every source file must have a Copyright and License Notice.
-	   The standard format for these notices can be found in <a href="copyrightandlicensenotice.php" target="_blank"> 
-        Default Copyright and License Notice</a>. If the source is to be licensed 
-        under a license other than the EPL alone, you must ensure that the Eclipse 
-        Foundation has approved the notice.</p>
-    <p>
-    Source files must have the Copyright and License Notice <em><b>before</b></em>
-    the files are checked into the eclipse.org source repository.
-    </p>
+$pageTitle = "A Guide to the Legal Documentation for Eclipse-Based Content";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("");
+$Theme->setPageAuthor("");
 
-    <ul class="checklist">
-    <li><label for="o1"><input id="o1" name="o1" type="checkbox" />Every source file has a Copyright and License Notice</label></li>
-    </ul>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-<h2>2. Documentation</h2>
-	<p>
-	The help documentation must have a Legal page with a copyright notice
-	and a link to the <a href="#about_files">About file</a> in the plug-in that contains the help documentation. 
-	For example:</p>
-      <img src="guidetolegaldoc_files/Help_legal_page.jpg" width="598" height="260">
-    <p>Documentation books usually contain a &quot;Legal&quot; page as the last 
-        page in the book. </p>
-
-    <ul class="checklist">
-    <li><label for="o2"><input id="o2" name="o2" type="checkbox" />Every help documentation set contains a Legal page</label></li>
-    </ul>
-
-<h2><a name="3_Builds"></a>3. Builds</h2>
-	<p>
-	Every build distribution, such as a zip or tar file, must contain a 
-	<a href="epl/notice.html" target="_blank">Eclipse Foundation Software User Agreement</a>
-	(known as the &quot;SUA&quot;) in the root directory of the distribution
-	in HTML format in a file named &quot;notice.html&quot;.</p>
-    <p>
-    A copy of the Project's primary license(s) must be in the root directory
-    of the distribution in HTML format. In most cases, this will be the
-    <a href="epl-v10.html">Eclipse Public License</a> alone in a file named 
-    &quot;epl-v10.html&quot; In exceptional circumstances, the Board may approve
-    the licensing of a project under license terms other than the EPL alone.
-
-    <ul class="checklist">
-    <li><label for="o31"><input id="o31" name="o31" type="checkbox" />Every build distribution has the standard SUA in the root as &quot;notice.html&quot;</label></li>
-    <li><label for="o32"><input id="o32" name="o32" type="checkbox" />Every build distribution 
-    has a copy of the primary license(s) in the root, e.g., &quot;epl-v10.html&quot;</label></li>
-    </ul>
-	<div class="postit"><div class="postitinner"><a name="SUA"></a><h3>What is the Software User Agreement?</h3>
-	The Software User Agreement is the agreement that governs the use of all 
-	software distributed by the Eclipse Foundation. The SUA references the 
-	Eclipse Public License as the primary vehicle to grant license rights and 
-	obligations to use the software. In addition, it also references other legal 
-	notices and agreements and describes the potential layout of the legal 
-	documentation in the accompanying Content.
-    <p>
-    The reason for the SUA is that Eclipse-based content is highly modularized
-    to facilitate ease of delivery, extensibility, and upgradeability. 
-    A typical Eclipse installation may potentially include plug-ins and features authored 
-    and/or distributed by many different parties including the Eclipse Foundation, other 
-    open-source organizations, and commercial vendors. 
-    <p>
-    This modularity makes an Eclipse distribution
-    somewhat different from a classical software product delivered with a single license file.
-    The Eclipse Foundation SUA guides the consumer to the various licenses distributed 
-    through out the Eclipse Project distribution.
-    </div></div>
-
-<h2>4. Features</h2>
-	<p>
-	A feature is a set of one or more related plug-ins and/or fragments that 
-    can be installed and upgraded together. Every feature must have at least three
-    (usually at least four) legal files:
-    <p>For example:</p>
-      <blockquote> 
-        <table cellspacing="4">
-          <tr> 
-            <td><i>eclipse</i></td>
-            <td>(installation root directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>features</i></td>
-            <td>(features directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
-            <td>(feature directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>license.html</i></td>
-            <td><b>(#1 Feature License)</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>epl-v10.html</i></td>
-            <td><b>(#2 Project's Primary License(s) (typically EPL alone) referenced by Feature License)</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>feature.properties</i></td>
-            <td><b>(#3 Feature Update License in &quot;license&quot; property)</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
-            <td>(plug-ins and fragments directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.sdk_3.0.1</i></td>
-            <td>(plug-in packaged as a directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.properties</i></td>
-            <td><b>(#4 Feature Blurb in &quot;blurb&quot; property)</b></td>
-          </tr>
-        </table>
-      </blockquote>
-	The first required file is &quot;license.html&quot;. This file is required to be the
-	<a href="epl/notice.html" target="_blank">Eclipse Foundation SUA</a> in HTML format (and thus
-	an exact duplicate of the &quot;notice.html&quot; in <a href="#3_Builds">the root of the distribution</a>).
-	This file is referred to as <em>The Feature License</em>.
-	<p>
-	The second required file is the <a href="epl-v10.html">Eclipse Public License</a> in HTML format in a file named 
-    &quot;epl-v10.html&quot; (and thus also an exact duplicate of the &quot;epl-v10.html&quot; 
-    in <a href="#3_Builds">the root of the distribution</a>).
-    <p>
-    Each feature has a file named &quot;feature.xml&quot; with a <code>license</code> node.
-    Often the strings in the &quot;feature.xml&quot; file are externalized in a &quot;feature.properties&quot;
-    file. Either way, the <code>license</code> node or property must contain the 
-    <a href="epl/notice.txt" target="_blank">Eclipse Foundation SUA</a> in PLAIN TEXT format.
-    This text (node or property) is referred to as <em>The Feature Update License</em>.
-    <p>
-    Each feature has at least one plug-in associated with it which is the 
-	&quot;feature plug-in&quot; for that feature. Not surprisingly, this plug-in 
-	usually has the same name as the feature. The &quot;about.properties&quot; 
-	property named &quot;blurb&quot; 
-	contains text that appears in the &quot;About features&quot; dialog in 
-	the Eclipse workbench. This is known as a &quot;Feature Blurb.&quot; Blurbs 
-	often contain copyright notices and any other statements of attribution 
-	that may be required by licenses.
-
-	<ul class="checklist">
-    <li><label for="o41"><input id="o41" name="o41" type="checkbox" />Every feature has the standard SUA in <u>HTML</u> in &quot;license.html&quot;</label></li>
-    <li><label for="o42"><input id="o42" name="o42" type="checkbox" />Every feature has the 
-    Project's primary license(s) (e.g., the EPL in &quot;epl-v10.html&quot;)</label></li>
-    <li><label for="o43"><input id="o43" name="o43" type="checkbox" />Every feature has the standard SUA in <u>plain text</u> in &quot;feature.xml &lt;license&gt;&quot; or &quot;feature.properties / license&quot;</label></li>
-    <li><label for="o44"><input id="o44" name="o44" type="checkbox" />Every feature plug-in has copyright notices, etc. in the &quot;blurb&quot; property of &quot;about.properties&quot;</label></li>
-    </ul>
-	<div class="postit"><div class="postitinner"><h3>Why So Many Copies?</h3>
-		<p>For technical reasons (i.e., this is the way the software works),
-		each of the different copies of the SUA and Project license(s) (e.g., EPL)
-		are shown to the user
-		at different times. We need to make sure that the SUA and Project license(s)
-		are available
-		to the user regardless of which installation and/or browsing mechanism he
-		or she uses, thus the existence of numerous copies of the same legal documents.
-	</div></div>
-	
-	<div class="postit"><div class="postitinner"><h3>What&rsquo;s the Difference Between These Files?</h3>
-		<p>The difference between the Feature License and Feature Update License 
-        is when they are shown to the user. The Feature License is only available 
-        once a feature has been installed. The Feature Update License is seen 
-        when a user is using the Eclipse Update Manager to install or upgrade 
-        a feature and must agree to an agreement before proceeding with the installation. 
-        One thing that is important to note is that with the distributed licensing 
-        model used by plug-ins, unless a Feature Update License contains an aggregation 
-        of all the notices from the plug-ins for a feature, a user will not be 
-        able to see these notices before installing the feature.</p>	</div></div>
-
-<h2>5. Plug-ins</h2>
-	<p>
-	<a name="#about_files"></a>
-	All plug-in directories must have an &quot;about.html&quot; file describing
-	the license terms of the code and content of the plug-in. The &quot;about.html&quot;
-	file may also contain other information such as whether the content contains
-	cryptographic functionality that may be subject to export controls.
-	These &quot;about.html&quot; are collective known as &quot;Abouts.&quot;
-	<p>
-	Most plug-ins of Eclipse Projects are pure EPL and thus the about.html file
-	will be <a href="epl/about.html" target="_blank">default about for EPL plug-ins</a>.
-	If a plug-in contains non-EPL content, read more about
-	<a href="epl/about.php">About files</a> and how to write About files for third-party
-	content.
-	<p>
-	In JAR&rsquo;ed plug-ins, any local files linked from an About such 
-	as copies of licenses, must be located in a directory called &quot;about_files.&quot; 
-	The contents of the &quot;about_files&quot; directory are handled specially 
-	so that links resolve correctly when the About in a JAR&rsquo;ed plug-in is 
-	viewed in an external browser spawned from the About dialog.</p>
-	<p>As an example:</p>
-      <blockquote> 
-        <table cellspacing="4">
-          <tr> 
-            <td><i>eclipse</i></td>
-            <td>(installation root directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;<i>plugins</i></td>
-            <td>(plug-ins and fragments directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.apache.ant_1.6.2</i></td>
-            <td>(plug-in packaged as a directory)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
-            <td><b>About</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
-            <td><b>Apache Software License referenced by about.html</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>LICENSE.dom.html</i></td>
-            <td><b>W3C License referenced by about.html</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>org.eclipse.core.runtime_3.1.0.jar</i></td>
-            <td>(plug-in packaged as a JAR)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about.html</i></td>
-            <td><b>About</b></td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>about_files</i></td>
-            <td>(directory for any local files linked from about.html)</td>
-          </tr>
-          <tr> 
-            <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>asl-v20.txt</i></td>
-            <td><b>Apache Software License referenced by about.html</b></td>
-          </tr>
-        </table>
-      </blockquote>
-	<ul class="checklist">
-    <li><label for="o51"><input id="o51" name="o51" type="checkbox" />Every plug-in has an &quot;about.html&quot;, usually the standard one.</label></li>
-    <li><label for="o53"><input id="o53" name="o53" type="checkbox" />Every plug-in with a non-standard &quot;about.html&quot; contains the additional referenced license files.</label></li>
-    <li><label for="o52"><input id="o52" name="o52" type="checkbox" />Every &rsquo;ed plug-in stores linked files in &quot;about_files&quot;</label></li>
-    </ul>
-
-
-<h2>6. Download Web Pages</h2>
-	<p>Any web page that makes builds available must have a link to the <a href="#SUA">SUA</a>
-	with the following wording:
-      <blockquote>
-        <p>All downloads are provided under the terms and conditions of the <a href="epl/notice.php" target="_blank">Eclipse 
-          Foundation Software User Agreement</a> unless otherwise specified.</p>
-      </blockquote>
-	<ul class="checklist">
-    <li><label for="o61"><input id="o61" name="o61" type="checkbox" />All download pages contain the standard reference to the SUA.</label></li>
-    </ul>
-
-<h2>Appendix A. Viewing All These Files</h2>
-
-	<h3>About Files</h3>
-    <p>Users looking for legal documentation may find the Abouts by browsing 
-    the directory structure of an Eclipse installation but the files are also 
-	viewable from the &quot;About plug-ins&quot; dialog in the Eclipse workbench. 
-	To view the Abouts, go to the menu item <strong>Help -> About Eclipse 
-	Platform</strong> and then click on the button &quot;Plug-in Details&quot; 
-	and then select a plug-in and click on the button &quot;More Info.&quot;</p>
-    <img src="guidetolegaldoc_files/About_plugins_dialog.jpg" width="598" height="447">
-
-	<h3>Feature Blurbs</h3>
-    <p>To view the blurb for each installed feature, go to 
-	the menu item <strong>Help > About Eclipse Platform</strong> and then 
-	click &quot;Feature Details&quot; and then select a feature. The blurb 
-	will appear in the bottom half of the dialog. </p>
-      <img src="guidetolegaldoc_files/About_features_dialog.jpg" width="598" height="536">
-
-
-
-</div>
-	
-</form>
-
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/legalfaq.php b/legalfaq.php
index e708f35..bb95486 100644
--- a/legalfaq.php
+++ b/legalfaq.php
@@ -1,21 +1,21 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2005,2017 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *******************************************************************************/
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Public License 2.0 which accompanies
+ * this distribution, and is available at http://eclipse.org/legal/epl-2.0
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ */
 
 require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
 
 $App = new App();
-$Nav = new Nav();
-include("_projectCommon.php");
+$Theme = $App->getThemeClass();
 
-$Theme = $App->getThemeClass($theme);
-$Theme->setNav($Nav);
+include("_projectCommon.php");
 
 $pageTitle = "Eclipse Foundation Legal Frequently Asked Questions (FAQ)";
 $Theme->setPageTitle($pageTitle);
@@ -36,15 +36,14 @@
 }
 
 ob_start(); ?>
-
 <div id="midcolumn">
-	<div class="homeitem3col">
-		<?php print getBodyContent(dirname(__FILE__) . '/documents/html/legalfaq.html'); ?>
-	</div>
+  <div class="homeitem3col">
+    <?php print getBodyContent(dirname(__FILE__) . '/documents/html/legalfaq.html'); ?>
+  </div>
 </div>
-  
 <?php
-    $html = ob_get_contents();
-    ob_end_clean();
-    $App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
+$html = ob_get_clean();
+
+$Theme->setNav($Nav);
+$Theme->setHtml($html);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/licenses.php b/licenses.php
index 66878af..dc21e47 100644
--- a/licenses.php
+++ b/licenses.php
@@ -1,34 +1,38 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2017 Eclipse Foundation and others.
+/**
+ * Copyright (c) 2017, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 require_once dirname(__FILE__) . "/../eclipse.org-common/system/app.class.php";
-require_once dirname(__FILE__) . "/../eclipse.org-common/system/nav.class.php";
-require_once dirname(__FILE__) . "/../eclipse.org-common/system/menu.class.php";
 
 $App = new App();
-$Menu = new Menu();
-$Nav = new Nav();
+$Theme = $App->getThemeClass();
 
 include (dirname(__FILE__) . "/_projectCommon.php");
 
 $pageTitle = "Third Party Content Licenses";
-$pageAuthor = "Wayne Beaton";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, privacy, policy");
+$Theme->setPageAuthor("Wayne Beaton");
 
 $licenseFile = dirname(__FILE__) . "/licenses.json";
 
-function dumpLicenseList($file)
-{
-    $licenses = json_decode(file_get_contents($file), true);
-    echo "<ul>";
-    foreach ($licenses['approved'] as $spdx => $name) {
-        echo "<li>{$name}</li>";
-    }
-    echo "</ul>";
+function dumpLicenseList($file) {
+  $licenses = json_decode(file_get_contents($file), true);
+  echo "<ul>";
+  foreach ($licenses['approved'] as $spdx => $name) {
+    echo "<li>{$name}</li>";
+  }
+  echo "</ul>";
 }
 
 // I'm pretty sure that this just won't work; it would end up
@@ -38,37 +42,9 @@
 $modified = strtotime("2017-10-19");
 
 ob_start();
-?>
-<div id="maincontent">
-	<div id="midcolumn">
-		<h1><?php echo $pageTitle; ?></h1>
-		<p>Updated <?php print $App->getFormattedDate($modified); ?></p>
-		<h3 id="approved">Approved Licenses</h3>
-		<p>
-			The following is a list of the most common licenses approved for use
-			by third party code redistributed by Eclipse Foundation Projects.
-			This list is not exhaustive. Should you have a query on a specific
-			license not listed here, please contact <a href="license@eclipse.org">license@eclipse.org</a>.
-		</p>
-		
-		<?php dumpLicenseList($licenseFile); ?>
-		
-		<h3 id="nonapproved">Non Approved Licenses</h3>
-		<ul>
-			<li>GNU General Public License (GPL)</li>
-			<li>Sun Binary Code License Agreement</li>
-		</ul>
-		<p>
-			Please note the LGPL has been approved by the Eclipse Board of
-			Directors in certain cases. Please contact <a
-				href="license@eclipse.org">license@eclipse.org</a> for more
-			information.
-		</p>
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-
-	</div>
-</div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/logo_guidelines.php b/logo_guidelines.php
index 06840cd..97930cd 100644
--- a/logo_guidelines.php
+++ b/logo_guidelines.php
@@ -1,296 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Guidelines for Eclipse Logos &amp; Trademarks";
-	$pageKeywords	= "legal, foundation, guidelines, trademarks";
-	$pageAuthor		= "Mike Milinkovich, Nov. 26, 2005";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+include ($App->getProjectCommon());
 
-	<div id="midcolumn">
-		<h1>$pageTitle<br/></h1>
-		<p>March 7, 2016</p>
-	<h3><a name="h.ggtn2qdts1nf"></a>Table of Contents</h3>
-      <blockquote>
-      <ul>
-        <li><a href="#Purpose" class=jump>Purpose</a></li>
-        <li><a href="#GeneralLogo" class=jump>General Usage of Logos</a></li>
-        <li><a href="#ProperEclipse" class=jump>Proper Usage of	&quot;Eclipse&quot; Trademark and Logo</a></li>
-        <li><a href="#ProperProjects" class=jump>Proper Usage of Eclipse Project Names and Logos</a></li>
-        <li><a href="#ProperWG" class=jump>Proper Usage of Eclipse Working Group Names and Logos</a></li>
-        <li><a href="#ProperMember" class=jump>Proper Usage of &quot;Eclipse Foundation Member&quot; Logo</a></li>
-        <li><a href="#ProperBuilt" class=jump>Proper Usage of &lsquo;Built on Eclipse&lsquo; Trademark and Logo</a></li>
-        <li><a href="#ProperReady" class=jump>Proper Usage of &quot;Eclipse Ready&quot; Trademark and Logo</a></li>
-        <li><a href="#ProperIncubation" class=jump>Proper Usage of &quot;Eclipse Incubation&quot; Trademark and Logo</a></li>
-        <li><a href="#ProperNotice" class=jump>Proper Notice and Attribution</a></li>        
-      </ul>
-      </blockquote>
+$pageTitle = "Guidelines for Eclipse Logos &amp; Trademarks";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, foundation, guidelines, trademarks");
+$Theme->setPageAuthor("Mike Milinkovich, Nov. 26, 2005");
 
-	<h3><a name="Purpose"></a>Purpose:</h3>
-	<p>These requirements are meant to promote and improve the image of
-	all elements of the Eclipse community, as well as to show that all
-	Eclipse Foundation projects are part of a community of developers,
-	adopters and users. While every project manages their own development
-	within the broader <a href="https://eclipse.org/projects/dev_process/development_process.php">Eclipse
-	Development Process</a>, a consistent set of trademark and branding
-	requirements benefits the entire Eclipse community.</p>
-	
-	<p>The Eclipse Foundation holds the trademarks for the project names
-	and logos on behalf of, and for the benefit of, the Eclipse community
-	as a whole. The individual projects are not separate legal entities,
-	and thus not able to hold trademarks individually. The Eclipse
-	Foundation is a legal entity and owns the trademarks on behalf of the
-	entire community.</p>
-	
-	<p>If you have any questions regarding this policy, or wish to use an
-	Eclipse Foundation trademark in a way not explicitly explained in
-	these Guidelines, then ask us by sending an email to
-	<a href="mailto:license@eclipse.org" target="_top">license@eclipse.org</a>.</p>
-	
-	<p>The Eclipse Foundation and Eclipse projects have created a number
-	of trademarks and logos to identify the Eclipse community and
-	individual Eclipse projects. In addition to the &lsquo;Eclipse&rsquo;
-	trademark, the Eclipse Foundation has introduced seven trademarks and
-	logos: </p>
-		<ul>
-			<li/>
-		<p>Eclipse Foundation Member,</p>
-			<li/>
-		<p>EclipseCon,</p>
-			<li/>
-		<p>Eclipse Summit,</p>
-			<li/>
-		<p>Built on Eclipse,</p>
-			<li/>
-		<p>Eclipse Ready, and</p>
-			<li/>
-		<p>Eclipse Incubation.</p>
-		</ul>
-	<p>Individual Eclipse projects and Eclipse Working Groups have also
-	introduced unique names and logos&nbsp;that are trademarks of the
-	Eclipse Foundation. This document outlines the policy and guidelines
-	of the Eclipse Foundation in regards to any use of these trademarks.</p>
-	<p>Our goals in establishing these guidelines are pretty simple:</p>
-	<ul>
-	<li>The Eclipse trademarks are a
-		symbol of the quality and community support that people have come to
-		associate with Eclipse. To ensure that the Eclipse trademarks
-		continue to serve these functions, we need to keep control over
-		their use. Along these lines, we want to ensure that the use of our
-		marks is not likely to lead to confusion with other marks. By this
-		we mean that people should be able to tell when something is from
-		the Eclipse Foundation or one of the Eclipse projects. Also, use of
-		our marks must not be in a disparaging manner because we prefer that
-		our marks not be used to be rude about the Eclipse technology, the
-		Eclipse Foundation, its projects, or its Members.</li>
-	<li>We want to encourage our logos to be used in approved ways.
-		For example, we want to make it as simple as legally possible for
-		our Members to use the &lsquo;Eclipse Foundation Member&rsquo; mark.</li>
-	</ul>
-	<h3><a name="GeneralLogo"></a>General Usage of Logos</h3>
-	<ol>
-		<li/>
-	<p>Derivative works of the
-		&lsquo;EclipseCon&rsquo;, &lsquo;Eclipse Summit&rsquo;, &lsquo;Eclipse
-		Foundation Member&rsquo;, &lsquo;Built on Eclipse&rsquo;, &lsquo;Eclipse
-		Ready&rsquo; and projects logos are not allowed.</p>
-		<li/>
-	<p>The &lsquo;Eclipse&rsquo; logos
-		and production specification are available from www.eclipse.org.
-		Replication of these logos must follow these specifications.</p>
-		<li/>
-	<p>Except for use by Eclipse
-		projects on the eclipse.org website, use of the &lsquo;Eclipse
-		Incubation&rsquo; Trademark and Logo is not permitted unless
-		authorized in writing by the Eclipse Foundation.</p>
-	</ol>	
-	
-	<h3><a name="ProperEclipse"></a>Proper Usage of	&quot;Eclipse&quot; Trademark and Logo</h3>
-	<p>The &ldquo;Eclipse&rdquo; name and logo are the intellectual
-	property of the Eclipse Foundation and must be identified as such.
-	Eclipse logos are provided for use under the terms of these
-	Guidelines. Use of the &ldquo;Eclipse&rdquo; name or Eclipse logos
-	are restricted to identifying the Eclipse Foundation, the Eclipse
-	projects, the Eclipse working groups, and their deliverables, as
-	applicable.</p>
-	<p>Eclipse logos (including the Eclipse logo, and the logos of
-	Eclipse projects and working groups) cannot be altered without the
-	written permission of the Eclipse Foundation. Eclipse Foundation
-	projects or working groups are permitted to create derivative works
-	of Eclipse logos with the permission of the <a href="http://www.eclipse.org/org/foundation/directors.php">Eclipse
-	Foundation Board of Directors</a>. Any project that wishes to seek
-	such permission may do so by sending an email to license@eclipse.org.</p>
-	<ol>
-		<li/>
-	<p>You must not incorporate the
-		&lsquo;Eclipse&rsquo; trademark into the name of your company or
-		software product name. If you have a software product that works
-		with an Eclipse technology, you must use phrases such as &lsquo;&lt;product
-		name&gt; for Eclipse&rsquo; or &lsquo;&lt;product name&gt;, Eclipse
-		Edition&rsquo;.</p>
-		<li/>
-	<p>You may request permission to
-		include the &lsquo;Eclipse&rsquo; trademark in the name of a
-		publication, certification program, domain name or book. At a
-		minimum you must ensure that a) the appropriate TM or (R) symbol is
-		associated with the &lsquo;Eclipse&rsquo; reference and appropriate
-		attribution as discussed below, b) &lsquo;Eclipse&rsquo; is not
-		concatenated with another word, e.g. EclipseBoard, and c) the usage
-		does not imply or make the user believe that the publication, domain
-		name or book is supported or authorized by the Eclipse Foundation.
-		Any organization wishing to seek such permission may do so by
-		sending an email to license@eclipse.org.</p>
-		<li/>
-	<p>An important use of the
-		&lsquo;Eclipse&rsquo; trademark is the &lsquo;org.eclipse&rsquo;
-		string used on all namespaces for Eclipse open source projects. This
-		naming convention is used to identify code that has been developed
-		as an Eclipse open source project. Therefore, no one, except Eclipse
-		open source projects may develop or maintain software packages that
-		use &lsquo;org.eclipse&rsquo; in their namespace.</p>
-		<li/>
-	<p>&lsquo;Eclipse&rsquo; must always be capitalized, except
-		when used as part of the Eclipse logos.</p>
-	</ol>
-	<h3><a name="ProperProjects"></a>Proper Usage of Eclipse Project Names and Logos</h3>
-	<p>The <a href="https://wiki.eclipse.org/Development_Resources/HOWTO/Project_Naming_Policy">Eclipse
-	Project Naming Policy</a>&nbsp;allows for Eclipse projects to have a
-	descriptive name, optional nickname and acronym. These names, e.g.
-	Orion, and acronyms, e.g. BIRT, can be become effective identifiers
-	of certain technologies, therefore it is important to establish
-	proper usage guidelines. All project names, nicknames, logos, and
-	acronyms are the intellectual property of the Eclipse Foundation and
-	must be identified as such. For clarity, projects are not required to
-	include &ldquo;Eclipse&rdquo; in their project logos. (Please see
-	proper notice and attribution below.)</p>
-	<ol>
-		<li/>
-	<p>All Eclipse projects must be
-		identified as being Eclipse projects. Therefore, when referencing an
-		Eclipse project, we ask that both the first and the most prominent
-		reference to the project on each page is identified as Eclipse
-		[project name], ex Eclipse Graphical Modeling Framework (GMF) or in
-		the case of a project name that already includes Eclipse, Eclipse
-		Communication Framework (ECF). Subsequent references may drop the
-		Eclipse identifier.</p>
-		<li/>
-	<p>You must not incorporate the
-		name of an Eclipse project, nickname or acronym into the name of
-		your company or software product name. If you have a software
-		product that works with an Eclipse project, it is suggested you use
-		terms such as '&lt;product name&gt; for &lt;Eclipse project name&gt;'
-		or '&lt;product name&gt;, &lt;Eclipse project name&gt; Edition'</p>
-		<li/>
-	<p>You may request permission to &nbsp;include an Eclipse
-		project trademark in the name of a publication, certification
-		program, domain name or book. At a minimum you must ensure that a)
-		the appropriate &trade; or &reg; symbol is associated with the
-		Eclipse project name reference and appropriate attribution as
-		discussed below, b) Eclipse project name is not concatenated with
-		another word, e.g. OrionPortal, and c) the usage does not imply or
-		make the user believe that the publication, domain name or book is
-		supported or authorized by the Eclipse Foundation or any Eclipse
-		project. &nbsp;Any organization wishing to seek such permission may
-		do so by sending an email to license@eclipse.org.</p>
-	</ol>
-	
-	<h3><a name="ProperWG"></a>Proper Usage of Eclipse Working Group Names and Logos</h3>
-	<p>The names and logos of the Eclipse Foundation Working Groups (WG)
-	are the intellectual property of the Eclipse Foundation and must be
-	identified as such. (Please see proper notice and attribution below).
-	Use of WG trademarks are restricted to identifying the WGs and their
-	deliverables, as applicable. No other uses of WG names and logos are
-	permitted unless authorized in writing by the Eclipse Foundation.</p>
-	<p>Each WG may, at its discretion, develop guidelines for use of the
-	WG trademarks or their derivatives, as applicable, by third parties.
-	These guidelines will be referenced in Appendix A of this document
-	and shall be consistent with these Guidelines for Eclipse Logos and
-	Trademarks. It is not permitted to create any derivative work of a WG
-	trademark with written approval of the Eclipse Foundation, which will
-	consult with the Steering Committee of the relevant Working Group.
-	Any organization wishing to seek permission to create a derivative
-	work of any WG trademark may do so by sending an email to
-	license@eclipse.org.</p>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-	<h3><a name="ProperMember"></a>Proper Usage of &quot;Eclipse Foundation Member&quot; Logo</h3>
-	<p>The &lsquo;Eclipse Foundation Member&rsquo; logo is to identify
-	those organizations and individuals that are official members of the
-	Eclipse Foundation, including 1) Strategic Members, 2) Enterprise
-	Members, 3) Solutions (formerly Add-in Provider) Members, 4)
-	Associate Members, and 5) Committer Members. Only official Members of
-	the Eclipse Foundation are authorized to use this logo.</p>
-	<h3><a name="ProperBuilt"></a>Proper Usage of &lsquo;Built on Eclipse&lsquo; Trademark and Logo</h3>
-	<p>The &lsquo;Built on Eclipse&rsquo; trademark is used to identify a
-	product that includes the core Eclipse IDE Platform, specifically the
-	runtime, SWT, JFace, and Generic Workbench components. This type of
-	product is able to run standalone with no prerequisites of other
-	Eclipse components.</p>
-	<h3><a name="ProperReady"></a>Proper Usage of &quot;Eclipse Ready&quot; Trademark and Logo</h3>
-	<p>The &lsquo;Eclipse Ready&lsquo; trademark and logo is used to
-	identify a product that is packaged as an Eclipse IDE feature or
-	plug-in and must be added to an Eclipse platform product. This type
-	of product does not run standalone.</p>
-	<h3><a name="ProperIncubation"></a>Proper Usage of &quot;Eclipse Incubation&quot; Trademark and Logo</h3>
-	<p>The &lsquo;Eclipse Incubation&rsquo; Trademark and Logo are for use exclusively&nbsp;by
-	the Eclipse Foundation and the Eclipse projects. Only the Eclipse
-	Foundation and its projects are authorized to use this trademark and
-	logo. All other use -- even by Eclipse Foundation Members -- is
-	prohibited.</p>
-	<h3><a name="ProperNotice"></a>Proper Notice and Attribution</h3>
-	<p>The appropriate trademark symbol (i.e. TM or (R)) must appear at
-	both the first and most prominent use of the Eclipse Foundation
-	trademarks, and with all occurrence of the Eclipse logo.</p>
-	<p>When you use an Eclipse Foundation trademark or logo you must
-	include a statement attributing the trademark to the Eclipse
-	Foundation, Inc. For example, &quot;&lsquo;Eclipse&rsquo;, &lsquo;Built
-	on Eclipse&rsquo; and &lsquo;Eclipse Ready&rsquo;, &lsquo;BIRT&rsquo;,
-	&lsquo;Orion&rsquo; are trademarks of Eclipse Foundation, Inc.&quot;</p>
-	<h3></a>Footnotes</h3>
-	<p>These guidelines were first introduced at a point in time when
-	some companies and individuals already had product names that include
-	the &lsquo;Eclipse&rsquo; trademark. Companies and individuals using
-	the &lsquo;Eclipse&rsquo; trademark as of February 1, 2005 will not
-	be required to change their already existing product names to comply
-	with these guidelines now or in the future. However, all companies
-	and individuals are required to give proper notice and attribution of
-	the &lsquo;Eclipse&rsquo; trademark. All usage subsequent to February
-	1, 2005 are required to follow these guidelines.</p>
-	<p>Similarly, further revisions to these guidelines were first
-	introduced at a point in time when some companies and individuals
-	already had product names that include Eclipse project trademarks.
-	Companies and individuals using an Eclipse project trademarks as of
-	June 20, 2007 will not be required to change their already existing
-	product names to comply with these guidelines now or in the future.
-	However, all companies and individuals are required to give proper
-	notice and attribution of the Eclipse project trademark. All usage
-	subsequent to June 20, 2007 are required to follow these guidelines.</p>
-</div>
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/newcommitter.php b/newcommitter.php
index 89714da..8e43085 100644
--- a/newcommitter.php
+++ b/newcommitter.php
@@ -1,5 +1,17 @@
 <?php
-header("Location: http://www.eclipse.org/projects/dev_process/new-committer.php");
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-exit;
-?>
+header("Location: http://www.eclipse.org/projects/dev_process/new-committer.php");
+exit();
\ No newline at end of file
diff --git a/noncodelicenses.php b/noncodelicenses.php
index d128685..d93565d 100644
--- a/noncodelicenses.php
+++ b/noncodelicenses.php
@@ -1,95 +1,33 @@
 <?php
-/**************************************************************************
- * Copyright (c) 2005,2017 Eclipse Foundation and others.
+/**
+ * Copyright (c) 2005, 2017, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
-require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php");
 
 $App = new App();
-$Nav = new Nav();
-$Menu = new Menu();
+$Theme = $App->getThemeClass();
+
 include ($App->getProjectCommon());
 
 $pageTitle = "Approved Licenses for Non-Code, Example, and Other Content";
-$pageKeywords = "license, content";
-$pageAuthor = "Mike Milinkovich";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("license, content");
+$Theme->setPageAuthor("Mike Milinkovich");
 
 ob_start();
-?>
-<div id="midcolumn">
-	<h1><?php print $pageTitle; ?></h1>
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-	<p>December 6, 2017</p>
-
-	<p>
-		The following licenses have been approved by the Board of Directors
-		for use with Non-Code Content, as that term is defined in the <a
-			href="termsofuse.php">Eclipse.org Terms of Use</a>.
-	</p>
-
-	<ol>
-		<li>the <a href="/legal/epl-2.0">Eclipse Public License 2.0</a>,
-		</li>
-
-		<li>the <a href="../org/documents/epl-v10.php">Eclipse Public License
-				1.0</a>,
-		</li>
-		<li>the <a href="http://creativecommons.org/licenses/by-sa/3.0/"
-			target="_blank">Creative Commons Attribution-Share Alike 3.0
-				(Unported) License</a>,
-		</li>
-		<li>the <a href="http://creativecommons.org/licenses/by/3.0/"
-			target="_blank">Creative Commons Attribution 3.0 (Unported) License</a>,
-		</li>
-		<li>the <a href="http://creativecommons.org/licenses/by-sa/4.0/"
-			target="_blank">Creative Commons Attribution-Share Alike 4.0
-				(International) License</a>, or
-		</li>
-		<li>the <a href="http://creativecommons.org/licenses/by/4.0/"
-			target="_blank">Creative Commons Attribution 4.0 (International)
-				License</a>.
-		</li>
-	</ol>
-	<br />
-	<p>In addition, the following licenses have been approved by the Board
-		of Directors for use with example code or build scripts and artifacts
-		within Eclipse projects.</p>
-	<ol>
-		<li>the <a href="/legal/epl-2.0">Eclipse Public License 2.0</a>,
-		</li>
-		<li>the <a href="../org/documents/epl-v10.php">Eclipse Public License 1.0</a>,
-			or
-		</li>
-		<li>the <a href="../org/documents/edl-v10.php">Eclipse Distribution
-				License</a> (EDL).
-		</li>
-	</ol>
-	<br />
-	<p>
-		For additional details on the definition of example code or build
-		scripts and artifacts and how to seek PMC approval for using the EDL,
-		please refer to the <a
-			href="../org/documents/Licensing_Example_Code.pdf">policy document</a>.
-	</p>
-	<br />
-
-</div>
-<div id="rightcolumn">
-	<div class="sideitem">
-		<h6>Related Links</h6>
-		<ul>
-			<li><a href="index.php">Legal resources</a></li>
-			<li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
-		</ul>
-	</div>
-</div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/privacy.php b/privacy.php
index 3b5a6d7..49660f6 100644
--- a/privacy.php
+++ b/privacy.php
@@ -1,135 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Revision of the Eclipse.org Privacy Policy
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Eclipse.org Privacy Policy";
-	$pageKeywords	= "legal, privacy, policy";
-	$pageAuthor		= "Mike Milinkovich";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+include ($App->getProjectCommon());
 
-	<div id="midcolumn">
-		<h1>$pageTitle</h1>
-		<h2>Eclipse.org Privacy Practices</h2>
+$pageTitle = "Eclipse.org Privacy Policy";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, privacy, policy");
+$Theme->setPageAuthor("Mike Milinkovich");
 
-		<p>May 12, 2016</p>	
-		
-		<p><strong>Privacy</strong></p>
-	
-		<p>You can visit Eclipse.org without revealing who you are or
-		any information about yourself. There are times, however, when the Eclipse Foundation or its Members
-		(&quot;We&quot; or &quot;Us&quot;) may need information from you.
-		You may choose to give personal information, such as your name
-		and address or e-mail id that may be needed, for example, to correspond with
-		you. We intend to let you know how such information will be used before it is
-		collected from you on the Internet.  If
-		you tell Us that you do not want Us to use this information as a basis for
-		further contact with you, We will respect your wishes.</p>
+ob_start();
+include ("content/en_privacy.php");
+$html = ob_get_clean();
 
-		<p><strong>Information Security and Quality</strong></p>
-
-		<p>We intend to protect the quality and integrity of your
-		personally identifiable information. We
-		have tried to implement appropriate technical and organizational measures, such
-		as using encryption for transmission of certain forms of information, to help
-		keep that information secure, accurate, current, and complete.</p>
-
-		<p>We will make a sincere effort to respond in a timely manner
-		to your requests to correct inaccuracies in your personal information. To
-		correct inaccuracies in your personal information please return the message
-		containing the inaccuracies to the sender with details of the correction
-		requested.</p>
-		
-		<p>We offer as a service to our community the ability for users of Eclipse software 
-		to store data on Eclipse Foundation servers through services including but not limited to
-		the User Storage Service and the Automated Error Reporting Initiative.  
-		Any data stored through these services will be publicly available on the Internet in 
-		unencrypted form and without access restriction. Therefore you should not use this 
-		service to store passwords, any personally identifiable information, any confidential 
-		business information, or anything else that you do not want to be generally and publicly 
-		available.</p>
-
-		<p><strong>Clickstream Data and Cookies</strong></p>
-
-		<p>We sometimes collect anonymous information from visits to
-		this Web site to help provide better service.  For example, We keep track of the
-		domains from which people visit and We
-		also measure visitor activity on Eclipse.org, but in ways that keep the
-		information anonymous. This anonymous
-		information is sometimes known as &quot;clickstream data.&quot; We may use this data to analyze trends and statistics and to help
-		us tailor the Web site to better serve Eclipse participants.</p>
-	
-		<p>Also, when personal data is collected from you in connection
-		with a transaction (such as contribution of code or posting to newsgroups) We
-		may extract some information about that transaction in an anonymous format and
-		combine it with other anonymous information such as clickstream data. This anonymous information is used and
-		analyzed only at an aggregate level to help Us understand trends and patterns.</p>
-
-		<p>Some Eclipse.org pages use cookies to better serve you when
-		you return to the site. You can set
-		your browser to notify you before you receive a cookie, giving you the chance
-		to decide whether to accept it. You can
-		also set your browser to turn off cookies. If you do so, however, some areas of some sites
-		may not function
-		properly.</p>
-
-		<p>To the extent Contributions and other Material (as defined
-		in the Terms of Use) contain personal information about you, including, but not
-		limited to, your name, we have the right to provide that information to others
-		pursuant to the Term of Use.</p>
-
-		<p><strong>Business Relationships</strong></p>
-
-		<p>This Web site contains links to other Web sites. We are not responsible for the privacy
-		practices or the content of such Web sites.</p>
-
-		<p><strong>Notification of Changes</strong></p>
-
-		<p>This privacy statement was last updated on May 12, 2016.
-		A notice will be posted on this Web site home page for thirty (30) days
-		whenever this privacy statement is changed.</p>
-
-		<p><strong>Questions Regarding This Statement</strong></p>
-
-		<p>Questions regarding this statement should be directed to: <a
-		href="mailto:license@eclipse.org">license@eclipse.org</a>.</p>
-		<br/>
-	</div>
-	<div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-			<li><a href="index.php">Legal resources</a></li>
-			<li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
-			</ul>
-		</div>
-	</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
diff --git a/services/aeri-privacy.php b/services/aeri-privacy.php
index e60cc3d..c244517 100644
--- a/services/aeri-privacy.php
+++ b/services/aeri-privacy.php
@@ -1,15 +1,16 @@
-<?php 
-	#*****************************************************************************
-	#
-	# legal/uss/privacy.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Display the current privacy policy for the user storage service.
-	#
-	#
-	#****************************************************************************
-
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
 include '../privacy.php';
-?>
\ No newline at end of file
diff --git a/services/aeri-termsofuse.php b/services/aeri-termsofuse.php
index 1b9561f..91ac0ca 100644
--- a/services/aeri-termsofuse.php
+++ b/services/aeri-termsofuse.php
@@ -1,15 +1,15 @@
-<?php 
-	#*****************************************************************************
-	#
-	# legal/uss/termsofuse.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Display the current terms of use for the user storage service.
-	#
-	#
-	#****************************************************************************
-
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 include '../termsofuse.php';
-?>
\ No newline at end of file
diff --git a/services/privacy.php b/services/privacy.php
index e60cc3d..e24e8eb 100644
--- a/services/privacy.php
+++ b/services/privacy.php
@@ -1,15 +1,15 @@
-<?php 
-	#*****************************************************************************
-	#
-	# legal/uss/privacy.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Display the current privacy policy for the user storage service.
-	#
-	#
-	#****************************************************************************
-
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 include '../privacy.php';
-?>
\ No newline at end of file
diff --git a/services/termsofuse.php b/services/termsofuse.php
index 1b9561f..af564ec 100644
--- a/services/termsofuse.php
+++ b/services/termsofuse.php
@@ -1,15 +1,16 @@
 <?php 
-	#*****************************************************************************
-	#
-	# legal/uss/termsofuse.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Display the current terms of use for the user storage service.
-	#
-	#
-	#****************************************************************************
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-include '../termsofuse.php';
-?>
\ No newline at end of file
+include '../termsofuse.php';
\ No newline at end of file
diff --git a/services/uss-beta-privacy.php b/services/uss-beta-privacy.php
index 299326b..ecb5d32 100644
--- a/services/uss-beta-privacy.php
+++ b/services/uss-beta-privacy.php
@@ -1,16 +1,16 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Revision of the Eclipse.org Privacy Policy
-	#
-	#
-	#****************************************************************************
-	
 include '../privacy.php';
-?>
diff --git a/services/uss-beta-termsofuse.php b/services/uss-beta-termsofuse.php
index 0591c1a..a6b5dc9 100644
--- a/services/uss-beta-termsofuse.php
+++ b/services/uss-beta-termsofuse.php
@@ -1,16 +1,16 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2015, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Mike Milinkovich (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-12-09
-	#
-	# Description: Revision of the Eclipse.org Terms of Use
-	#
-	#
-	#****************************************************************************
-
-include '../termsofuse.php';
-?>
+include '../termsofuse.php';
\ No newline at end of file
diff --git a/termsofuse.php b/termsofuse.php
index 85dc785..4542be1 100644
--- a/termsofuse.php
+++ b/termsofuse.php
@@ -1,266 +1,32 @@
 <?php
-/**************************************************************************
+/**
  * Copyright (c) 2015, 2018 Eclipse Foundation and others.
  *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Public License 2.0 which accompanies
- * this distribution, and is available at http://eclipse.org/legal/epl-2.0
- **************************************************************************/
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 require_once (dirname(__FILE__) . "/../eclipse.org-common/system/app.class.php");
-require_once (dirname(__FILE__) . "/../eclipse.org-common/system/nav.class.php");
-require_once (dirname(__FILE__) . "/../eclipse.org-common/system/menu.class.php");
 
 $App = new App();
-$Menu = new Menu();
-$Nav = new Nav();
+$Theme = $App->getThemeClass();
 
 include ($App->getProjectCommon());
 
 $pageTitle = "Eclipse.org Terms of Use";
-$pageKeywords = "terms, legal, website, terms of use";
-$pageAuthor = "Mike Milinkovich";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("terms, legal, website, terms of use");
+$Theme->setPageAuthor("Mike Milinkovich");
 
 ob_start();
-?>
-<div id="maincontent">
-	<div id="midcolumn">
-		<h1><?php print $pageTitle ?></h1>
+include ("content/en_termsofuse.php");
+$html = ob_get_clean();
 
-		<p>May 12, 2016</p>
-
-		<h3>Terms and Conditions of Use for the Eclipse Foundation Web Site
-			and Related Services</h3>
-
-		<p>
-			<b>By accessing, browsing, or using this web site, you acknowledge
-				that you have read, understand, and agree to be bound by these
-				terms.</b>
-		</p>
-
-		<p>This Web site and related services are made available by the
-			Eclipse Foundation. All software, documentation, information and/or
-			other materials provided on and through this Web site
-			(&quot;Content&quot;) and all of the related services offered by the
-			Eclipse Foundation may be used solely under the following terms and
-			conditions (&quot;Terms of Use&quot;).</p>
-
-		<p>This Web site may contain other proprietary notices and copyright
-			information, the terms of which must be observed and followed. The
-			Content on this Web site may contain technical inaccuracies or
-			typographical errors and may be changed or updated without notice.
-			The Eclipse Foundation may also make improvements and/or changes to
-			the Content at any time without notice.</p>
-
-		<p>The Eclipse Foundation, its members ("Members") assume no
-			responsibility regarding the accuracy of the Content and use of the
-			Content is at the recipient&rsquo;s own risk. The Eclipse Foundation
-			and the Members provide no assurances that any reported problems with
-			any Content will be resolved. Except as otherwise expressly stated,
-			by providing the Content, neither the Eclipse Foundation nor the
-			Members grant any licenses to any copyrights, patents or any other
-			intellectual property rights.</p>
-
-		<p>The Eclipse Foundation and the Members do not want to receive
-			confidential information from you through this Web site and related
-			services. Please note that any information or material sent to The
-			Eclipse Foundation or the Members will be deemed NOT to be
-			confidential and will be publicly available.</p>
-
-		<h3>User Data Storage Services ("UDSS")</h3>
-
-		<p>
-			As a service to you, Eclipse software may offer functionality whereby
-			you can store certain information on Eclipse Foundation’s computer
-			systems, so that it is accessible to you from various devices that
-			you use. Examples include, but are not limited to, the User Storage
-			Service and the Automated Error Reporting Initiative. <b>PLEASE BE
-				AWARE THAT ALL INFORMATION THAT YOU STORE WITH ECLIPSE WILL BE
-				PUBLICLY ACCESSIBLE ON THE INTERNET IN UNENCRYPTED FORM AND WITHOUT
-				ANY ACCESS RESTRICTIONS. Do not store passwords, any personally
-				identifiable information, any confidential business information, or
-				anything else that you do not want to be generally and publicly
-				available. By using this functionality, any information that you
-				store (the “Stored Information”) will be subject to the <a
-				href="https://creativecommons.org/publicdomain/zero/1.0/legalcode">CC0
-					1.0 Creative Commons</a> license, where, for purposes of that
-				license, the Stored Information shall constitute the “Work” and you
-				shall be the “Affirmer”.
-			</b> What that means is that anybody who accesses your information on
-			the Internet has a worldwide, unrestricted, royalty free,
-			irrevocable, perpetual, non-exclusive license to use, make,
-			reproduce, prepare derivative works of, publicly display, publicly
-			perform, transmit, sell, distribute, sublicense or otherwise transfer
-			the Stored Information without any obligation to you, including any
-			obligation of attribution.
-		</p>
-
-		<p>Eclipse reserves the right to discontinue this service at any time
-			or to remove any specific Stored Information from owned or controlled
-			computer systems at any time, and Eclipse does not commit to making
-			the Stored Information available at all times in the future.</p>
-
-		<p>You are prohibited from posting, transmitting, or storing to or
-			from this Web site site or to any service offered by the Eclipse
-			Foundation any unlawful, threatening, libelous, defamatory, obscene,
-			scandalous, inflammatory, pornographic, or profane material, or any
-			other material that could give rise to any civil or criminal
-			liability under the law.</p>
-
-		<p>
-			If you believe that Content residing or accessible on or through this
-			Web site or any UDSS infringes a copyright, please send a notice of
-			copyright infringement to our designated agent pursuant to the
-			procedures set forth here: <a href="copyright.php">https://www.eclipse.org/legal/copyright.php</a>
-		</p>
-
-		<h3>Disclaimers</h3>
-
-		<p>The Eclipse Foundation and the Members make no representations
-			whatsoever about any other Web site that you may access through this
-			Web site. When you access a non-Eclipse Foundation Web site, even one
-			that may contain the organization&rsquo;s name or mark, please
-			understand that it is independent from the Eclipse Foundation, and
-			that the Eclipse Foundation and the Members have no control over the
-			content on such Web site. In addition, a link to a non-Eclipse
-			Foundation Web site does not mean that the Eclipse Foundation or the
-			Members endorse or accept any responsibility for the content, or the
-			use, of such Web site. It is up to you to take precautions to ensure
-			that whatever you select for your use is free of such items as
-			viruses, worms, Trojan horses and other items of a destructive
-			nature.</p>
-
-		<p>IN NO EVENT WILL THE ECLIPSE FOUNDATION AND/OR THE MEMBERS BE
-			LIABLE TO YOU (AN INDIVIDUAL OR ENTITY) OR ANY OTHER INDIVIDUAL OR
-			ENTITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, SPECIAL OR
-			CONSEQUENTIAL DAMAGES RELATED TO ANY USE OF THIS WEB SITE, THE
-			CONTENT, STORED INFORMATION, OR ON ANY OTHER HYPER LINKED WEB SITE,
-			INCLUDING, WITHOUT LIMITATION, ANY LOST PROFITS, LOST SALES, LOST
-			REVENUE, LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR
-			OTHER DATA ON YOUR OR OUR INFORMATION HANDLING SYSTEMS OR OTHERWISE,
-			EVEN IF THE ECLIPSE FOUNDATION OR THE MEMBERS ARE EXPRESSLY ADVISED
-			OR AWARE OF THE POSSIBILITY OF SUCH DAMAGES OR LOSSES.</p>
-
-		<p>ALL CONTENT IS PROVIDED BY THE ECLIPSE FOUNDATION AND/OR THE
-			MEMBERS ON AN "AS IS" BASIS ONLY. THE ECLIPSE FOUNDATION AND THE
-			MEMBERS PROVIDE NO REPRESENTATIONS, CONDITIONS AND/OR WARRANTIES,
-			EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-			WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY AND
-			NONINFRINGEMENT. THE ECLIPSE FOUNDATION MAKES NO REPRESENTATIONS OR
-			WARRANTIES ABOUT THE SECURITY OF ANY INOFRMATION OR CONTENT STORED
-			WITH THE ECLIPSE FOUNDATION.</p>
-
-		<p>The Eclipse Foundation and the Members reserve the right to
-			investigate complaints or reported violations of these Terms of Use
-			and to take any action they deem appropriate including, without
-			limitation, reporting any suspected unlawful activity to law
-			enforcement officials, regulators, or other third parties and
-			disclosing any information necessary or appropriate to such persons
-			or entities relating to user profiles, e-mail addresses, usage
-			history, posted materials, IP addresses and traffic information.</p>
-
-		<p>The Eclipse Foundation and the Members reserve the right to seek
-			all remedies available at law and in equity for violations of these
-			Terms of Use, including but not limited to the right to block access
-			from a particular Internet address to this Web site.</p>
-
-		<h3>Licenses</h3>
-
-		<p>
-			Except for Content available through the UDSS, the Content provided
-			on this Web site is provided under the terms and conditions of the <a
-				href="epl/notice.php">Eclipse Foundation Software User Agreement</a>
-			and those additional terms, conditions and notices referenced
-			therein.
-		</p>
-
-		<p>
-			If the Content is licensed to you under the terms and conditions of
-			the Eclipse Public License ("<a href="epl-2.0">EPL</a>"),
-			any Contributions, as defined in the applicable license(s), uploaded,
-			submitted, or otherwise made available to the Eclipse Foundation
-			and/or the Members, by you that relate to such Content are provided
-			under the terms and conditions of the EPL and can be made available
-			to others under the terms of the EPL.
-		</p>
-
-		<p>If the Content is licensed to you under license terms and
-			conditions other than the EPL ("Other License"), that Content, as
-			well as any modifications, enhancements and/or other code and/or
-			documentation (collectively, "Modifications") uploaded, submitted, or
-			otherwise made available to the Eclipse Foundation and/or the
-			Members, by you that constitute or otherwise relate to such Content
-			are provided under terms and conditions of the Other License and can
-			be made available to others under the terms of the Other License. In
-			addition, with regard to Modifications for which you are the
-			copyright holder, you are also providing the Modifications under the
-			terms and conditions of the EPL and such Modifications can be made
-			available to others under the terms of the EPL, provided however that
-			the Eclipse Foundation shall have the right to reject any
-			Modifications if the acceptance by the Eclipse Foundation would be in
-			any way inconsistent with the Eclipse Foundation's Intellectual
-			Property Policy.</p>
-
-		<p>
-			To the extent you wish to upload, submit, or otherwise make Non-Code
-			Content (as defined below) available to the Eclipse Foundation and/or
-			the Members, you may make that material available under the terms and
-			conditions of the EPL or any other license stipulated for that
-			purpose at <a href=".">www.eclipse.org/legal</a>. Non-Code Content is
-			Content for which you own or control all rights, and which is not
-			program code intended to be submitted to a Project and documentation
-			related to such code and which is not Stored Information. For
-			example, Non-Code Content would include white papers, dissertations,
-			articles or other literary works, power point presentations,
-			encyclopedias, anthologies, wikis, blogs, diagrams, drawings,
-			sketches, photos or other images, audio content, video content and
-			audiovisual materials.
-		</p>
-
-		<p>For all other software, information and other material including,
-			without limitation, ideas, concepts, know-how and techniques,
-			uploaded, submitted or otherwise made available to The Eclipse
-			Foundation, the Members, and/or users of this Web-site, (collectively
-			"Material"), if the three paragraphs above are inapplicable, and if
-			the Material is not Stored Information, you grant (or warrant that
-			the owner of such rights has expressly granted) a license under
-			either the applicable Project License(s) (as that term is defined in
-			the Eclipse Intellectual Property Policy), or, if no such Project
-			License(s) is applicable, you grant (or warrant that the owner of
-			such rights has expressly granted) the Eclipse Foundation, the
-			Members and the users of this Web-site a worldwide, unrestricted,
-			royalty free, fully paid up, irrevocable, perpetual, non-exclusive
-			license to use, make, reproduce, prepare derivative works of,
-			publicly display, publicly perform, transmit, sell, distribute,
-			sublicense or otherwise transfer such Materials, and/or derivative
-			works thereof, and authorize third parties to do any, some or all of
-			the foregoing including, but not limited to, sublicensing others to
-			do any some or all of the foregoing indefinitely. You represent and
-			warrant that to your knowledge, you have sufficient rights in the
-			Materials to grant the foregoing rights and licenses.</p>
-
-		<p>All logos and trademarks contained on this Web site are and remain
-			the property of their respective owners. No licenses or other rights
-			in or to such logos and/or trademarks are granted to you.</p>
-
-		<p>
-			You can learn more about the <a href="privacy.php">Eclipse.org
-				privacy practices</a> on the Web.
-		</p>
-		<br />
-
-	</div>
-	<div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-				<li><a href="index.php">Legal resources</a></li>
-				<li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
-			</ul>
-		</div>
-	</div>
-</div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage(null, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html );
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/trademarkattributions.php b/trademarkattributions.php
index 0c2e481..346a80d 100644
--- a/trademarkattributions.php
+++ b/trademarkattributions.php
@@ -1,70 +1,33 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ * Denis Roy (Eclipse Foundation) - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Trademark Attributions";
-	$pageKeywords	= "legal, trademarks";
-	$pageAuthor		= "Mike Milinkovich, Nov. 22, 2005";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+include ($App->getProjectCommon());
 
-	<div id="midcolumn">
-		<h1>$pageTitle</h1>
-      	<p>14th December, 2001<br>
-        Modified: 3 May 2016</p>
+$pageTitle = "Trademark Attributions";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, trademarks");
+$Theme->setPageAuthor("Mike Milinkovich, Nov. 22, 2005");
 
-		<p>Content on this web site may make reference to the following trademarks:</p>	
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-		<p>Eclipse, Polarsys and Jetty are registered trademark of the Eclipse Foundation, Inc. in the United States, other countries, or both.</p>
-		
-		<p>IBM, WebSphere. DB2, MQSeries, and VisualAge are trademarks of International Business Machines Corporation in the United States, other countries, or both.</p>
-
-		<p>C-bus is a trademark of Corollary, Inc. in the United States, other countries, or both.</p> 
-
-		<p>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</p>
-
-		<p>Microsoft, Windows, Windows NT, and the Windows logo are trademarks of Microsoft Corporation in the United States, other countries, or both.</p>
-
-		<p>PC Direct is a trademark of Ziff Communications Company in the United States, other countries, or both and is used by IBM Corporation under license.</p>
-
-		<p>ActionMedia, LANDesk, MMX, Pentium and ProShare are trademarks of Intel Corporation in the United States, other countries, or both.<br>
-        (Click <a href="http://www.intel.com/sites/corporate/tradmarx.htm">here</a> to see a complete list of Intel trademarks).</p>
-
-      	<p>UNIX is a registered trademark of The Open Group in the United States and other countries. </p>
-      	
-      	<p>Linux s the registered trademark of Linus Torvalds in the U.S. and other countries.</p>
-      	
-		<p>Android is a trademark of Google Inc.</p>
-		        
-      	<p>Other company, product, and service names may be trademarks or service marks of others.</p>
-      	<br/>
-	</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/updatemanager.php b/updatemanager.php
index 1b92c9f..03f2c3a 100644
--- a/updatemanager.php
+++ b/updatemanager.php
@@ -1,73 +1,34 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+<?php
+/**
+ * Copyright (c) 2005, 2018 Eclipse Foundation and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * Contributors:
+ *   Denis Roy (Eclipse Foundation) - Initial implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Denis Roy
-	# Date:			2005-11-07
-	#
-	# Description: Type your page comments here - these are not sent to the browser
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Eclipse Foundation Update Manager Agreement";
-	$pageKeywords	= "legal, foundation, update";
-	$pageAuthor		= "Type your name here";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	<div id="midcolumn">
-		<h1>$pageTitle</h1>
-		
-		<p>8th September, 2004</p>	
+include ($App->getProjectCommon());
 
-		<p><strong>As of February 11, 2011 this agreement was superseded by the revised <a href="epl/notice.php">Eclipse Foundation Software User Agreement</a>.</strong></p>
-		<p>The Eclipse Foundation makes available the Eclipse Update Manager 
-		(&quot;Update Manager&quot;) for the purpose of allowing users to install software, 
-		documentation, information and/or
-		other materials (collectively &quot;Downloadable Features&quot;). A Downloadable Feature 
-		is a bundle of Plug-ins and/or Fragments and related materials. This capability is provided
-		with the intent of allowing users to extend and update the functionality of Eclipse-based 
-		products. Information about packaging Downloadable Features is available at
-		<a href="http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-update-home/doc/eclipse_update_packaging.html">
-		http://dev.eclipse.org/viewcvs/index.cgi/%7Echeckout%7E/platform-update-home/doc/eclipse_update_packaging.html</a> (&quot;Specification&quot;).</p>
+$pageTitle = "Eclipse Foundation Update Manager Agreement";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("legal, foundation, update");
+$Theme->setPageAuthor("Mike Milinkovich");
 
-		<p>You may make a Downloadable Feature available on a web server (&quot;Update Server&quot;) with the intent of allowing other parties to install the Downloadable Feature using the Update Manager. By
-		providing a Downloadable Feature in such a manner and making it available in accordance with the Specification, you acknowledge your agreement to and grant all necessary rights to permit
-		the following:</p>
-		<blockquote>
-		<ol>
-			<li>A series of actions may occur (&quot;Update Process&quot;) in which a user may execute the Update Manager on a machine (&quot;Target Machine&quot;) with the intent of
-        		extending and updating the functionality of an Eclipse-based product.</li>
-   			<li>During the Update Process, the Update Manager may interact with your Update Server such that a Downloadable Feature or a portion thereof will be copied from your
-        		Update Server to the Target Machine (&quot;Downloaded&quot;) using the Update Manager.</li>
-			<li>According to the Specification, you must provide the terms and conditions that govern the use of the Downloadable Feature (&quot;Feature Update License&quot;) and such Feature Update License shall be placed on your Update Server in accordance with the Specification.  Such Feature Update License must inform the user of the terms and conditions that govern the Downloadable Feature.</li>
-			<li>The Update Manager will present the Feature Update License so that a user may read it and indicate that they agree with the terms and conditions of that
-        		license. Upon such indication of agreement by the user, the Update Manager will complete installation of the Downloadable Feature.</li>
-			<li>If you provide a Downloadable Feature (&quot;Top-Level Feature&quot;) that &quot;includes&quot; other Downloadable Features (&quot;Included Features&quot;) according to the Specification,
-        		any installation of the Top-Level Feature by the Update Manager will present only the Feature Update License for the Top-Level Feature and upon the user
-        		indicating their agreement of that license&rsquo;s terms and conditions, both the Top-Level Feature and the Included Features will be installed as described above. It is your obligation to ensure that the Feature Update License for the Top-Level Feature includes the terms and conditions that apply to any and all Included Features or tells the user where to find the Feature Update Licenses that apply to the Included Features.</li>
-		</ol>
-		</blockquote>
-	</div>
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
 
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+$Theme->setHtml($html);
+$Theme->setNav($Nav);
+$Theme->generatePage();
\ No newline at end of file
