diff --git a/assets/public/stylesheets/styles.min.css b/assets/public/stylesheets/styles.min.css
index 8121784..a4c95cd 100644
--- a/assets/public/stylesheets/styles.min.css
+++ b/assets/public/stylesheets/styles.min.css
@@ -1 +1 @@
-.transition{-webkit-transition:all 500ms ease;-moz-transition:all 500ms ease;-o-transition:all 500ms ease;transition:all 500ms ease}h1,h2{font-family:'Raleway',Arial,sans-serif;font-weight:100}.jumbotron{background-image:url(../../../images/header-bg.jpg);background-size:cover;padding:48px 0 30px}@media (max-width:767px){.jumbotron{background-position:bottom right}}.jumbotron h1,.jumbotron h2,.jumbotron p,.jumbotron li{color:#fff}.jumbotron h1{font-weight:100}.jumbotron h2{margin-bottom:20px}.jumbotron p{margin-bottom:0;font-size:14px}.jumbotron p a{font-weight:300;color:#fff}.jumbotron hr{opacity:0.6}.jumbotron .list-with-arrow{padding-left:15px;list-style:none}.jumbotron .list-with-arrow li{padding-bottom:20px}.jumbotron .list-with-arrow li:before{font-family:'FontAwesome';content:'\f054';margin:0 5px 0 -15px;color:#F7941E;font-weight:100}.projects h2{text-align:center}@media (max-width:767px){.projects h2{font-size:32px;margin:30px 0 40px}}@media (min-width:768px){.projects h2{font-size:48px;margin:60px 0 80px}}.projects h3{font-weight:bold}.projects .well{padding:0;border-radius:0;box-shadow:none;background-color:#fff}.projects .well h3{margin-top:0}@media (max-width:767px){.projects .well{text-align:center}.projects .well .col-left-box,.projects .well .col-right-box{background-color:#f2f2f2;padding:20px 0}}.projects .well .col-left-box,.projects .well .col-right-box{background-color:#f2f2f2}@media (max-width:767px){.projects .well .col-left-box,.projects .well .col-right-box{padding:20px}}@media (min-width:768px){.projects .well .col-left-box,.projects .well .col-right-box{min-height:150px;padding:40px}.projects .well .col-left-box:before,.projects .well .col-right-box:before,.projects .well .col-left-box:after,.projects .well .col-right-box:after{display:block;content:"";position:absolute;width:0;height:0}.projects .well .col-left-box:before,.projects .well .col-right-box:before{border-top:100px solid #fff;top:0}.projects .well .col-left-box:after,.projects .well .col-right-box:after{border-bottom:100px solid #fff;bottom:0}}@media (min-width:768px){.projects .well .col-left-box{text-align:left}.projects .well .col-left-box:before,.projects .well .col-left-box:after{right:0;border-left:100px solid transparent}}@media (min-width:768px){.projects .well .col-right-box{text-align:right}.projects .well .col-right-box:before,.projects .well .col-right-box:after{left:0;border-right:100px solid transparent}}.projects .well .content{padding:20px}.together{text-align:center;background-color:#e8e8e8;margin-top:40px;padding:40px 0}.together p{line-height:1.8;margin-bottom:20px}.bold{font-weight:700}.btn-border-only{background-color:transparent;border:1px solid;font-weight:300}.btn-border-only:hover,.btn-border-only:active,.btn-border-only:focus{border-color:#ccc;color:#ccc;background-color:transparent}.btn-border-only.white{border-color:#fff;-webkit-transition:all 500ms ease;-moz-transition:all 500ms ease;-o-transition:all 500ms ease;transition:all 500ms ease}.btn-border-only.white:hover{border-color:#ccc;color:#ccc}.btn-border-only.black{border-color:#858585;color:#858585;-webkit-transition:all 500ms ease;-moz-transition:all 500ms ease;-o-transition:all 500ms ease;transition:all 500ms ease}.btn-border-only.black:hover{border-color:#3B3B3B;color:#3B3B3B}@media (min-width:768px){.vertical-align.for-sm-and-up{display:flex;align-items:center}}
\ No newline at end of file
+.transition{-webkit-transition:all 500ms ease;-moz-transition:all 500ms ease;-o-transition:all 500ms ease;transition:all 500ms ease}.mars-page-content h1,.mars-page-content h2{font-family:'Raleway',Arial,sans-serif;font-weight:100}.jumbotron{background-image:url(../../../images/header-bg.jpg);background-size:cover;padding:48px 0 30px}@media (max-width:767px){.jumbotron{background-position:bottom right}}.jumbotron h1,.jumbotron h2,.jumbotron p,.jumbotron li{color:#fff}.jumbotron h1{font-weight:100}.jumbotron h2{margin-bottom:20px}.jumbotron p{margin-bottom:0;font-size:14px}.jumbotron p a{font-weight:300;color:#fff}.jumbotron hr{opacity:0.6}.jumbotron .list-with-arrow{padding-left:15px;list-style:none}.jumbotron .list-with-arrow li{padding-bottom:20px}.jumbotron .list-with-arrow li:before{font-family:'FontAwesome';content:'\f054';margin:0 5px 0 -15px;color:#F7941E;font-weight:100}.projects h2{text-align:center}@media (max-width:767px){.projects h2{font-size:32px;margin:30px 0 40px}}@media (min-width:768px){.projects h2{font-size:48px;margin:60px 0 80px}}.projects h3{font-weight:bold}.projects .well{padding:0;border-radius:0;box-shadow:none;background-color:#fff}.projects .well h3{margin-top:0}@media (max-width:767px){.projects .well{text-align:center}.projects .well .col-left-box,.projects .well .col-right-box{background-color:#f2f2f2;padding:20px 0}}.projects .well .col-left-box,.projects .well .col-right-box{background-color:#f2f2f2}@media (max-width:767px){.projects .well .col-left-box,.projects .well .col-right-box{padding:20px}}@media (min-width:768px){.projects .well .col-left-box,.projects .well .col-right-box{min-height:150px;padding:40px}.projects .well .col-left-box:before,.projects .well .col-right-box:before,.projects .well .col-left-box:after,.projects .well .col-right-box:after{display:block;content:"";position:absolute;width:0;height:0}.projects .well .col-left-box:before,.projects .well .col-right-box:before{border-top:100px solid #fff;top:0}.projects .well .col-left-box:after,.projects .well .col-right-box:after{border-bottom:100px solid #fff;bottom:0}}@media (min-width:768px){.projects .well .col-left-box{text-align:left}.projects .well .col-left-box:before,.projects .well .col-left-box:after{right:0;border-left:100px solid transparent}}@media (min-width:768px){.projects .well .col-right-box{text-align:right}.projects .well .col-right-box:before,.projects .well .col-right-box:after{left:0;border-right:100px solid transparent}}.projects .well .content{padding:20px}.together{text-align:center;background-color:#e8e8e8;margin-top:40px;padding:40px 0}.together p{line-height:1.8;margin-bottom:20px}.bold{font-weight:700}.btn-border-only{background-color:transparent;border:1px solid;font-weight:300}.btn-border-only:hover,.btn-border-only:active,.btn-border-only:focus{border-color:#ccc;color:#ccc;background-color:transparent}.btn-border-only.white{border-color:#fff;-webkit-transition:all 500ms ease;-moz-transition:all 500ms ease;-o-transition:all 500ms ease;transition:all 500ms ease}.btn-border-only.white:hover{border-color:#ccc;color:#ccc}.btn-border-only.black{border-color:#858585;color:#858585;-webkit-transition:all 500ms ease;-moz-transition:all 500ms ease;-o-transition:all 500ms ease;transition:all 500ms ease}.btn-border-only.black:hover{border-color:#3B3B3B;color:#3B3B3B}@media (min-width:768px){.vertical-align.for-sm-and-up{display:flex;align-items:center}}
\ No newline at end of file
diff --git a/assets/src/stylesheets/_mixins.less b/assets/src/stylesheets/_mixins.less
index e773b00..4e770b3 100644
--- a/assets/src/stylesheets/_mixins.less
+++ b/assets/src/stylesheets/_mixins.less
@@ -1,13 +1,8 @@
-/*******************************************************************************
- * Copyright (c) 2015 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
- *
- * Contributors:
- *    Eric Poirier (Eclipse Foundation) - Initial implementation
- *******************************************************************************/
+//
+// Mixins
+//
+// author: Eric Poirier <eric.poirier@eclipse-foundation.org>
+//-------------------------------------------------------------------
 
 .transition {
   //transition: all 0.5s ease;
diff --git a/assets/src/stylesheets/styles.less b/assets/src/stylesheets/styles.less
index 3f9f1c4..cbd07dd 100644
--- a/assets/src/stylesheets/styles.less
+++ b/assets/src/stylesheets/styles.less
@@ -1,19 +1,15 @@
-/*******************************************************************************
- * Copyright (c) 2015 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
- *
- * Contributors:
- *    Eric Poirier (Eclipse Foundation) - Initial implementation
- *******************************************************************************/
+//
+// Mars page styles
+//
+// author: Eric Poirier <eric.poirier@eclipse-foundation.org>
+//-------------------------------------------------------------------
 
 @import "_mixins.less";
-
-h1, h2{
-  font-family: 'Raleway', Arial, sans-serif;
-  font-weight:100;
+.mars-page-content {
+  h1, h2{
+    font-family: 'Raleway', Arial, sans-serif;
+    font-weight:100;
+  }
 }
 
 /* HEADER */
diff --git a/content/en_index.php b/content/en_index.php
index 2700d57..5d639a4 100644
--- a/content/en_index.php
+++ b/content/en_index.php
@@ -11,7 +11,7 @@
  *******************************************************************************/
 ?>
 
-<section class="jumbotron breadcrumbs-offset">
+<section class="jumbotron breadcrumbs-offset mars-page-content">
   <div class="container">
     <div class="content">
       <div class="alert alert-danger" role="alert">
@@ -50,7 +50,7 @@
     </div>
   </div>
 </section>
-<section class="projects">
+<section class="projects mars-page-content">
   <div class="container">
     <div class="row">
       <div class="col-md-18 col-sm-24 col-md-offset-3">
@@ -128,7 +128,7 @@
     </div>
   </div>
 </section>
-<section id="together" class="together footer-offset">
+<section id="together" class="together footer-offset mars-page-content">
   <div class="container">
     <div class="row">
       <div class="col-md-18 col-md-offset-3">
diff --git a/index.php b/index.php
index 75941a5..85f51ef 100644
--- a/index.php
+++ b/index.php
@@ -1,21 +1,20 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2015 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) 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) - Initial implementation
- *******************************************************************************/
+ *   Eric Poirier (Eclipse Foundation) - Initial implementation
+ *
+ * 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();
 
 #redirect the user if he already saw the luna landing page
 $uri = explode("/", $_SERVER['REQUEST_URI']);
@@ -29,24 +28,22 @@
   }
 }
 
-# Begin: page-specific settings.  Change these.
 $pageTitle = "Mars Eclipse";
-$pageKeywords = "eclipse Mars, release, simultaneous, release train, mars";
-$pageAuthor = "Eric Poirier";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("eclipse Mars, release, simultaneous, release train, mars");
+$Theme->setPageAuthor("Eric Poirier");
 
 // Custom theme variables
 $variables = array();
-$variables['main_container_classes'] = 'container-full';
-
-// Place your html content in a file called content/en_pagename.php
-ob_start();
-include("content/en_" . $App->getScriptName());
-$html = ob_get_clean();
-
+$variables['main_container_classes'] = 'container-full footer-offset breadcrumbs-offset padding-top';
 $App->setThemeVariables($variables);
 
-# Generate the web page
+ob_start();
+include ("content/en_" . $App->getScriptName());
+$html = ob_get_clean();
+
 $App->AddExtraHtmlHeader('<link href="//fonts.googleapis.com/css?family=Raleway:100,300,500,400,700" rel="stylesheet" type="text/css">');
 $App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/mars/assets/public/stylesheets/styles.min.css" media="screen" />');
 $App->AddExtraJSFooter('<script type="text/javascript" src="/mars/assets/public/javascript/scripts.min.js"></script>');
-$App->generatePage("solstice", $Menu, NULL, $pageAuthor, $pageKeywords, $pageTitle, $html);
+$Theme->setHtml($html);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/install/install.php b/install/install.php
index ccf3a5e..f968f72 100644
--- a/install/install.php
+++ b/install/install.php
@@ -1,39 +1,41 @@
-<?php 
-/*******************************************************************************
- * Copyright (c) 2015 Eclipse Foundation and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*    Wayne Beaton (Eclipse Foundation)- initial API and implementation
-*******************************************************************************/
-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");
+<?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:
+ *   Wayne Beaton (Eclipse Foundation)- initial API and implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-$App 	= new App();
-$Menu 	= new Menu();
-$Nav = new Nav();
-include($App->getProjectCommon());
-include( '_commonLeftNav.php' );
+$App = new App();
+$Theme = $App->getThemeClass();
+
+$pageTitle = "Install Mars";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("eclipse Mars, release, simultaneous, release train, mars");
+$Theme->setPageAuthor("Wayne Beaton");
 
 ob_start();
 ?>
 <div id="maincontent">
-	<div id="midcolumn">
-		<h1>How to Install Eclipse Mars</h1>
-		<p></p>
-		<h3>Install a Java Runtime Environment</h3>
-		<h3>Download Eclipse</h3>
-		
-		<h3>Troubleshooting</h3>
-	</div>
+  <div id="midcolumn">
+    <h1>How to Install Eclipse Mars</h1>
+    <p></p>
+    <h3>Install a Java Runtime Environment</h3>
+    <h3>Download Eclipse</h3>
+    <h3>Troubleshooting</h3>
+  </div>
 </div>
-
 <?php
 $html = ob_get_contents();
 ob_end_clean();
-$App->generatePage($theme, $Menu, NULL , $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
+
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/noteworthy/index.php b/noteworthy/index.php
index c7baf3c..f198719 100644
--- a/noteworthy/index.php
+++ b/noteworthy/index.php
@@ -1,28 +1,28 @@
-<?php 
-/*******************************************************************************
- * Copyright (c) 2015 Eclipse Foundation and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*    Wayne Beaton (Eclipse Foundation)- initial API and implementation
-*******************************************************************************/
-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");
+<?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:
+ *   Wayne Beaton (Eclipse Foundation)- initial API and implementation
+ *   Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-$App 	= new App();
-$Menu 	= new Menu();
-$Nav = new Nav();
-include($App->getProjectCommon());
-include( '_commonLeftNav.php' );
+$App = new App();
+$Theme = $App->getThemeClass();
 
 $App->AddExtraHtmlHeader('<link rel="stylesheet" href="noteworthy.css">');
 
-$pageTitle ="Eclipse Mars New and Noteworthy";
-$pageAuthor = "Wayne Beaton";
+$pageTitle = "Eclipse Mars New and Noteworthy";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("eclipse Mars, release, simultaneous, release train, mars");
+$Theme->setPageAuthor("Wayne Beaton");
 
 ob_start();
 ?>
@@ -31,9 +31,9 @@
 <?php include "noteworthy.html"; ?>
 
 </div>
-
 <?php
 $html = ob_get_contents();
 ob_end_clean();
-$App->generatePage($theme, $Menu, NULL , $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
+
+$Theme->setHtml($html);
+$Theme->generatePage();
\ No newline at end of file
diff --git a/planning/_projectCommon.php b/planning/_projectCommon.php
index dbe647a..c9d1814 100755
--- a/planning/_projectCommon.php
+++ b/planning/_projectCommon.php
@@ -1,18 +1,24 @@
 <?php
-/*******************************************************************************
- * Copyright (c) 2013 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) 2014, 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 API and implementation
- *******************************************************************************/
-$theme = "solstice";
+ * Chris Aniszczyk - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php");
+
 $App->Promotion = TRUE;
 
+$Nav = new Nav();
 $Nav->addNavSeparator("Mars", null);
 $Nav->addCustomNav("Project List", "/projects/releases/releases.php?release=mars", "_self", 2);
 $Nav->addCustomNav("Project Descriptions", "/projects/releases/descriptions.php?release=mars", "_self", 2);
-?>
+$Theme->setNav($Nav);
diff --git a/planning/index.php b/planning/index.php
index b12a13e..ec5a2d4 100644
--- a/planning/index.php
+++ b/planning/index.php
@@ -1,35 +1,49 @@
-<?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) 2014, 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:
+ * Chris Aniszczyk - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-#
-# Begin: page-specific settings.
-$pageTitle 		= "Eclipse Planning Council";
-$pageKeywords	= "Eclipse Planning Council";
-$pageAuthor		= "David Williams";
-$theme = "Nova";
-# Paste your HTML content between the markers!
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
+
+$App = new App();
+$Theme = $App->getThemeClass();
+
+include ($App->getProjectCommon());
+
+$pageTitle = "Eclipse Planning Council";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("Eclipse Planning Council");
+$Theme->setPageAuthor("David Williams");
+
+// Paste your HTML content between the markers!
 ob_start();
 ?>
-
-
-	<!-- include empty lef nav col for now -->
-	<div id="leftcol">
-	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-	</div>
-	
+<!-- include empty lef nav col for now -->
 <div id="maincontent">
-<div id="midcolumn">
-<h1><?= $pageTitle ?></h1>
-<h2>Purpose</h2>
-<p>This 'planning' directory at this URL is to hold Planning Council specific web
-pages and web apps. Most Planning Council information is available on
-the <a href="http://wiki.eclipse.org/Planning_Council">Eclipse Planning
-Council Wiki Pages</a></p>
+  <div id="midcolumn">
+    <h1><?php print $pageTitle ?></h1>
+    <h2>Purpose</h2>
+    <p>
+      This 'planning' directory at this URL is to hold Planning Council specific
+      web pages and web apps. Most Planning Council information is available on
+      the <a href="http://wiki.eclipse.org/Planning_Council">Eclipse Planning
+        Council Wiki Pages</a>
+    </p>
+  </div>
 </div>
-</div> 
-
 <?php
 $html = ob_get_contents();
 ob_end_clean();
 
-# Generate the web page
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+$Theme->setHtml($html);
+$Theme->generatePage();
diff --git a/planning/poll.php b/planning/poll.php
index 16cbec4..cc190e6 100755
--- a/planning/poll.php
+++ b/planning/poll.php
@@ -1,104 +1,91 @@
-<?php 
-//ini_set("display_errors", "true");
-//error_reporting (E_ALL);
-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();
+<?php
+/**
+ * Copyright (c) 2014, 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:
+ * Chris Aniszczyk - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-       #*****************************************************************************
-       #
-       # poll.php
-       #
-       # Author:                   Chris Aniszczyk
-       # Date:                     2014-01-28
-       #
-       # Description: Quick poll to get input for Luna +1 Sim. Release name. 
-       #
-       #
-       #****************************************************************************
-       
-       #
-       # Begin: page-specific settings.  Change these. 
-       $pageTitle           = "Community Poll Vote";
-       $pageKeywords = "Eclipse Simultaneous Release 2016";
-       $pageAuthor          = "Chris Aniszczyk";
-       $theme = "solstice";
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	   # Polls are good for 3 months!
-	   $App->usePolls();
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	   # Poll 1
-	   $Poll = new Poll(11, "Vote: What is your favorite name for the 2016 Eclipse Simultaneous Release?");
-	   $Poll->addOption(1, "Naboo"); 
-           $Poll->addOption(2, "Naiad");
-	   $Poll->addOption(3, "Nano");
-	   $Poll->addOption(4, "Narvi"); 
-	   $Poll->addOption(5, "Nash");
-	   $Poll->addOption(6, "Neo");
-	   $Poll->addOption(7, "Neptune");
-	   $Poll->addOption(8, "Newton");
-	   $Poll->addOption(9, "Nibiru");
-           $Poll->addOption(10, "Nova");
-	   # $Poll->noGraph();  # uncomment to disable bar graph
-	   $pollHTML = $Poll->getHTML();
+$pageTitle = "Community Poll Vote";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("Eclipse Simultaneous Release 2016");
+$Theme->setPageAuthor("Chris Aniszczyk");
 
-	   $Poll->requireLogin(); # no anonymous votes
+// Polls are good for 3 months!
+$App->usePolls();
 
-	       # Paste your HTML content between the markers!   
-	ob_start();
-	?>            
+// Poll 1
+$Poll = new Poll(11, "Vote: What is your favorite name for the 2016 Eclipse Simultaneous Release?");
+$Poll->addOption(1, "Naboo");
+$Poll->addOption(2, "Naiad");
+$Poll->addOption(3, "Nano");
+$Poll->addOption(4, "Narvi");
+$Poll->addOption(5, "Nash");
+$Poll->addOption(6, "Neo");
+$Poll->addOption(7, "Neptune");
+$Poll->addOption(8, "Newton");
+$Poll->addOption(9, "Nibiru");
+$Poll->addOption(10, "Nova");
+// $Poll->noGraph(); # uncomment to disable bar graph
+$pollHTML = $Poll->getHTML();
 
+$Poll->requireLogin(); // no anonymous votes
 
-	<div id="maincontent" style="width: 90%; padding: 5%;">
+// Paste your HTML content between the markers!
+ob_start();
+?>
+<div id="maincontent">
+  <h1><?php print $pageTitle ?></h1>
+  <h2>Help decide the name for the 2016 Eclipse Simultaneous Release!</h2>
+  <p>
+    There will be an Eclipse Simultaneous Release on the fourth Wednesday of
+    June, 2016. But what to call it? Please vote, for your favorite name for the
+    2016 release. Remember, the simultaneous release name is an informal <i>marketing
+      name</i>. It should be recognizable, pronounceable, relatively distinct
+    and not obvious to confuse with other software or trademarks. Be sure to
+    consider how it sounds in context, such as...
+  </p>
+  <p>
+    <i>"Hey, go download the <b>Eclipse xyz Release</b> and see all the cool
+      stuff in there!"
+    </i>
+  </p>
+  <p>
+    The following list was arrived at with input from the community (see <a
+      href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=453927"
+    >bug 453927</a>) and discussions inside the Eclipse Planning Council.
+  </p>
+  <div style="padding: 5px; margin-left: 1%; margin-right: 1%;">
+    <p>
+      Naboo: 8 %<br /> Naiad: 1 %<br /> Nano: 2 %<br /> Narvi: 3 %<br /> Nash: 2
+      %<br /> Neo: 8 %<br /> Neptune: 38 %<br /> Newton: 11 %<br /> Nibiru: 2 %<br />
+      Nova: 25 %<br /> <b>Total votes: 367</b><br />
+    </p>
+  </div>
+  <p>Thanks for your vote and your help with Eclipse! The poll is closed and
+    names are under review.</p>
+  <p>
+    <b>Note: The Planning Council reserves the right to make the final decision,
+      in case some popularly voted item is later found to be unsuitable for some
+      reason.</b></p>
+  <p>Current time: <?php echo date("d/m/y : H:i (T)", time()); ?></p>
+</div>
+<?php
+$html = ob_get_contents();
+ob_end_clean();
 
-	              <h1><?= $pageTitle ?></h1>
-	                     <h2>Help decide the name for the 2016 Eclipse Simultaneous Release!</h2>
-	
-	                     <p>There will be an Eclipse Simultaneous Release on the fourth Wednesday of
-	                     June, 2016. But what to call it? Please vote, for your favorite name for the 2016
-	                     release. Remember, the simultaneous release name is an informal <i>marketing name</i>. It
-	                     should be recognizable, pronounceable, relatively distinct and not obvious
-	                     to confuse with other software or trademarks. Be sure to
-	                     consider how it sounds in context, such as...</p>
-						
-						<p>
-	                      <i>"Hey, go download the <b>Eclipse xyz Release</b> and see all the cool stuff in there!"</i>
-						</p>
-
-	                     <p>The following list was arrived at with input from the community (see
-	                     <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=453927">bug
-	                     453927</a>) and discussions inside the Eclipse Planning Council.</p>
-
-                                    <div style="padding: 5px; margin-left: 1%; margin-right: 1%;">
-                                    
-<p>
-Naboo: 8 %<br />
-Naiad: 1 %<br />
-Nano: 2 %<br />
-Narvi: 3 %<br />
-Nash: 2 %<br />
-Neo: 8 %<br />
-Neptune: 38 %<br />
-Newton: 11 %<br />
-Nibiru: 2 %<br />
-Nova: 25 %<br />
-
-<b>Total votes: 367</b><br />
-</p>
-
-				    </div>
-<p>Thanks for your vote and your help with Eclipse! The poll is closed and names are under review.</p>  
-
-	                     <p><b>Note: The Planning Council reserves the right to make the final decision, in case some
-	                     popularly voted item is later found to be unsuitable for some reason.</b><p>
-
-	                     <p>Current time: <?php echo date("d/m/y : H:i (T)", time()); ?></p>
-
-	</div>
-
-	<?php
-	       $html = ob_get_contents();
-	       ob_end_clean();
-
-	       # Generate the web page
-	       $App->generatePage($theme, $Menu, NULL, $pageAuthor, $pageKeywords, $pageTitle, $html);
-	?>
+$Theme->setHtml($html);
+$Theme->generatePage();
 
diff --git a/planning/poll2.php b/planning/poll2.php
index 8e0fc5a..2bc0b82 100755
--- a/planning/poll2.php
+++ b/planning/poll2.php
@@ -1,93 +1,95 @@
-<?php 
-//ini_set("display_errors", "true");
-//error_reporting (E_ALL);
-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();
+<?php
+/**
+ * Copyright (c) 2014, 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:
+ * Chris Aniszczyk - Initial implementation
+ * Eric Poirier (Eclipse Foundation)
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
 
-       #*****************************************************************************
-       #
-       # poll.php
-       #
-       # Author:                   Chris Aniszczyk
-       # Date:                     2014-01-28
-       #
-       # Description: Quick poll to get input for Luna +1 Sim. Release name. 
-       #
-       #
-       #****************************************************************************
-       
-       #
-       # Begin: page-specific settings.  Change these. 
-       $pageTitle           = "Community Poll Vote";
-       $pageKeywords = "Eclipse Simultaneous Release 2016 (Vote 2)";
-       $pageAuthor          = "Chris Aniszczyk";
-       $theme = "solstice";
+require_once ($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");
 
-	   # Polls are good for 3 months!
-	   $App->usePolls();
+$App = new App();
+$Theme = $App->getThemeClass();
 
-	   # Poll 1
-	   $Poll = new Poll(12, "Vote: What is your favorite name for the 2016 Eclipse Simultaneous Release?");
-	   $Poll->addOption(1, "N"); 
-           $Poll->addOption(2, "Namaste");
-	   $Poll->addOption(3, "Nandini");
-	   $Poll->addOption(4, "Narwhal"); 
-	   $Poll->addOption(5, "Narvi");
-	   $Poll->addOption(6, "Neon");
-	   $Poll->addOption(7, "Neumond");
-	   $Poll->addOption(8, "Nickel");
-	   $Poll->addOption(9, "Nirvana");
-           $Poll->addOption(10, "Noir");
-           $Poll->addOption(11, "Nomad");
-           $Poll->addOption(12, "Number 2016");
+$pageTitle = "Community Poll Vote";
+$Theme->setPageTitle($pageTitle);
+$Theme->setPageKeywords("Eclipse Simultaneous Release 2016 (Vote 2)");
+$Theme->setPageAuthor("Chris Aniszczyk");
 
-	   # $Poll->noGraph();  # uncomment to disable bar graph
-	   $pollHTML = $Poll->getHTML();
+// Polls are good for 3 months!
+$App->usePolls();
 
-	   $Poll->requireLogin(); # no anonymous votes
+// Poll 1
+$Poll = new Poll(12, "Vote: What is your favorite name for the 2016 Eclipse Simultaneous Release?");
+$Poll->addOption(1, "N");
+$Poll->addOption(2, "Namaste");
+$Poll->addOption(3, "Nandini");
+$Poll->addOption(4, "Narwhal");
+$Poll->addOption(5, "Narvi");
+$Poll->addOption(6, "Neon");
+$Poll->addOption(7, "Neumond");
+$Poll->addOption(8, "Nickel");
+$Poll->addOption(9, "Nirvana");
+$Poll->addOption(10, "Noir");
+$Poll->addOption(11, "Nomad");
+$Poll->addOption(12, "Number 2016");
 
-	       # Paste your HTML content between the markers!   
-	ob_start();
-	?>            
+// $Poll->noGraph(); # uncomment to disable bar graph
+$pollHTML = $Poll->getHTML();
+
+$Poll->requireLogin(); // no anonymous votes
+
+// Paste your HTML content between the markers!
+ob_start();
+?>
+<div id="maincontent">
+  <h1><?php print $pageTitle ?></h1>
+  <h2>Help decide the name for the 2016 Eclipse Simultaneous Release!</h2>
+  <p>
+    There will be an Eclipse Simultaneous Release on the fourth Wednesday of
+    June, 2016. But what to call it? Please vote, for your favorite name for the
+    2016 release. Remember, the simultaneous release name is an informal <i>marketing
+      name</i>. It should be recognizable, pronounceable, relatively distinct
+    and not obvious to confuse with other software or trademarks. Be sure to
+    consider how it sounds in context, such as...
+  </p>
+  <p>
+    <i>"Hey, go download the <b>Eclipse xyz Release</b> and see all the cool
+      stuff in there!"
+    </i>
+  </p>
+  <p>
+    The following list was arrived at with input from the community (see <a
+      href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=453927"
+    >bug 453927</a>) and discussions inside the Eclipse Planning Council.
+  </p>
+  <div style="padding: 5px; margin-left: 1%; margin-right: 1%;">
+
+<?php print $pollHTML ?>
+</div>
+  <p>Thanks for your vote and your help with Eclipse!</p>
+  <p>
+    <b>Note: The Planning Council reserves the right to make the final decision,
+      in case some popularly voted item is later found to be unsuitable for some
+      reason.</b>
 
 
-	<div id="maincontent" style="width: 90%; padding: 5%;">
+  <p>
 
-	              <h1><?= $pageTitle ?></h1>
-	                     <h2>Help decide the name for the 2016 Eclipse Simultaneous Release!</h2>
-	
-	                     <p>There will be an Eclipse Simultaneous Release on the fourth Wednesday of
-	                     June, 2016. But what to call it? Please vote, for your favorite name for the 2016
-	                     release. Remember, the simultaneous release name is an informal <i>marketing name</i>. It
-	                     should be recognizable, pronounceable, relatively distinct and not obvious
-	                     to confuse with other software or trademarks. Be sure to
-	                     consider how it sounds in context, such as...</p>
-						
-						<p>
-	                      <i>"Hey, go download the <b>Eclipse xyz Release</b> and see all the cool stuff in there!"</i>
-						</p>
 
-	                     <p>The following list was arrived at with input from the community (see
-	                     <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=453927">bug
-	                     453927</a>) and discussions inside the Eclipse Planning Council.</p>
+  <p>Current time: <?php echo date("d/m/y : H:i (T)", time()); ?></p>
+</div>
+<?php
+$html = ob_get_contents();
+ob_end_clean();
 
-                                    <div style="padding: 5px; margin-left: 1%; margin-right: 1%;">
-                                    
-<?= $pollHTML ?>
-				    </div>
-<p>Thanks for your vote and your help with Eclipse!</p>  
-
-	                     <p><b>Note: The Planning Council reserves the right to make the final decision, in case some
-	                     popularly voted item is later found to be unsuitable for some reason.</b><p>
-
-	                     <p>Current time: <?php echo date("d/m/y : H:i (T)", time()); ?></p>
-
-	</div>
-
-	<?php
-	       $html = ob_get_contents();
-	       ob_end_clean();
-
-	       # Generate the web page
-	       $App->generatePage($theme, $Menu, NULL, $pageAuthor, $pageKeywords, $pageTitle, $html);
-	?>
+$Theme->setHtml($html);
+$Theme->generatePage();
 
