diff --git a/_projectCommon.php b/_projectCommon.php
index 7606319..0281aa4 100644
--- a/_projectCommon.php
+++ b/_projectCommon.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2014 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
@@ -12,30 +12,17 @@
 ********************************************************************************/
 $Nav->setLinkList(null);
 
-$PR = "gmf-runtime";
-$projectName = "GMF Runtime";
-$topLevel = "modeling/gmp";
+$projectname = "gmf-runtime";
+$projectdisplayname = "GMF Runtime";
+$modelingprojectname = "modeling";
+$topprojectname = "gmp"; 
+$shortprojectname = "gmf-runtime";
 
 $debug = (isset ($_GET["debug"]) && preg_match("/^\d+$/", $_GET["debug"]) ? $_GET["debug"] : -1);
 
-$rooturl = "http://" . $_SERVER["HTTP_HOST"] . "/$PR";
-$downurl = "http://www.eclipse.org";
-$bugurl = "https://bugs.eclipse.org";
-
-$extraprojects = array(); //components with only downloads, no info yet, "prettyname" => "directory"
-$nodownloads = array(); //components with only information, no downloads, or no builds available yet, "projectkey"
-$nonewsgroup = array(); //components without newsgroup
-$nomailinglist = array(); //components without mailinglist
-$incubating = array(); // components which are incubating
-$nomenclature = "Project"; //are we dealing with "components" or "projects"?
-
 include_once($_SERVER["DOCUMENT_ROOT"] . "/gmf-runtime/downloads/scripts.php");
 
 $regs = null;
-$projects = array("GMF Runtime" => "gmf-runtime");
-$proj = "/modeling"; // (isset($_GET["project"]) && preg_match("/^(" . join("|", $projects) . ")$/", $_GET["project"], $regs) ? $regs[1] : getProjectFromPath($PR));
-$projct= "gmf-runtime";
-
 $buildtypes = array(
 		"R" => "Release",
 		"S" => "Stable",
diff --git a/description.html b/description.html
deleted file mode 100644
index 10edabc..0000000
--- a/description.html
+++ /dev/null
@@ -1 +0,0 @@
-This project was just provisioned, so there isn't much to see here. You can find links to the propsal on this page.  Stay tuned for great things. 
\ No newline at end of file
diff --git a/downloads.php b/downloads.php
index 14a3199..4649ce1 100644
--- a/downloads.php
+++ b/downloads.php
@@ -1,6 +1,6 @@
 <?php  																														
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2014 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
@@ -34,14 +34,13 @@
 	<li>Releases: <a href="http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/releases/">http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/releases/</a></li>
 	<li>Milestones: <a href="http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/milestones/">http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/milestones/</a></li>
 	<li>Integration: <a href="http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/interim/">http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/interim/</a></li>
-	<li>Maintenance: <a href="http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/maintenance/">http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/maintenance/</a></li>
 </ul>
 
 <h3>Downloadable P2 Repositories and SDK dropins</h3>
 <p>If you prefer an update-site or an SDK archive, you can download it from <a href="downloads/index.php">here directly</a>.</p>
 
 <h3>Nightly Builds</h3>
-<p>The nightly builds can also be used as a P2 repository. The nightly builds for the Kepler simultanious release can be accessed from <a href="https://hudson.eclipse.org/hudson/job/gmf-runtime-kepler/">Hudson</a>.</p>
+<p>The nightly builds can also be used as a P2 repository. The nightly builds for the Luna simultaneous release can be accessed from <a href="https://hudson.eclipse.org/gmf-runtime/job/gmf-runtime-master/">Hudson</a>.</p>
 
 <h3>Translations</h3>
 <p>Translations packages can be downloaded from the <a href="http://www.eclipse.org/babel/downloads.php">Babel project downloads page</a>.</p>
diff --git a/downloads/downloads-common.php b/downloads/downloads-common.php
index 79646f4..5d8d01e 100644
--- a/downloads/downloads-common.php
+++ b/downloads/downloads-common.php
@@ -1,6 +1,6 @@
 <?php
 /******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -14,71 +14,39 @@
 	"eclipse" => "<a href=\"http://www.eclipse.org/eclipse/\">Eclipse</a>",
 );
 
-require_once($_SERVER["DOCUMENT_ROOT"] . "/gmf-runtime/downloads/downloads-scripts.php");
+require_once($_SERVER["DOCUMENT_ROOT"] . "/$projectname/downloads/downloads-scripts.php");
 
-if (is_array($projects))
+$numzips = 0;
+if (isset($dls[$shortprojectname]) && is_array($dls[$shortprojectname]))
 {
-	$projectArray = getProjectArray($projects, $extraprojects, $nodownloads, $PR);
-	$proj = "/" . (isset($_GET["project"]) && preg_match("/^(?:" . join("|", $projects) . ")$/", $_GET["project"]) ? $_GET["project"] :	""); # default
-}
-else
-{
-	$proj = "";
-}
-
-$proj = $PR;
-$projct = $PR;
-if (strstr($PR, "/") !== false)
-{
-	list($topProj, $parentProj) = explode("/", $PR); # modeling, emf
-}
-else
-{
-	list($topProj, $parentProj) = array("NONE", $PR); # NONE, gef
-}
-
-if (isset($projct) && isset($hasmoved) && is_array($hasmoved) && array_key_exists($projct,$hasmoved))
-{
-	header("Location: http://www.eclipse.org/modeling/" . $hasmoved[$projct] . "/downloads/?" . $_SERVER["QUERY_STRING"]);
-	exit;
-}
-
-$numzips = isset($extraZips) ? 0 - sizeof($extraZips) : 0; // if extra zips (new zips added later), reduce the "required" count when testing a build
-if (isset($dls[$proj]) && is_array($dls[$proj]))
-{
-	foreach (array_keys($dls[$proj]) as $z)
+	foreach (array_keys($dls[$shortprojectname]) as $z)
 	{
-		$numzips += sizeof($dls[$proj][$z]);
+		$numzips += sizeof($dls[$shortprojectname][$z]);
 	}
 }
 
 # store an array of paths to hide
-$hiddenBuilds = is_readable($_SERVER["DOCUMENT_ROOT"] . "/$PR/downloads/hidden.txt") ? file($_SERVER["DOCUMENT_ROOT"] . "/$PR/downloads/hidden.txt") : array();
+$hiddenBuilds = is_readable($_SERVER["DOCUMENT_ROOT"] . "/$projectname/downloads/hidden.txt") ? file($_SERVER["DOCUMENT_ROOT"] . "/$projectname/downloads/hidden.txt") : array();
 
-// include extras-$proj.php or extras-$PR.php
-$files = array ($_SERVER["DOCUMENT_ROOT"] . "/$PR/downloads/extras-" . $projct . ".php", $_SERVER["DOCUMENT_ROOT"] . "/$PR/downloads/extras-" . $PR . ".php");
-foreach ($files as $file)
+// include extras-$projectname.php
+$extras = $_SERVER["DOCUMENT_ROOT"] . "/$projectname/downloads/extras-$projectname.php";
+if (file_exists($extras))
 {
-	if (file_exists($file))
-	{
-		include_once($file);
-		break;
-	}
+	include_once($extras);
 }
 
 $hadLoadDirSimpleError = 1; //have we echoed the loadDirSimple() error msg yet? if 1, omit error; if 0, echo at most 1 error
 $sortBy = (isset($_GET["sortBy"]) && preg_match("/^(date)$/", $_GET["sortBy"], $regs) ? $regs[1] : "");
 $showAll = (isset($_GET["showAll"]) && preg_match("/^(1)$/", $_GET["showAll"], $regs) ? $regs[1] : "0");
 $showMax = (isset($_GET["showMax"]) && preg_match("/^(\d+)$/", $_GET["showMax"], $regs) ? $regs[1] : ($sortBy == "date" ? "10" : "5"));
-$showBuildResults = !isset($_GET["light"]) && !isset($_GET["nostatus"]); // suppress display of status to render page faster
 
-$PWD = "/home/data2/httpd/download.eclipse.org/$topLevel/$PR/downloads/drops";
+$PWD = "/home/data2/httpd/download.eclipse.org//$modelingprojectname/$topprojectname/$projectname/downloads/drops";
 
 $downloadScript = getdownloadScript();
 $downloadPre = "";
 
 print "<div id=\"midcolumn\">\n";
-print "<h2>GMF Runtime P2 Repositories & SDK Dropins</h2>\n";
+print "<h2>$projectdisplayname P2 Repositories & SDK Dropins</h2>\n";
 print "<p>This page provides a bundled P2 repository and different SDK dropins (in runnable form) for each build.</p>";
 
 $branches = loadDirSimple($PWD, ".*", "d");
@@ -104,7 +72,7 @@
 {
 	print "<h2>Builds</h2>\n";
 	print "<ul>\n";
-	if (is_array($projectArray) && !in_array($projct, $projectArray))
+	if (is_array($projectArray) && !in_array($shortprojectname, $projectArray))
 	{
 		print "<li><i><b>Sorry!</b></i> There are no builds yet available for this component.</li>";
 	}
diff --git a/downloads/downloads-scripts.php b/downloads/downloads-scripts.php
index 20fcc38..5e3d6d5 100644
--- a/downloads/downloads-scripts.php
+++ b/downloads/downloads-scripts.php
@@ -1,6 +1,6 @@
 <?php
 /******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -144,7 +144,7 @@
 
 function createFileLinks($dls, $PWD, $branch, $ID, $pre2, $filePreProj, $ziplabel = "") // the new way - use a ziplabel pregen'd from a dir list!
 {
-	global $PR, $suf, $proj, $projct, $filePreStatic, $extraZips, $projects, $showBuildResults;
+	global $projectname, $suf, $modelingprojectname, $shortprojectname, $filePreStatic;
 	$uu = 0;
 
 	if (!$ziplabel)
@@ -155,320 +155,86 @@
 
 	$cnt=-1; // for use with static prefix list
 
-	if (!isset($dls[$proj]) && isset($dls["/"]))
-	{
-		$dls[$proj] = $dls["/"];
-	}
-	if (!isset($dls[$proj]))
-	{
-		// set default
-		$flip = array_flip($projects);
-		$dls[$proj] = array($flip[$projct] => array(
-				"<acronym title=\"Archived Update Site\"><img alt=\"Click to download archived All-In-One p2 Repo Update Site\" src=\"/modeling/images/dl-icon-update-zip.gif\"/> <b style=\"color:green\">All-In-One Update Site</b></acronym>" => "gmf-runtime-Update",
-				"SDK (Runtime, Source)" => "gmf-sdk-runtime",
-				"Runtime" => "gmf-runtime",
-				"Automated Tests" => "gmf-tests-runtime"
-		));
-	}
-
 	$echo_out_all = "";
 
-	if (!$showBuildResults)
+	foreach (array_keys($dls[$shortprojectname]) as $z)
 	{
-		foreach (array_keys($dls[$proj]) as $z)
+		$echo_out = "";
+		foreach ($dls[$shortprojectname][$z] as $label => $u)
 		{
-			$echo_out_all .= "<li class=\"separator\"><img src=\"/modeling/images/dl.gif\" alt=\"Download\"/> " . fileFound("$PWD/", "$branch/$ID/", "$z Build Artifacts") . "</li>\n";
-			break;
+			$cnt++;
+			if (!is_array($u))
+			{
+				$u = $u ? array("$u") : array("");
+			}
+
+			// support a page with three different valid prefixes which can
+			// overlap when searched using dynamic check below
+			if ($filePreStatic && is_array($filePreStatic) && array_key_exists($modelingprojectname,$filePreStatic))
+			{
+				$filePreProj = array($filePreStatic[$modelingprojectname][$cnt]); // just one value to check
+			}
+
+			$tries = array();
+			foreach ($u as $ux)
+			{
+				foreach ($filePreProj as $filePre)
+				{ 
+					$tries[] = "$branch/$ID/$pre2$filePre$ux-$ziplabel.zip"; 
+					$tries[] = "$branch/$ID/$filePre$ux-$ziplabel.zip"; 
+					$tries[] = "$branch/$ID/$pre2$filePre$ux-incubation-$ziplabel.zip"; 
+					$tries[] = "$branch/$ID/$filePre$ux-incubation-$ziplabel.zip"; 
+					$tries[] = "$branch/$ID/$ux-$ziplabel.zip"; 
+				}
+			}
+			$outNotFound = "<i><b>$pre2</b>$filePre";
+			if (sizeof($u) > 1 ) {
+				$outNotFound .= "</i>{"; foreach ($u as $ui => $ux) {
+					$outNotFound .= ($ui>0 ? "," : "") . $ux;
+				} $outNotFound .= "}<i>";
+			}
+			else
+			{
+				$outNotFound .= $u[0];
+			}
+			$outNotFound .= "-$ziplabel ...</i>";
+			$out = "";
+			foreach ($tries as $y)
+			{
+				if (is_file("$PWD/$y"))
+				{
+					$out = fileFound("$PWD/", $y, $label);
+					break;
+				}
+			}
+			if ($out)
+			{
+				$echo_out .= "<li class=\"separator\">\n";
+				$echo_out .= $out;
+				$echo_out .= "</li>\n";
+			}
+			else if (!isset($extraZips) || !is_array($extraZips) || !in_array($filePre . $u[0],$extraZips)) // $extraZips defined in downloads/index.php if necessary
+			{
+				$echo_out .= "<li>\n";
+				$echo_out .= $outNotFound;
+				$echo_out .= "</li>\n";
+			}
+			$uu++;
 		}
-	}
-	else
-	{
-		foreach (array_keys($dls[$proj]) as $z)
+		if ($echo_out) // if the whole category is empty, don't show it (eg., GEF)
 		{
-			$echo_out = "";
-			foreach ($dls[$proj][$z] as $label => $u)
-			{
-				$cnt++;
-				if (!is_array($u)) // for compatibilty with uml2, where there's no "RT" value in $u
-				{
-					$u = $u ? array("$u") : array("");
-				}
-
-				// support EMF page with three different valid prefixes which can
-				// overlap when searched using dynamic check below
-				if ($filePreStatic && is_array($filePreStatic) && array_key_exists($proj,$filePreStatic))
-				{
-					$filePreProj = array($filePreStatic[$proj][$cnt]); // just one value to check
-				}
-
-				$tries = array();
-				foreach ($u as $ux)
-				{
-					foreach ($filePreProj as $filePre)
-					{ 
-						$tries[] = "$branch/$ID/$pre2$filePre$ux-$ziplabel.zip"; // for compatibilty with uml2, where there's no "runtime" value in $ux
-						$tries[] = "$branch/$ID/$filePre$ux-$ziplabel.zip"; // for compatibilty with uml2, where there's no "runtime" value in $ux
-						$tries[] = "$branch/$ID/$pre2$filePre$ux-incubation-$ziplabel.zip"; // for compatibilty with uml2, where there's no "runtime" value in $ux
-						$tries[] = "$branch/$ID/$filePre$ux-incubation-$ziplabel.zip"; // for compatibilty with uml2, where there's no "runtime" value in $ux
-						$tries[] = "$branch/$ID/$ux-$ziplabel.zip"; // for compatibilty with uml2, where there's no "runtime" value in $ux
-					}
-				}
-				$outNotFound = "<i><b>$pre2</b>$filePre";
-				if (sizeof($u) > 1 ) {
-					$outNotFound .= "</i>{"; foreach ($u as $ui => $ux) {
-						$outNotFound .= ($ui>0 ? "," : "") . $ux;
-					} $outNotFound .= "}<i>";
-				}
-				else
-				{
-					$outNotFound .= $u[0];
-				}
-				$outNotFound .= "-$ziplabel ...</i>";
-				$out = "";
-				foreach ($tries as $y)
-				{
-					if (is_file("$PWD/$y"))
-					{
-						$out = fileFound("$PWD/", $y, $label);
-						break;
-					}
-				}
-				if ($out)
-				{
-					$echo_out .= "<li class=\"separator\">\n";
-					$echo_out .= $out;
-					$echo_out .= "</li>\n";
-				}
-				else if (!isset($extraZips) || !is_array($extraZips) || !in_array($filePre . $u[0],$extraZips)) // $extraZips defined in downloads/index.php if necessary
-				{
-					$echo_out .= "<li>\n";
-					$echo_out .= $outNotFound;
-					$echo_out .= "</li>\n";
-				}
-				$uu++;
-			}
-			if ($echo_out) // if the whole category is empty, don't show it (eg., GEF)
-			{
-				$echo_out_all .= "<li><img src=\"/modeling/images/dl.gif\" alt=\"Download\"/> $z\n<ul>\n" . $echo_out . "</ul>\n</li>\n";
-			}
+			$echo_out_all .= "<li><img src=\"/$projectname/images/dl.gif\" alt=\"Download\"/> $z\n<ul>\n" . $echo_out . "</ul>\n</li>\n";
 		}
 	}
 	return $echo_out_all;
 }
 
-/* if $styled = 0 or false, return text only */
-function showBuildResults($PWD, $path, $styled=1) // given path to /../downloads/drops/M200402021234/
-{
-	global $downloadPre, $pre, $numzips, $PR, $projct;
-	$mid = "$downloadPre/$PR" . ($projct == "" ? $projct : "/$projct") . "/downloads/drops/";
-	$out = "";
-	$buildlog = "$PWD${path}buildlog.txt";
-	$buildlog_cache = null;
-	clearstatcache();
-
-	$warnings = 0;
-	$errors = 0;
-	$failures = 0;
-	$didnotruns = 0;
-
-	$result = "";
-	$icon = "";
-
-	$indexHTML = "";
-	$compilelogSummary = "";
-
-	$link = "";
-	$link2 = "";
-
-	$ID = substr($path, -14);
-
-	if (!$icon && (is_file("$PWD${path}index.html") || is_file("$PWD${path}index.php")))
-	{
-		$indexHTML = is_file("$PWD${path}index.html") ? file_get_contents("$PWD${path}index.html") : "";
-		$zips = loadDirSimple($PWD . $path, "(\.zip|\.tar\.gz)", "f"); // get files count
-		$md5s = is_dir($PWD . $path . "/checksum") ? loadDirSimple($PWD . $path . "/checksum", "(\.zip\.md5|\.tar\.gz\.md5)", "f") :
-		loadDirSimple($PWD . $path, "(\.zip\.md5|\.tar\.gz\.md5)", "f"); // get files count
-
-		if ((sizeof($zips) >= $numzips && sizeof($md5s) >= $numzips))
-		{
-			//check testresults/chkpii/ for results
-			if (is_file("$PWD${path}testresults/chkpii/org.eclipse.nls.summary.txt"))
-			{
-				$chkpiiResults = file_get_contents("$PWD${path}testresults/chkpii/org.eclipse.nls.summary.txt");
-				// eg, file contains:
-				//htm: 6 E, 0 W
-				//xml: 1 E, 1 W
-				//properties: 0 E, 2 W
-				$regs = null;
-				preg_match_all("/^\S+: (\d+) E, (\d+) W$/m", $chkpiiResults, $regs);
-				for ($i = 0; $i < sizeof($regs[0]); $i++)
-				{
-					$errors += $regs[1][$i];
-					$warnings += $regs[2][$i];
-					$icon = "not";
-					$link = "$pre$mid${path}testresults/chkpii/";
-					$link2 = "$pre$mid${path}testresults/chkpii/";
-				}
-			}
-
-			// check JUnit results
-			$files = loadDirSimple("$PWD${path}testresults/xml/", ".xml", "f");
-			$out = "";
-			$noProblems = true;
-			foreach ($files as $file)
-			{
-				$results = getTestResultsJUnitXML("$PWD${path}testresults/xml/" . $file);
-				if ($results && is_array($results))
-				{
-					$errors += $results[0];
-					$failures += $results[1];
-					$didnotruns += $results[2];
-					$icon = "not";
-					$results = null;
-				}
-			}
-
-			//check compilelogs/summary.txt for results
-			if (is_file("$PWD${path}compilelogs/summary.txt"))
-			{
-				$compilelogSummary = file_get_contents("$PWD${path}compilelogs/summary.txt");
-				$link2 = "http://www.eclipse.org/$PR/downloads/testResults.php?hl=1&amp;project=$projct&amp;ID=" . substr($path, 0, strlen($path) - 1);
-				if ($compilelogSummary)
-				{
-					$m = null;
-					if (preg_match("/(\d+)P, (\d+)W, (\d+)E, (\d+)F/", $compilelogSummary, $m))
-					{
-						$warnings += $m[2];
-						$errors += $m[3];
-						$failures += $m[4];
-					}
-				}
-			}
-
-			if ($errors)
-			{
-				$icon = "not";
-				$result = "ERROR";
-			}
-			else if ($didnotruns)
-			{
-				$icon = "not";
-				$result = "CAUTION";
-			}
-			else
-			{
-				$icon = ($warnings ? "check-maybe" : "check");
-				$result = "";
-			}
-
-			//parse out the check/fail icons in index.html, if we haven't failed already
-			if ($icon != "not" && $indexHTML)
-			{
-				if (preg_match("/<font size=\"-1\" color=\"#FF0000\">skipped<\/font>/", $indexHTML))
-				{
-					$icon = "check-maybe";
-					$result = "Skipped ";
-				}
-				else if (preg_match("/(?:<!-- Examples -->.*FAIL\.gif|FAIL\.gif.*<!-- Automated Tests -->)/s", $indexHTML))
-				{
-					$icon = "not";
-					$result = "FAILED ";
-				}
-				else if (preg_match("/<!-- Automated Tests -->.*FAIL\.gif.*<!-- Examples -->/s", $indexHTML))
-				{
-					$icon = "check-tests-failed";
-					$result = "TESTS FAILED ";
-				}
-			}
-		}
-	}
-
-	if (!$icon)
-	{
-		// display in progress icon & link to log
-		$result = "...";
-		$icon = "question";
-	}
-
-	clearstatcache();
-
-	if (!$result && !is_dir("$PWD${path}testresults/xml/"))
-	{
-		$result = "Skipped ";
-		$icon = "check-maybe";
-	}
-
-	if (!$link) // return a string with icon, result, and counts (if applic)
-	{
-		$link = "http://download.eclipse.org/" . $mid . $path . "buildlog.txt";
-	}
-
-	if (!$link2) // link to console log in progress if it exists
-	{
-		$ID = substr($path, -14);
-		$conlog = "${path}testing/${ID}testing/linux.gtk_consolelog.txt";
-		$testlog = "http://www.eclipse.org/$PR/downloads/testResults.php?hl=1&amp;project=$projct&amp;ID=" . substr($path, 0, strlen($path) - 1);
-		$link2 = (is_file("$PWD$conlog") ? "$mid$conlog" : (is_file("$PWD$testlog") ? "$testlog" : $link));
-		$result = (is_file("$PWD$conlog") ? "Testing..." : $result);
-	}
-
-	if ($styled)
-	{
-		$out .= "<a " .
-			(preg_match("/FAIL|CAUTION|ERROR/", $result) || $didnotruns > 0 || $errors > 0 || $failures > 0 ? "class=\"fail\" " :
-					(preg_match("/Testing|Stalled|Skipped/",$result) || $warnings > 0 ? "class=\"warning\" " :
-							"class=\"success\" ") ) .
-							"href=\"$link2\">$result";
-	}
-	else
-	{
-		$out .= (preg_match("/FAIL|CAUTION|ERROR/", $result) || $didnotruns > 0 || $errors > 0 || $failures > 0 ? "FAILURE / " :
-			(preg_match("/Testing|Stalled|Skipped/",$result) || $warnings > 0 ? "WARNING / " :
-					"SUCCESS / ") ) .
-					"$result";
-	}
-	if ($errors == 0 && $failures == 0 && $warnings == 0 && !$result)
-	{
-		$out .= "OK";
-	}
-	else
-	{
-		$out  .= ($result && $result != "..."  && $result != "Skipped" ? ": " : "");
-		$out2  = "";
-		$out2 .= ($didnotruns > 0 ? "$didnotruns D N R, " : "");
-		$out2 .= ($errors > 0 ? "$errors E, " : "");
-		$out2 .= ($failures > 0 ? "$failures F, " : "");
-		$out2 .= ($warnings > 0 ? "$warnings W" : "");
-		$out  .= preg_replace("/^(.+), $/","$1",$out2);
-	}
-	if ($styled)
-	{
-		$out .= "</a> <a href=\"$link\"><img src=\"/modeling/images/$icon.gif\" alt=\"$icon\"/></a>";
-	}
-
-	$replacements = array(
-		"SUCCESS / Success" => "SUCCESS",
-		"SUCCESS / ..." => "UNKNOWN",
-		"FAILURE / FAILED: " => "FAILED"
-	);
-	foreach ($replacements as $match => $replace)
-	{
-		if ($out == $match) $out = $replace;
-	}
-
-	return array(
-		$out,
-		$link2,
-		$link
-	);
-}
-
 function fileFound($PWD, $url, $label, $md5AlignRight = true, $icon = null)
 {
-	global $downloadScript, $downloadPre, $PR, $proj;
+	global $downloadScript, $downloadPre, $projectname, $modelingprojectname, $topprojectname, $shortprojectname;
 
 	$out = "";
-	$mid = "$downloadPre/$topLevel/$proj/downloads/drops/"; 
+	$mid = "$downloadPre/$modelingprojectname/$topprojectname/$shortprojectname/downloads/drops/"; 
 	$md5files = array("$url.md5", preg_replace("#/([^/]+$)#", "/checksum/$1", $url) . ".md5");
 	foreach ($md5files as $md5file)
 	{
@@ -485,13 +251,13 @@
 
 function doNLSLinksList($packs, $cols, $subcols, $packSuf, $folder, $isArchive = false)
 {
-	global $downloadScript, $downloadPre, $PR, $proj, $projct;
+	global $downloadScript, $downloadPre, $projectname, $modelingprojectname, $shortprojectname;
 
 	foreach ($packs as $name => $packPre)
 	{
 		foreach ($cols as $alt => $packMid)
 		{
-			print "<li><img src=\"/modeling/images/dl.gif\" alt=\"$alt\"/> $alt: ";
+			print "<li><img src=\"/$projectname/images/dl.gif\" alt=\"$alt\"/> $alt: ";
 			$ret = array();
 			if (sizeof($subcols) > 2)
 			{
@@ -505,7 +271,7 @@
 						$ret = array();
 					}
 					$ret[] = "<a href=\"" . ($isArchive ? "http://archive.eclipse.org" : $downloadScript) .
-					"$downloadPre/$PR$proj/downloads/drops/$folder$packPre$packMid-$packMid2$packSuf\">$alt2</a>";
+					"$downloadPre/$projectname/$modelingprojectname/downloads/drops/$folder$packPre$packMid-$packMid2$packSuf\">$alt2</a>";
 					$cnt++;
 				}
 				if (sizeof($ret) > 0)
@@ -519,7 +285,7 @@
 				foreach ($subcols as $alt2 => $packMid2)
 				{
 					$ret[] = "<a href=\"" . ($isArchive ? "http://archive.eclipse.org" : $downloadScript) .
-					"$downloadPre/$PR$proj/downloads/drops/$folder$packPre$packMid-$packMid2$packSuf\">$alt2</a>";
+					"$downloadPre/$projectname/$modelingprojectname/downloads/drops/$folder$packPre$packMid-$packMid2$packSuf\">$alt2</a>";
 				}
 				print join(", ", $ret);
 			}
@@ -564,97 +330,15 @@
 	return $filec;
 }
 
-/* if $styled = 0 or false, return text only */
-function getExtraTestsResults($branch, $ID, $styled=1)
-{
-	global $jdk14testsPWD, $jdk50testsPWD, $jdk60testsPWD, $testsPWD;
-	$tests = "";
-	$s = array(0 => "");
-	$t = array(0 => "");
-	return array($s, $t, $tests);
-}
-
-function toPlainTextSummaries($summary)
-{
-	global $debug, $PR, $projct;
-	if ($debug > 0) print htmlspecialchars($summary)."<br/>";
-
-	$miniSummary  = "";
-	$textSummary  = "";
-	// <a href="/modeling/emf/build/log-viewer.php?jdk50test=2.2.4/R200710030400/200710030422/" class="warning">511 W, 3 D</a>
-	// <a href="/modeling/emf/build/log-viewer.php?jdk50test=2.2.4/R200710030400/200710030422/"><img src="/modeling/images/check.gif" alt="OK"/></a>
-	// <a href="/modeling/emf/build/log-viewer.php?jdk50test=2.4.0/N200712241351/200712241410/">...</a>
-	$pattern = "#<a href=\"[^\"]+\?([^\"]+)=([^\"]+)\"(| class=\"[^\"]+\")>([^<]+)</a>#";
-	preg_match_all($pattern, $summary, $out, PREG_SET_ORDER);
-	/* [1] => jdk50test
-	 [2] => /modeling/emf/build/log-viewer.php?jdk50test=2.2.4/R200710030400/200710030422/
-	[4] => 511 W, 3 D
-	*/
-	if (sizeof($out) > 0)
-	{
-		if ($debug > 0) {
-			print "\n-------1-------\n<br/><pre>"; print_r($out); print "</pre><br/>\n";
-		}
-		foreach ($out as $set)
-		{
-			$url = "http://" . $_SERVER["SERVER_NAME"] . "/" . $PR . "/" . $projct . "/" . $set[1] . "s/" . $set[2] . "testlog.txt";
-			$miniSummary .= " [" . strtoupper(str_replace("test", "", $set[1])) . ": " . $set[4] . "]";
-			$textSummary .= strtoupper(str_replace("test", "", $set[1])) . " Test (" . $set[4] . ")\t" . $url . "\n";
-		}
-	}
-
-	$patterns = array(
-			// <a href="../../../modeling/emf/tests/2.2.4/R200710030400/200710030422/results/svt.html"><img src="/modeling/images/check.gif" alt="OK"/></a>
-			"#<a href=\"([^\"]+/results/([^\"]+).html)\"><img src=\"[^\"]+/images/[^\"]+.gif\" alt=\"([^\"]+)\"\/></a>#",
-
-			// <a href="../../../modeling/emf/tests/2.2.4/R200710030400/200710030432/results/svt.html" class="fail">1 F</a>
-			"#<a href=\"([^\"]+/results/([^\"]+).html)\" class=\"[^\"]+\">([^\<]+)</a>#",
-	);
-
-	$failedPattern =
-	// <a href="../../../modeling/emf/tests/2.4.0/N200712241351/200712241410/testlog.txt"><img src="/modeling/images/not.gif" alt="FAILED"/></a>
-	"#<a href=\"([^\"]+/modeling/emf/(tests)/[^\"]+)\"><img src=\"[^\"]+/images/[^\"]+.gif\" alt=\"([^\"]+)\"\/></a>#"
-			;
-
-			$foundURLs = array();
-			foreach ($patterns as $pattern)
-			{
-				$set = null;
-				$out = array();
-				$outFail = array();
-				preg_match_all($pattern, $summary, $out, PREG_SET_ORDER);
-				preg_match_all($failedPattern, $summary, $outFail, PREG_SET_ORDER);
-				/* [1] => ../../../modeling/emf/tests/2.2.4/R200710030400/200710030422/results/bvt.html
-				 [2] => bvt
-				[3] => OK
-				*/
-				$sets = sizeof($out) > 0 ? $out : $outFail;
-				if ($debug > 0) {
-					print "\n-------2-------\n<br/><pre>"; print_r($sets); print "</pre><br/>\n";
-				}
-				foreach ($sets as $set)
-				{
-					if (!in_array($set[1], $foundURLs)) {
-						$foundURLs[] = $set[1];
-						$url = str_replace("../../..", "http://" . $_SERVER["SERVER_NAME"], $set[1]);
-						$miniSummary .= " [" . strtoupper($set[2]) . ": " . $set[3] . "]";
-						$textSummary .= strtoupper($set[2]) . " Test (" . $set[3] . ")\t" . $url . "\n";
-					}
-				}
-			}
-
-			return array($miniSummary,$textSummary);
-}
-
 function outputBuild($branch, $ID, $c)
 {
-	global $PWD, $dls, $filePre, $proj, $showBuildResults, $sortBy, $projct, $jdk14testsPWD, $jdk50testsPWD, $jdk60testsPWD, $testsPWD, $deps, $PR, $hiddenBuilds;
+	global $PWD, $dls, $filePre, $modelingprojectname, $sortBy, $shortprojectname, $jdk14testsPWD, $jdk50testsPWD, $jdk60testsPWD, $testsPWD, $deps, $projectname, $hiddenBuilds;
 
 	# suppress hidden builds for public server
 	foreach ($hiddenBuilds as $hb) {
-		if (trim($hb) == "$PR/$branch/$ID")
+		if (trim($hb) == "$projectname/$branch/$ID")
 		{
-			debug("Build $PR/$branch/$ID is hidden, pending mirror replication.", 1);
+			debug("Build $projectname/$branch/$ID is hidden, pending mirror replication.", 1);
 			return "";
 		}
 	}
@@ -667,12 +351,7 @@
 	// generalize for any relabelled build, thus 2.0.1/M200405061234/*-2.0.2.zip is possible; label = 2.0.2
 	$IDlabel = $ziplabel;
 
-	$opts = loadBuildConfig("$PWD/$branch/$ID/build.cfg", $deps);
-
 	$ret = "<li>\n";
-	$buildResults = $showBuildResults ? showBuildResults("$PWD/", "$branch/$ID/") && !isset($opts["hudson.job.url"]) : array("");
-	$extraTestsResults = $showBuildResults ? getExtraTestsResults($branch, $ID) : array(array(), "", "");
-	$ret .= "<div>" . $buildResults[0] .  join("", preg_replace("/^(.+)$/", "<span>$1</span>", $extraTestsResults[0])) . "</div>";
 	$ret .= "<a href=\"javascript:toggle('r$ID')\">" .
 	"<i>" . ($sortBy == "date" && $IDlabel != $branch ? "$branch / " : "") . "$IDlabel</i> " .
 	"(" . IDtoDateStamp($ID, 2) . ")" .
@@ -680,127 +359,45 @@
 	"<a name=\"$ID\"></a> " .
 	"<a href=\"?showAll=1&amp;hlbuild=$ID" .
 	($sortBy == "date" ? "&amp;sortBy=date" : "") .
-	"&amp;project=$projct#$ID\">" .
-	"<img alt=\"Link to this build\" src=\"/modeling/images/link.png\"/>" .
+	"&amp;project=$shortprojectname#$ID\">" .
+	"<img alt=\"Link to this build\" src=\"/$projectname/images/link.png\"/>" .
 	"</a>" .
 	((isset($opts["noclean"]) && $opts["noclean"]) || is_dir("$PWD/$branch/$ID/eclipse/$ID") ? doNoclean("$PWD/$branch/$ID") : "");
 
 	$ret .= "<ul id=\"r$ID\"" . (($c == 0 && !isset($_GET["hlbuild"])) || isset($_GET["hlbuild"]) && $ID == $_GET["hlbuild"] ? "" : " style=\"display: none\"") . ">\n";
 
-	if (!isset($filePre[$proj]) && isset($filePre["/"]))
+	if (!isset($filePre[$modelingprojectname]) && isset($filePre["/"]))
 	{
-		$filePre[$proj] = $filePre["/"];
+		$filePre[$modelingprojectname] = $filePre["/"];
 	}
-	if (!isset($filePre[$proj]))
+	if (!isset($filePre[$modelingprojectname]))
 	{
-		$topProj = preg_replace("#.+/(.+)#","$1", $PR);
-		$filePre[$proj] = array($projct);
+		$topProj = preg_replace("#.+/(.+)#","$1", $projectname);
+		$filePre[$modelingprojectname] = array($shortprojectname);
 	}
 	
-	$ret .= createFileLinks($dls, $PWD, $branch, $ID, $pre2, $filePre[$proj], $ziplabel);
+	$ret .= createFileLinks($dls, $PWD, $branch, $ID, $pre2, $filePre[$modelingprojectname], $ziplabel);
 
-	$ret .= $extraTestsResults[2];
-	$ret .= getBuildArtifacts("$PWD", "$branch/$ID");
 	$ret .= "</ul>\n";
 	$ret .= "</li>\n";
 
 	return $ret;
 }
 
-function doNoclean($dir)
-{
-	global $PR,$projct;
-	$sizeondisk = pretty_size(dirsize($dir));
-	$versionAndBuildID = explode("/",$dir); $versionAndBuildID = $versionAndBuildID[sizeof($versionAndBuildID) - 2] . "/" . $versionAndBuildID[sizeof($versionAndBuildID) - 1];
-	return " <a href=\"/$PR/$projct/build/clean.php?versionAndBuildID=$versionAndBuildID\"><span class=\"noclean\"><acronym title=\"Failed builds do not purge temp files automatically -- click here to do so!\">Size on disk: $sizeondisk</acronym></span>" .
-	" <img alt=\"Purge releng materials before promoting this build!\" src=\"/modeling/images/bug.png\"/></a>";
-}
-
-function loadBuildConfig($file, $deps)
-{
-	$lines = (is_file($file) && is_readable($file) ? file($file) : array());
-
-	$opts = array();
-	foreach ($lines as $z)
-	{
-		$regs = null;
-		// Modeling build style
-		if (preg_match("/^((?:" . join("|", array_keys($deps)) . ")(?:DownloadURL|File|BuildURL))=(.{2,})$/", $z, $regs))
-		{
-			$opts[$regs[1]] = $regs[2];
-		}
-		// Athena build style
-		else if (preg_match("/^(.+\.(?:download\.url|file|buildurl|url|name|id))=(.{2,})$/", $z, $regs))
-		{
-			#print "[ " . $regs[1] . " = " . $regs[2] . " ]<br/>";
-			$opts[$regs[1]] = $regs[2];
-		}
-		else if (preg_match("#^(buildAlias|noclean)=(.+)$#", $z, $regs))
-		{
-			$opts[$regs[1]] = trim($regs[2]);
-		}
-		else if (preg_match("#^(javaHome|JAVA_HOME|java.home)=(.+)$#", $z, $regs))
-		{
-			# TODO: change this to an exec to use java --version instead
-			# TODO: why is build.cfg not being found?
-			$rp = realpath($regs[2]);
-			$opts[$regs[1]] = ($rp && $rp != $regs[2] ? preg_replace("#.+/([^/]+)#", "$1", $regs[2]) . " (" . preg_replace("#.+/([^/]+)#", "$1", $rp) . ")" : preg_replace("#.+/([^/]+)#", "$1", $regs[2]));
-		}
-	}
-	return $opts;
-}
-
-function getBuildArtifacts($dir, $branchID)
-{
-	global $downloadPre, $PR, $deps, $proj, $projct, $debug;
-
-	$PR = "$PR" . ($proj != "/" ? $proj : ""); # to allow for modeling/emf
-	$mid = "$downloadPre/$PR" . "/downloads/drops/";
-	$file = "$dir/$branchID/build.cfg";
-	$havedeps = array();
-	$opts = loadBuildConfig($file, $deps);
-
-	$ret = "";
-
-	# ANy: Added to depict details via Hudson build job
-	if (isset($opts["hudson.job.url"])){
-		$ret .= "<li>\n";
-		$ret .= "<img src=\"/modeling/images/dl-more.gif\" alt=\"More info about this build\"/> Build Details\n";
-		$ret .= "<ul>\n";
-		$ret .= "<li>Hudson job <a href=\"" . $opts["hudson.job.url"] . "\">" . $opts["hudson.job.name"] . " #" . $opts["hudson.job.id"] . "</a></li>\n";
-		$ret .= "</ul>\n";
-		$ret .= "</li>\n";
-	}
-	return $ret;
-}
-
-function hudsonURLcleanup($vanity)
-{
-	$vanity = preg_replace("#hudson job cbi#","",$vanity);
-	$vanity = preg_replace("#Snapshot|snapshot#","",$vanity);
-	$vanity = preg_replace("#(lastSuccessful[^ ]+|lastStable[^ ]+)#","",$vanity);
-	$vanity = preg_replace("#artifact#","",$vanity);
-	$vanity = preg_replace("#base#","",$vanity);
-	$vanity = preg_replace("#[ ]+#"," ",$vanity);
-	return $vanity;
-}
-
-
 function showToggle($showAll, $showMax, $sortBy, $count)
 {
-	global $projct;
-	$ret = "<li><a href=\"" . $_SERVER["PHP_SELF"] . "?project=".$projct."&amp;showAll=" . ($showAll == "1" ? "" : "1") . "&amp;showMax=$showMax&amp;sortBy=$sortBy\">" . ($showAll != "1" ? "show all $count" : "show only $showMax") . "...</a></li>\n";
+	global $shortprojectname;
+	$ret = "<li><a href=\"" . $_SERVER["PHP_SELF"] . "?project=".$shortprojectname."&amp;showAll=" . ($showAll == "1" ? "" : "1") . "&amp;showMax=$showMax&amp;sortBy=$sortBy\">" . ($showAll != "1" ? "show all $count" : "show only $showMax") . "...</a></li>\n";
 	return $ret;
 }
 
 function showArchived($oldrels)
 {
-	global $PR, $proj;
+	global $projectname, $modelingprojectname, $projectdisplayname;
 
 	$thresh = sizeof($oldrels) > 5 ? ceil(sizeof($oldrels)/3) : 6;
-	#print "<div id=\"midcolumn\">\n";
 	print "<h3><a name=\"archives\"></a>Archived Releases</h3>\n";
-	print "<p>Older " . project_name($proj) . " releases have been moved to archive.eclipse.org, and can be accessed here:</p>";
+	print "<p>Older $projectdisplayname releases have been moved to archive.eclipse.org, and can be accessed here:</p>";
 	print '<table cellspacing="0" cellpadding="0" border="0" style="margin:0"><tr valign="top">'."\n";
 	print "<td><ul id=\"archives\">\n";
 	$cnt=-1;
@@ -817,9 +414,9 @@
 		}
 		else if (!is_array($oldrels[$z]))
 		{
-			print "<li style=''><a href=\"http://archive.eclipse.org/$PR$proj/downloads/drops/$z/R$oldrels[$z]/\">$z</a> (" . IDtoDateStamp($oldrels[$z], 2) . ")</li>\n";
+			print "<li style=''><a href=\"http://archive.eclipse.org/$projectname/$modelingprojectname/downloads/drops/$z/R$oldrels[$z]/\">$z</a> (" . IDtoDateStamp($oldrels[$z], 2) . ")</li>\n";
 		}
-		else // optional syntax with hardcoded datestamp and URL, like for old EMF/SDO/XSD 1.x builds
+		else 
 		{
 			print "<li><a href=\"" . $oldrels[$z][1] . "\">$z</a> (" . $oldrels[$z][0] . ")</li>\n";
 		}
@@ -829,28 +426,4 @@
 	print "</tr></table>\n";
 	#print "</div>\n";
 }
-
-function getTestResultsJUnitXML($file)
-{
-	$data = array();
-	exec("head -3 $file | grep \"<testsuite\"", $data); // possibly faster than file($file), but might break on some servers (eg., exec() is disabled on www.eclipse.org, so warnings are thrown)
-	foreach ($data as $line)
-	{
-		// <testsuite errors="0" failures="0" ...>
-		$matches = null;
-		if (preg_match("/<testsuite errors=\"(\d+)\" failures=\"(\d+).+\"/", $line, $matches))
-		{
-			return array($matches[1], $matches[2], 0);
-		}
-		else if (preg_match("/<testsuite.+failures=\"(\d+)\" errors=\"(\d+)\".+/", $line, $matches))
-		{
-			return array($matches[2], $matches[1], 0);
-		}
-		else if (false!==strpos($line,"<testsuites/>") || false!==strpos($line,"<testsuites />") || false!==strpos($line,"<testsuites></testsuites>") || false!==strpos($line,"Failed to invoke suite")) // no tests run!
-		{
-			return array(0, 0, 1);
-		}
-	}
-	return array(0, 0, 0); # Errors, Failures, DNRs
-}
 ?>
diff --git a/downloads/index.php b/downloads/index.php
index 3d88420..aaee40a 100644
--- a/downloads/index.php
+++ b/downloads/index.php
@@ -1,6 +1,6 @@
 <?php
 /******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
@@ -20,28 +20,20 @@
 include($App->getProjectCommon());
 ob_start();
 
-/* config */
-
-/* zips that are allowed to be absent from the downloads page (eg., new ones added mid-stream) */
-$extraZips = array(
-		"gmf-examples-pde", "GMF-examples-pde", "gmf-xpand", "gmf-gmf-Update"
-);
-
 /* $project => sections/Project Name => (prettyname => filename) */
-/* only required if using something other than the default 4; otherwise will be generated */
 $dls = array(
 		/*"/newProj" => array(
-		 "Project Name" => array( # same as value in _projectCommon.php's $projects array
-		 		"<acronym title=\"Click to download archived All-In-One p2 Repo Update Site\"><img alt=\"Click to download archived All-In-One p2 Repo Update Site\" src=\"/modeling/images/dl-icon-update-zip.gif\"/> <b style=\"color:green\">All-In-One Update Site</b></acronym>" => "Update",
+		 "Project Name" => array( 
+		 		"<acronym title=\"Click to download archived All-In-One p2 Repo Update Site\"><img alt=\"Click to download archived All-In-One p2 Repo Update Site\" src=\"/$projectname/images/dl-icon-update-zip.gif\"/> <b style=\"color:green\">All-In-One Update Site</b></acronym>" => "Update",
 		 		"SDK (Runtime, Source)" => "SDK",
 		 		"Runtime" => "runtime",
 		 		"Examples" => "examples",
 		 		"Automated Tests" => "automated-tests"
 		 )
 		),*/
-		"/gmf-runtime" => array(
-				"GMF Runtime" => array(
-						"<acronym title=\"Click to download archived All-In-One p2 Repo Update Site\"><img alt=\"Click to download archived All-In-One p2 Repo Update Site\" src=\"/modeling/images/dl-icon-update-zip.gif\"/> <b style=\"color:green\">All-In-One Update Site</b></acronym>" => "Update",
+		"$shortprojectname" => array(
+				"$projectdisplayname" => array(
+						"<acronym title=\"Click to download archived All-In-One p2 Repo Update Site\"><img alt=\"Click to download archived All-In-One p2 Repo Update Site\" src=\"/$projectname/images/dl-icon-update-zip.gif\"/> <b style=\"color:green\">All-In-One Update Site</b></acronym>" => "$projectname-Update",
 						"GMF Runtime Master" => "runtime-Master",
 						"GMF Runtime SDK" => "sdk-runtime",
 						"GMF Runtime" => "runtime",
@@ -49,27 +41,26 @@
 		),
 );
 
-/* list of valid file prefixes for projects who have been renamed; keys have leading / to match $proj */
+/* list of valid file prefixes for projects who have been renamed; keys have leading / to match $modelingprojectname */
 /* only required if using something other than the default; otherwise will be generated */
-$filePre = array( # use "/" because GEF has no parent or child projects/components
-		"/gmf-runtime" => array("gmf"),
+$filePre = array( 
+		"/$projectname" => array("$topprojectname"),
 );
 
-/* define showNotes(), $oldrels, doLanguagePacks() in extras-$proj.php (or just extras.php for flat projects) if necessary, downloads-common.php will include them */
+/* define showNotes(), $oldrels, doLanguagePacks() in extras-$projectname.php if necessary, downloads-common.php will include them */
 /* end config */
-require_once($_SERVER["DOCUMENT_ROOT"] . "/gmf-runtime/downloads/downloads-common.php");
+require_once($_SERVER["DOCUMENT_ROOT"] . "/$projectname/downloads/downloads-common.php");
 
 $html = ob_get_contents();
 ob_end_clean();
 
-$trans = array_flip($projects);
-$pageTitle = "GMF Runtime P2 Repositories and Zip Downloads";
-$pageKeywords = "gmf runtime";
+$pageTitle = "$projectdisplayname P2 Repositories and Zip Downloads";
+$pageKeywords = "$topprojectname $projectname $shortprojectname";
 $pageAuthor = "Anthony Hunter";
 
 # Generate the web page
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>' . "\n");
-$App->AddExtraHtmlHeader('<script src="/gmf-runtime/downloads/downloads.js" type="text/javascript"></script>' . "\n"); //ie doesn't understand self closing script tags, and won't even try to render the page if you use one
+$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/' . $projectname . '/style.css"/>' . "\n");
+$App->AddExtraHtmlHeader('<script src="/' . $projectname . '/downloads/downloads.js" type="text/javascript"></script>' . "\n"); //ie doesn't understand self closing script tags, and won't even try to render the page if you use one
 $App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
 
 ?>
diff --git a/downloads/scripts.php b/downloads/scripts.php
index 89bf83c..e13556f 100644
--- a/downloads/scripts.php
+++ b/downloads/scripts.php
@@ -1,132 +1,14 @@
 <?php
-
-// $Id: scripts.php,v 1.89 2011/01/26 20:19:18 ahunter Exp $
-
-function PWD_check($PWD, $suf)
-{
-	debug ("&#160; &#160; <b>PWD = </b>$PWD; <b>suf = </b>$suf;<br/>&#160; &#160; &#160; is_dir? <b style='color:green'>" . is_dir($PWD) . "</b>; is_readable? <b style='color:green'>" . is_readable($PWD) . "</b>; is_writable? <b style='color:green'>" . is_writable($PWD) . "</b><br/>", 2);
-	return(!is_dir($PWD) || !is_readable($PWD) ||($suf == "logs" && !is_writable($PWD)));
-}
-
-function getPWD($suf = "", $doDynCheck = true, $debug_echoPWD = 1) // set 0 to hide (for security purposes!)
-{
-	global $PR, $App;
-	debug ("<br/>getPWD <b>PR = </b>$PR, <b>suf = </b>$suf</br>", 2);
-	$PWDs = array();
-
-	if($doDynCheck)
-	{
-		//dynamic assignments
-		$PWD = $App->getDownloadBasePath() . "/$PR/" . $suf;
-		$PWDs[] = $PWD;
-
-		//second dynamic assignment
-		if(PWD_check($PWD, $suf))
-		{
-			$PWD = $_SERVER["DOCUMENT_ROOT"] . "/$PR/" . $suf;
-			$PWDs[] = $PWD;
-		}
-
-		if(!PWD_check($PWD, $suf))
-		{
-			debug("'$suf' ended up with first '$PWD' (is_readable: <b style='color:green'>" . is_readable($PWD) . "</b>, is_dir: <b style='color:green'>" . is_dir($PWD) . "</b>)");
-			return $PWD;
-		}
-	}
-	$PWD = "";
-
-	//static assignments
-	if(PWD_check($PWD, $suf))
-	{
-		$servers = array(
-				"/buildbox(?:\.torolab\.ibm\.com)?/" => "/home/www-data/build",
-				"/build\.eclipse\.org/" => "/opt/public/modeling/build",
-				"/emf(?:\.torolab\.ibm\.com)?/" => "/home/www-data/build",
-				"/(emft|modeling)(?:\.eclipse\.org)?/" => "/home/www-data/build",
-				"/localhost/" => "/home/www-data/build",
-				"/download1\.eclipse\.org/" => "/home/local/data/httpd/download.eclipse.org",
-				"/fullmoon\.torolab\.ibm\.com/" => "/home/www");
-
-		foreach(array_keys($servers) as $z)
-		{
-			$PWD = $servers[$z] . "/$PR/$suf";
-			if(preg_match($z, $_SERVER["HTTP_HOST"]) && !PWD_check($PWD, $suf))
-			{
-				$PWDs[] = $PWD;
-			}
-		}
-		foreach(array_keys($servers) as $z)
-		{
-			$PWD = $servers[$z] . "/$suf";
-			if(preg_match($z, $_SERVER["HTTP_HOST"]) && !PWD_check($PWD, $suf))
-			{
-				$PWDs[] = $PWD;
-			}
-		}
-	}
-	$PWD = "";
-
-	//try a default guess: /home/www, two options
-	if(PWD_check($PWD, $suf))
-	{
-		$data = array(
-				4 => array(
-						"checkdir" => "/home/data/httpd/download.eclipse.org/",
-						"tries" => array("/home/data/httpd/download.eclipse.org/$suf",
-								"/home/data/httpd/download.eclipse.org/$PR/$suf",)
-				),
-				5 => array("checkdir" => "/home/data2/httpd/download.eclipse.org/",
-						"tries" => array("/home/data2/httpd/download.eclipse.org/$suf",
-								"/home/data2/httpd/download.eclipse.org/$PR/$suf",)
-				),
-				6 => array("checkdir" => "/home/local/data/httpd/download.eclipse.org/",
-						"tries" => array($doDynCheck ? $App->getDownloadBasePath() . "/$PR/" . $suf : null,
-								"/home/local/data/httpd/download.eclipse.org/$suf",
-								"/home/local/data/httpd/download.eclipse.org/$PR/$suf",)
-				),
-				7 => array("checkdir" => "/var/www/",
-						"tries" => array("/var/www/$PR/$suf",
-								"/var/www/html/$PR/$suf",)
-				)
-		);
-
-		foreach(array_keys($data) as $y)
-		{
-			$PWD = $data[$y]["checkdir"];
-			if(is_dir($PWD) && is_readable($PWD))
-			{
-				foreach(array_keys($data[$y]["tries"]) as $z)
-				{
-					#debug("&#160; &#160; &#160; &#160; &#160; \$data[$y][\"tries\"][$z] = " . $data[$y]["tries"][$z],3);
-					$PWD = $data[$y]["tries"][$z];
-					if($PWD && !PWD_check($PWD, $suf))
-					{
-						$PWDs[] = $PWD;
-						break 2;
-				}
-			}
-		}
-	}
-}
-$PWD = "/home/data2/httpd/download.eclipse.org/gmf-runtime/gmf-runtime/downloads/drops";
-
-krsort($PWDs);
-reset($PWDs);
-	debug_r($PWDs, "<hr>PWDs: ", "<hr>", 2);
-foreach($PWDs as $i => $PWD)
-{
-	debug(" &#160; &#160; $i : $PWD", 9);
-	if(!PWD_check($PWD, $suf))
-	{
-		debug("'$suf' ended up with second '$PWD' (is_readable: <b style='color:green'>" . is_readable($PWD) . "</b>, is_dir: <b style='color:green'>" . is_dir($PWD) . "</b>)");
-		return $PWD;
-	}
-}
-
-debug("<!-- PWD not found! -->");
-debug("'$suf' ended up with third '$PWD' (is_readable: <b style='color:green'>" . is_readable($PWD) . "</b>, is_dir: <b style='color:green'>" . is_dir($PWD) . "</b>)");
-return $PWD;
-}
+/******************************************************************************
+ * Copyright (c) 2013, 2014 IBM Corporation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*    IBM Corporation - initial implementation
+****************************************************************************/
 
 function loadDirSimple($dir, $ext, $type) // 1D array, not 2D
 {
@@ -162,99 +44,6 @@
 	return $stuff;
 }
 
-function wArr($arr)
-{
-	print "<pre>\n";
-	print_r($arr);
-	print "</pre>\n";
-}
-
-function w($s, $br = "") // shortcut for echo() with second parameter: "add break+newline"
-{
-	if(stristr($br, "n"))
-	{
-		$br = "\n";
-	}
-	else
-	if($br)
-	{
-		$br = "<br/>\n";
-	}
-
-	print $s . $br;
-}
-
-function getNews($lim, $key, $xml = "", $linkOnly = false, $dateFmtPre = "", $dateFmtSuf = "") // allow overriding in case the file's not in /$PR/
-{
-	global $PR;
-
-	$xml =($xml ? $xml : file_get_contents($_SERVER["DOCUMENT_ROOT"] . "/$PR/" . "news/news.xml"));
-	$news_regex = "%
-			<news\ date=\"([^\"]+)\"\ showOn=\"([^\"]+)\">.*\\n
-			(.+)\\n
-			</news>.*\\n
-			%mx";
-
-	if(!$xml)
-	{
-		print "<p><b><i>Error</i></b> Couldn't find any news!</p>\n";
-	}
-
-	$regs = null;
-	preg_match_all($news_regex, $xml, $regs);
-	$i_real = 0;
-	foreach(array_keys($regs[0]) as $i)
-	{
-		if($i_real >= $lim && $lim > 0)
-		{
-			return;
-		}
-
-		$showOn = explode(",", $regs[2][$i]);
-		if($key == "all" || in_array($key, $showOn))
-		{
-			$i_real++;
-			print "<p>\n";
-			if(strtotime($regs[1][$i]) > strtotime("-3 weeks"))
-			{
-				if(preg_match("/update/i", $regs[3][$i]))
-				{
-					print '<img src="/modeling/images/updated.gif" alt="Updated!"/> ';
-				}
-				else
-				{
-					print '<img src="/modeling/images/new.gif" alt="New!"/> ';
-				}
-
-			}
-			if(!$dateFmtPre && !$dateFmtSuf)
-			{
-				$app =(date("Y", strtotime($regs[1][$i])) < date("Y") ? ", Y" : "");
-				print date("M" . '\&\n\b\s\p\;jS' . $app, strtotime($regs[1][$i])) . ' - ' . "\n";
-			}
-			else
-			if($dateFmtPre)
-			{
-				print date($dateFmtPre, strtotime($regs[1][$i]));
-			}
-			if($linkOnly)
-			{
-				$link = preg_replace("#.+(<a .+</a>).+#", "$1", $regs[3][$i]);
-			}
-			else
-			{
-				$link = $regs[3][$i];
-			}
-			print $link;
-			if($dateFmtSuf)
-			{
-				print date($dateFmtSuf, strtotime($regs[1][$i]));
-			}
-			print "</p>\n";
-		}
-	}
-}
-
 /* TODO: remove this when we upgrade php to >= 4.3.0 everywhere */
 if(!function_exists("file_get_contents"))
 {
@@ -264,84 +53,6 @@
 	}
 }
 
-function getProjectArray($projects, $extraprojects, $nodownloads, $PR) //only the projects we have the files for
-{
-	$pwd = getPWD();
-
-	$projs = loadDirSimple($pwd, ".*", "d"); // locally available
-	foreach($nodownloads as $z)
-	{
-		/* php <4.2.0 returns NULL on array_search() failure, but php >=4.2.0 returns FALSE on array_search() failure, so don't check that */
-		if(is_numeric($s = array_search($z, $projs)))
-		{
-			unset($projs[$s]);
-		}
-	}
-
-	return array_intersect(array_merge($projects, $extraprojects), $projs);
-}
-
-function doSelectProject($projectArray, $proj, $nomenclature, $style = "homeitem3col", $showAll = "", $showMax = "", $sortBy = "")
-{
-	global $incubating;
-	$vars = array("showAll", "showMax", "sortBy", "hlbuild");
-	$tmp = preg_replace("#^/#", "", $proj);
-
-	$hlbuild =(isset($_GET["hlbuild"]) && preg_match("/^[IMNRS]\d{12}$/", $_GET["hlbuild"]) ? $_GET["hlbuild"] : "");
-
-	$out = "<div class=\"" .($style == "sideitem" ? "sideitem" : "homeitem3col") . "\">\n";
-	$tag =($style == "sideitem" ? "h6" : "h3");
-	$out .= "<$tag>";
-	if($style != "sideitem" && isset($incubating) && in_array($tmp, $incubating))
-	{
-		$out .= '<a href="http://www.eclipse.org/projects/what-is-incubation.php"><img style="float:right"
-				src="http://www.eclipse.org/modeling/images/egg-icon.png" alt="Validation (Incubation) Phase"
-				border="0" /></a>';
-	}
-	$out .= "$nomenclature selection</$tag>\n";
-	$out .= "<form action=\"" . $_SERVER["SCRIPT_NAME"] . "\" method=\"get\" id=\"subproject_form\">\n";
-	$out .= "<p>\n";
-	$out .= "<label for=\"project\">$nomenclature: </label>\n";
-
-	$out .= "<select id=\"project\" name=\"project\" onchange=\"javascript:document.getElementById('subproject_form').submit()\">\n";
-	foreach($projectArray as $k => $v)
-	{
-		$out .= "<option value=\"$v\">$k</option>\n";
-	}
-	$out .= "</select>\n";
-	foreach($vars as $z)
-	{
-		if($$z !== "")
-		{
-			$out .= "<input type=\"hidden\" name=\"$z\" value=\"" . $$z . "\"/>\n";
-		}
-	}
-	$out = preg_replace("#<option (value=\"$tmp\")>#", "<option selected=\"selected\" $1>", $out);
-	$out .= "<input type=\"submit\" value=\"Go!\"/>\n";
-	$out .= "</p>\n";
-	$out .= "</form>\n";
-	$out .= "</div>\n";
-
-	return $out;
-}
-
-function project_name($proj)
-{
-	global $projects, $PR;
-
-	if (isset($projects))
-	{
-		$tmp = array_flip($projects);
-		$proj = preg_replace("#^/#", "", $proj);
-		return isset($tmp[$proj]) ? $tmp[$proj] :(isset($tmp[$PR]) ? $tmp[$PR] : "");
-	}
-	else
-	{
-		return strtoupper($proj);
-	}
-
-}
-
 function debug($str, $level = 0)
 {
 	global $debug;
@@ -431,11 +142,11 @@
 	return $out;
 }
 
-function getProjectFromPath($PR)
+function getProjectFromPath($projectname)
 {
 	$m = null;
-	return preg_match("#/" . $PR . "/([^/]+)/build/.+#", $_SERVER["PHP_SELF"], $m) ? $m[1] :(preg_match("#/(" .
-			$PR . ")/build/.+#", $_SERVER["PHP_SELF"], $m) ? $m[1] : "");
+	return preg_match("#/" . $projectname . "/([^/]+)/build/.+#", $_SERVER["PHP_SELF"], $m) ? $m[1] :(preg_match("#/(" .
+			$projectname . ")/build/.+#", $_SERVER["PHP_SELF"], $m) ? $m[1] : "");
 }
 
 function cvsminus($rev)
@@ -457,90 +168,16 @@
 	}
 }
 
-function changesetForm($bugid = "")
-{
-	?>
-<form action="http://www.eclipse.org/modeling/emf/news/changeset.php"
-	method="get" target="_blank">
-	<p>
-		<label for="bugid">Bug ID: </label><input size="7" type="text"
-			name="bugid" id="bugid" value="<?php print $bugid; ?>" /> <input
-			type="submit" value="Go!" />
-	</p>
-	<p>
-		<a href="javascript:void(0)"
-			onclick="javascript:this.style.display = 'none'; document.getElementById('changesetinfo').style.display = 'block';">How
-			does this work?</a>
-	</p>
-	<div id="changesetinfo" style="display: none">
-		<p>Use this form to generate a bash shell script which can be run
-			against the projects and plugins in your workspace to produce a patch
-			file showing all changes for a given bug.</p>
-		<p>
-			The requested bug must be indexed in the <a
-				href="http://www.eclipse.org/modeling/searchcvs.php?q=190525">Search
-				CVS</a> database. Download the generated script for more
-			information. If the script is empty, then the bug was not found.
-		</p>
-	</div>
-</form>
-<?php
-
-}
-
-function tokenize($in) # split a shell command into flag/value pairs
-{
-	/* 17722 ? Ss 0:00 /bin/bash /home/www-data/build/modeling/scripts/start.sh -proj gmf
-	 * -sub gmf -version 2.1.0 -branch HEAD
-	* -URL http://download.eclipse.org/eclipse/downloads/drops/S-3.4M7-200805020100/eclipse-SDK-3.4M7-linux-gtk.tar.gz
-	* -URL http://download.eclipse.org/modeling/emf/emf/downloads/drops/2.4.0/S200805052017/emf-sdo-xsd-SDK-2.4.0M7.zip
-	* -URL http://download.eclipse.org/modeling/mdt/uml2/downloads/drops/2.2.0/S200805052208/mdt-uml2-SDK-2.2.0M7.zip
-	* -URL http://download.eclipse.org/tools/orbit/downloads/drops/S20080427194908/orbitBundles-S20080427194908.map
-	* -URL http://emft.eclipse.org/modeling/mdt/ocl/downloads/drops/1.2.0/S200805061053/mdt-ocl-SDK-1.2.0M7.zip
-	* -URL http://emft.eclipse.org/modeling/emf/query/downloads/drops/1.2.0/S200805061125/emf-query-SDK-1.2.0M7.zip
-	* -URL http://download.eclipse.org/modeling/emf/transaction/downloads/drops/1.2.0/S200805061205/emf-transaction-SDK-1.2.0M7.zip
-	* -URL http://emft.eclipse.org/modeling/emf/validation/downloads/drops/1.2.0/S200805061125/emf-validation-SDK-1.2.0M7.zip
-	* -URL http://download.eclipse.org/tools/gef/downloads/drops/3.4.0/S200804291800/GEF-ALL-3.4.0M7.zip -antTarget run
-	* -mapfileRule use-false -buildType I -javaHome /opt/sun-java2-5.0 -downloadsDir /home/www-data/build/downloads
-	* -buildDir /home/www-data/build/modeling/gmf/gmf/downloads/drops/2.1.0/I200805072353
-	* -email gmf-releng@eclipse.org,nickboldt@gmail.com,max.feldman@borland.com,anthonyh@ca.ibm.com
-	* -basebuilderBranch RC1_34
-	*/
-	$bits = explode(" -", $in);
-	$pairs["cmd"] = $bits[0];
-	for($i = 1; $i < sizeof($bits); $i++)
-	{
-		$pair = explode(" ", $bits[$i]);
-		if(isset($pair[0]) && isset($pair[1]))
-		{
-			$pairs[$pair[0]] = $pair[1];
-		}
-		else
-		if(isset($pair[0]))
-		{
-			$pairs[$pair[0]] = "";
-		}
-	}
-	return $pairs;
-}
-
-function addGoogleAnalyticsTrackingCodeToHeader($UA = "UA-2566337-8")
-{
-	# http://wiki.eclipse.org/Using_Phoenix#Google_Analytics
-	global $App;
-	$App->SetGoogleAnalyticsTrackingCode("$UA");
-}
-
 function getDownloadScript()
 {
-	global $PR;
-	if(strstr($PR, "/") !== false)
+	global $projectname;
+	if(strstr($projectname, "/") !== false)
 	{
-		list($topProj, $parentProj) = explode("/", $PR); # modeling, emf
+		list($topProj, $parentProj) = explode("/", $projectname); 
 	}
 	else
 	{
-		list($topProj, $parentProj) = array("NONE", $PR); # NONE, gef
+		list($topProj, $parentProj) = array("NONE", $projectname); 
 	}
 
 	# if this is a Modeling page, use /modeling/download.php;
diff --git a/images/dl-icon-update-zip.gif b/images/dl-icon-update-zip.gif
new file mode 100644
index 0000000..a16254b
--- /dev/null
+++ b/images/dl-icon-update-zip.gif
Binary files differ
diff --git a/images/dl.gif b/images/dl.gif
new file mode 100644
index 0000000..9d2f23a
--- /dev/null
+++ b/images/dl.gif
Binary files differ
diff --git a/images/link.png b/images/link.png
new file mode 100644
index 0000000..8b624d9
--- /dev/null
+++ b/images/link.png
Binary files differ
