diff --git a/_projectCommon.php b/_projectCommon.php
index 22e55dc..3f6db80 100755
--- a/_projectCommon.php
+++ b/_projectCommon.php
@@ -7,7 +7,8 @@
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
- * Contributors:
+ * Contributors: Christopher Frost
+ *               Mike Keith
  *    
  *******************************************************************************/
 
@@ -25,17 +26,18 @@
 	# $Nav->setLinkList(array());
 	
 	# Break the navigation into sections
-	$Nav->addNavSeparator("MyProject", 	"/default");
-	$Nav->addCustomNav("Download", "/project/download.php", "_self", 3);
-	$Nav->addCustomNav("Documentation", "/project/documentation.php", "_blank", 3);
-	$Nav->addCustomNav("Support", "/project/support.php", "_blank", 3);
-	$Nav->addCustomNav("Getting Involved", "/project/developers", "_blank", 3);
+	$Nav->addNavSeparator("Gemini Home", 	"/gemini/dbaccess/");
+	$Nav->addCustomNav("Gemini Web Home",	"/gemini/dbaccess/", 				"_self", 3);
+	$Nav->addCustomNav("Download", 			"/gemini/dbaccess/download", 		"_self", 3);
+	$Nav->addCustomNav("Documentation", 	"/gemini/dbaccess/documentation",	"_self", 3);
+	$Nav->addCustomNav("Support", 			"/gemini/dbaccess/support", 			"_self", 3);
+	$Nav->addCustomNav("Getting Involved", 	"/gemini/dbaccess/contribute",		"_self", 3);
+	$Nav->addCustomNav("About Gemini", 		"/gemini/dbaccess/about",    		"_self", 3);
 
 	# Define keywords, author and title here, or in each PHP page specifically
-	$pageKeywords	= "xtext, dsl, modeling, domain specific language, textual";
-	$pageAuthor		= "Your name";
-	# $pageTitle 		= "Xtext";
-
+	# $pageKeywords	= "eclipse, OSGi, gemini";
+	# $pageAuthor		= "Mike Keith";
+	# $pageTitle 		= "Gemini DBAccess";
 
 	# top navigation bar
 	# To override and replace the navigation with your own, uncomment the line below.
@@ -47,11 +49,11 @@
 	# $Menu->addMenuItem("Developers", "/project/developers", "_self");
 	
 	# To define additional CSS or other pre-body headers
-	# $App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+	$App->AddExtraHtmlHeader('<link media="screen" rel="stylesheet" type="text/css" href="/gemini/dbaccess/resources/local.css"/>');
 	
 	# To enable occasional Eclipse Foundation Promotion banners on your pages (EclipseCon, etc)
 	$App->Promotion = TRUE;
 	
 	# If you have Google Analytics code, use it here
-	# $App->SetGoogleAnalyticsTrackingCode("YOUR_CODE");
+	# $App->SetGoogleAnalyticsTrackingCode("UA-15496793-1");
 ?>
\ No newline at end of file
diff --git a/about/index.php b/about/index.php
new file mode 100644
index 0000000..2b8011f
--- /dev/null
+++ b/about/index.php
@@ -0,0 +1,43 @@
+<?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());
+	
+/*******************************************************************************
+ * Copyright (c) 2009 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: Christopher Frost
+ *               Mike Keith
+ *    
+ *******************************************************************************/
+
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini DB Access - About";
+	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, History, origin, origins, about";
+	$pageAuthor		= "Mike Keith";
+		
+	ob_start();
+?>
+	
+	<div id="midcolumn">
+		<h2>About Gemini DB Access</h2>
+		<p>
+			The Gemini DB Access project is about providing modularized access to JDBC resources. It causesexports a DataSourceFactory
+			object so that client applications of the JDBC driver can import and access the features of the driver without having to 
+			package the driver as part of the applicaion. 
+		</p>
+	</div>
+
+<?
+	$html = ob_get_clean();
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
diff --git a/contribute/index.php b/contribute/index.php
new file mode 100644
index 0000000..5fe92a4
--- /dev/null
+++ b/contribute/index.php
@@ -0,0 +1,47 @@
+<?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());
+	
+/*******************************************************************************
+ * Copyright (c) 2009 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: Christopher Frost
+ *               Mike Keith
+ *    
+ *******************************************************************************/
+
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini DB Access - Contribute";
+	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, Contribute, Developers, help";
+	$pageAuthor		= "Mike Keith";
+		
+	ob_start();
+?>
+	
+	<div id="midcolumn">
+		<h2>Contributing to the Project</h2>
+		<p>
+			If you have a JDBC driver that you would like to either use or have already implemented as a module then
+			please either subscribe and send an email to the <a href="https://dev.eclipse.org/mailman/listinfo/gemini-dev">developer mailing list</a> or post to the <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153">forum</a>.
+		</p>
+		
+		<p>
+			All of the source code for this project is maintain in an SVN repository.
+		</p>
+
+	</div>
+
+<?
+	$html = ob_get_clean();
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
diff --git a/documentation/index.php b/documentation/index.php
new file mode 100644
index 0000000..33d0cd4
--- /dev/null
+++ b/documentation/index.php
@@ -0,0 +1,43 @@
+<?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());
+	
+/*******************************************************************************
+ * Copyright (c) 2009 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: Christopher Frost
+ *               Mike Keith
+ *    
+ *******************************************************************************/
+
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini DB Access - Documentation";
+	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, Documentation";
+	$pageAuthor		= "Mike Keith";
+		
+	ob_start();
+?>
+	
+	<div id="midcolumn">
+		<h2>Gemini DB Access Documentation</h2>
+		<p>
+		The documentation has not been created yet for this project. If you would like to volunteer to write, or assist in 
+		writing them, please send an email to the <a href="https://dev.eclipse.org/mailman/listinfo/gemini-dev">developer mailing list</a> or post to the <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153">forum</a>.
+		</p>
+
+	</div>
+
+<?
+	$html = ob_get_clean();
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
diff --git a/download.php b/download.php
deleted file mode 100644
index a4c9eb1..0000000
--- a/download.php
+++ /dev/null
@@ -1,34 +0,0 @@
-<?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'
-/*******************************************************************************
- * Copyright (c) 2009 
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    
- *******************************************************************************/
-
-	$pageTitle 		= "MyProject - Download";
-	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
-
-	$html  = <<<EOHTML
-<div id="midcolumn">
-<h2>$pageTitle</h2>
-<p>All downloads are provided under the terms and conditions of the <a href="/legal/epl/notice.php">Eclipse Foundation Software User Agreement</a> unless otherwise specified.</p>
-
-<h3>Galileo - Eclipse 3.5</h3>
-<p><b>Update site:</b> http://download.eclipse.org/myproject/<br />
-<b>ZIP file: </b><a href="/downloads/download.php?file=/myproject/file.zip">file.zip</a> (10 MiB)</p>
-
-<h3>Helios - Eclipse 3.6 (unreleased)</h3>
-<p><b>Update site:</b> http://download.eclipse.org/myproject/<br />
-<b>ZIP file: </b><a href="/downloads/download.php?file=/myproject/file.zip">file.zip</a> (10 MiB)</p>
-
-
-</div>
-EOHTML;
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
diff --git a/download/index.php b/download/index.php
new file mode 100644
index 0000000..a125af0
--- /dev/null
+++ b/download/index.php
@@ -0,0 +1,57 @@
+<?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());
+	
+/*******************************************************************************
+ * Copyright (c) 2009 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: Christopher Frost
+ *               Mike Keith
+ *    
+ *******************************************************************************/
+
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini DB Access - Downloads";
+	$pageKeywords	= "Eclipse, EclipseRT, OSGi, Downloads";
+	$pageAuthor		= "Mike Keith";
+		
+	ob_start();
+?>
+	
+	<div id="midcolumn">
+		<h2>Downloads</h2>
+		<p>
+			All downloads are provided under the terms and conditions of the 
+			<a href="/legal/epl/notice.php">Eclipse Foundation Software User Agreement</a> unless otherwise specified.
+		</p>
+		<p>
+		    No downloads are currently available.
+		</p>
+	</div>
+
+	<!-- remove the entire <div> tag to omit the right column!  -->
+	<div id="rightcolumn">
+		<div class="sideitem">
+			<h6>Incubation</h6>
+			<div id="incubation">
+				<a href="/projects/what-is-incubation.php">
+					<img align="center" src="/images/egg-incubation.png" border="0" alt="Incubation" />
+				</a>
+			</div>
+		</div>
+	</div>
+
+<?
+	$html = ob_get_clean();
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
diff --git a/index.php b/index.php
index ab12bd1..6e8f567 100755
--- a/index.php
+++ b/index.php
@@ -1,4 +1,12 @@
 <?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();		
+	incltude($App->getProjectCommon());
+	
 /*******************************************************************************
  * Copyright (c) 2009 Eclipse Foundation and others.
  * All rights reserved. This program and the accompanying materials
@@ -6,25 +14,60 @@
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
- * Contributors:
+ * Contributors: Christopher Frost
+ *               Mike Keith
  *    
  *******************************************************************************/
 
-	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());
-	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini DB Access - Home";
+	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, Home";
+	$pageAuthor		= "Mike Keith";
+			
+	ob_start();
+?>
+	<div id="midcolumn">
+		<div class="logo"><h1>Gemini DB Access</h1></div>
+		<p>
+			The Gemini DB Access project provides modularized distributions of JDBC drivers, currently suitable for running in OSGi. 
+			While the list is currently fairly short, it is expected to grow as the needs of its users grow and resources to implement 
+			them increase.
+		</p>
+		
+	</div>
+
+	<!-- remove the entire <div> tag to omit the right column!  -->
+	<div id="rightcolumn">
+		<div class="sideitem">
+			<h6>Quick Links</h6>
+			<ul>
+				<li><a href="http://wiki.eclipse.org/Gemini">Gemini Wiki</a></li>
+				<li><a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153&">Gemini Forum</a></li>  
+				<li><a href="https://dev.eclipse.org/mailman/listinfo/gemini-dev">Developer Mailing List</a></li>
+				<li><a href="http://www.eclipse.org/projects/project_summary.php?projectid=rt.gemini">Project Summary</a></li>
+				<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;order=Importance;classification=RT;product=Gemini">Gemini Bugzilla</a></li>
+			</ul>
+		</div>
+		<div class="sideitem">
+			<h6>Incubation</h6>
+			<div id="incubation">
+				<a href="/projects/what-is-incubation.php">
+					<img align="center" src="/gemini/web/images/egg-incubation.png" border="0" alt="Incubation" />
+				</a>
+			</div>
+		</div>		
+		<!-- div class="sideitem">
+			<h6>&lt;h6&gt; tag</h6>
+				<div class="modal">
+					Wrapping your content using a div.modal tag here will add the gradient background
+				</div>
+		</div -->
+	</div>
+
 	
-	$localVersion = false;
-	
-	# Define these here, or in _projectCommon.php for site-wide values
-	$pageKeywords	= "eclipse, project";
-	$pageAuthor		= "Your name";
-	$pageTitle 		= "My project home";
-	
-	
-	// 	# Paste your HTML content between the EOHTML markers!
-	$html = file_get_contents('pages/_index.html');
+<?
+	$html = ob_get_clean();
 
 	# Generate the web page
-	$App->generatePage($theme, $Menu, null, $pageAuthor, $pageKeywords, $pageTitle, $html);
-
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
 ?>
\ No newline at end of file
diff --git a/midcolumn_example.php b/midcolumn_example.php
deleted file mode 100644
index e8b3466..0000000
--- a/midcolumn_example.php
+++ /dev/null
@@ -1,91 +0,0 @@
-<?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'
-/*******************************************************************************
- * Copyright (c) 2009 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:
- *    
- *******************************************************************************/
-
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Nova #midcolumn Template";
-	$pageKeywords	= "Nova, template, #midcolumn";
-	$pageAuthor		= "Nathan Gervais";
-		
-	# Paste your HTML content between the EOHTML markers!	
-	ob_start();
-	?>
-	<div id="midcolumn">
-		<h1>&lt;H1&gt; tag</h1>
-		
-		<p>
-			This is a &lt;p&gt; tag.  
-		</p>
-		
-		<p>
-			This is a &lt;p&gt; tag.  With a lot of text. <br/>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-		</p>
-		
-		
-		<h3>&lt;h3&gt; tag</h3>
-		<div class="homeitem">
-			<ul>
-				<li>This is an unordered list</li>
-				<li>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.</li>
-				<li>Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum</li>
- 				<li>Curabitur vel lorem in turpis adipiscing dictum. Nunc mi est, scelerisque vitae, venenatis et, euismod et, sem. Praesent aliquet mi vel felis. Pellentesque pellentesque convallis ante. Praesent imperdiet velit vitae justo. Nullam quis purus. Aenean neque enim, consequat non, mattis eu, gravida sed, massa.</li>
-			</ul>
-			<ol> 
-				<li>This is an ordered list</li>
-				<li>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.</li>
-				<li>Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum</li>
- 				<li>Curabitur vel lorem in turpis adipiscing dictum. Nunc mi est, scelerisque vitae, venenatis et, euismod et, sem. Praesent aliquet mi vel felis. Pellentesque pellentesque convallis ante. Praesent imperdiet velit vitae justo. Nullam quis purus. Aenean neque enim, consequat non, mattis eu, gravida sed, massa.</li>
-			</ol>				
-		</div>
-		
-		<h2>&lt;h2&gt; tag</h2>
-		<table>
-			<tr>
-				<td>Tables look </td>
-				<td>like this</td>
-			</tr>
-			<tr>
-				<td>Data</td>
-				<td>Data</td>
-			</tr>
-			<tr>
-				<td>Data</td>
-				<td>Data</td>
-			</tr>
-		</table>
-		
-	</div>
-
-	<!-- remove the entire <div> tag to omit the right column!  -->
-	<div id="rightcolumn">
-		<div class="sideitem">
-			<h6>Related Links</h6>
-			<ul>
-				<li><a href="midcolumn.php">#midcolumn Template</a></li>
-				<li><a href="fullcolumn.php">#fullcolumn Template</a></li>
-			</ul>
-		</div>
-		<div class="sideitem">
-			<h6>&lt;h6&gt; tag</h6>
-				<div class="modal">
-					Wrapping your content using a div.modal tag here will add the gradient background
-				</div>
-		</div>
-	</div>
-
-	
-	<?
-	$html = ob_get_clean();
-
-	# Generate the web page
-	$App->generatePage('Nova', $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
diff --git a/pages/_index.html b/pages/_index.html
deleted file mode 100644
index ce5ecfa..0000000
--- a/pages/_index.html
+++ /dev/null
@@ -1,92 +0,0 @@
-<div id="bigbuttons">
-<h3>Primary Links</h3>
-<ul>
-	<li><a id="buttonDownload" href="download.php" title="Download">Eclipse
-	Distribution, Update Site, Dropins</a></li>
-	<li><a id="buttonDocumentation" href="midcolumn_example.php"
-		title="Documentation">Tutorials, Examples, Videos, Reference Documentation</a></li>
-	<li><a id="buttonSupport" href="midcolumn_example.php" title="Download">Bug
-	Tracker, Newsgroup, Professional Support</a></li>
-	<li><a id="buttonInvolved" href="midcolumn_example.php" title="Getting Involved">CVS,
-	Workspace Setup, Wiki, Committers</a></li>
-</ul>
-</div>
-
-<div id="midcolumn">
-<h3>MyProject - use this header describe what it does</h3>
-<div id="introText">
-
-<p class="left"> This project was just provisioned.  You can see the proposal 
-<a href="/proposals/gemini">here</a>
-
-<p class="right">MyProject is a framework for development of cool stuff and
-more cool stuff. Just describe your project here very briefly. Use the center 
-section below for a screenshot, a screenshot collage or a screencast.</p>
-
-
-</p>
-
-</div>
-
- 
-
-<div id="screencast">
-<object width="640" height="480"><param name="allowfullscreen" value="true" /><param name="allowscriptaccess" value="always" /><param name="movie" value="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" /><embed src="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" type="application/x-shockwave-flash" allowfullscreen="true" allowscriptaccess="always" width="640" height="480"></embed></object>
-</div>
-
-<!-- 
-<h3>...and yet powerful</h3>
- -->
-<div id="feature_1">
-
-<h4>Some cool feature</h4>
-<p>MyProject has this really cool feature that you describe here in few words, just as a teaser.</p>
-</div>
-
-<div id="feature_2">
-<h4>Another Feature</h4>
-<p>When working with MyProject, great things happen, and one of them is described here.</p>
-</div>
-
-<div id="feature_3">
-<h4>Another Feature</h4>
-<p>When working with MyProject, great things happen, and one of them is described here.</p>
-</div>
-
-<div id="feature_4">
-<h4>User Experience</h4>
-<p>
-Experiment with style.css to create columns for text, just the way you want it. This section 
-is a bit wider and can contain more words, even small logos or graphics to describe a neat feature in more detail.</p>
-</div>
-
-<div id="feature_more">
-<h4>and much more...</h4>
-<p>Read the MyProject <a href="/project/documentation.php">documentation</a> and join the discussion at the <a href="http://www.eclipse.org/forums/eclipse.newsgroup.name">forum</a> to understand how powerful MyProject is.</p>
-<p> Want to know more? <a href="/projects/project_summary.php?projectid=rt.gemini.dbaccess">About This Project</a>
-</div>
-
-</div>
-
-<div id="rightcolumn">
-
-<div>
-<h3>Current Status</h3>
-<p>Update this section occasionally to let your community know what's new and exciting with your project....</p>
-</div>
-
-<div id="headlines">
-<h3>New and Noteworthy</h3>
-<p>... or a link to your new and noteworthy.</p>
-</div>
-
-<div id="headlines">
-<h3>Headlines on the web</h3>
-<p>Project headlines...</p>
-</div>
-
-<div id="headlines">
-<h3>Another announcement</h3>
-<p>MyProject is pleased to announce...</p>
-</div>
-</div>
\ No newline at end of file
diff --git a/resources/local.css b/resources/local.css
new file mode 100644
index 0000000..8ab1dfe
--- /dev/null
+++ b/resources/local.css
@@ -0,0 +1,56 @@
+@CHARSET "UTF-8";
+
+
+.twtr-hd h3, .twtr-hd h4 {
+	color: #ffffff;
+}
+
+.twtr-hd h3 {
+	border: 0px;
+}
+
+.logo {
+    margin-left: auto;
+    margin-right: auto;
+    margin-bottom: 20px;
+	text-align: center;
+	width: 215px;
+}
+
+.award {
+	margin-top: -20px;
+	margin-left: auto;
+    margin-right: auto;
+    width: 144px;
+}
+
+#novaContent.faux  {
+	background: url("/gemini/images/faux.png") repeat-y scroll 0 0 #FFFFFF;
+}
+
+h1, h2, h3, h4 {
+	color: #002E62;
+}	
+
+a {
+	color: #002E62;
+}
+
+a:hover {
+	color: #0093CF;
+	text-decoration: none;
+}
+
+#incubation {
+	margin-left: auto;
+    margin-right: auto;
+    width: 98px;
+}
+
+#search #searchBox {
+	width:220px;
+}
+
+#novaContent li {
+	list-style-image: url("/gemini/images/bullet.png");
+}
diff --git a/style.css b/resources/style.css
similarity index 99%
rename from style.css
rename to resources/style.css
index edf76c9..fab5b1c 100644
--- a/style.css
+++ b/resources/style.css
@@ -1,4 +1,5 @@
 @CHARSET "UTF-8";
+
 #novaContent {
 	background: url("images/backgroundMain.png") no-repeat;
 	padding-top: 210px;
@@ -16,6 +17,7 @@
 
 h3 {
 	clear: both;
+	border: 0px
 }
 
 h7 {
@@ -27,7 +29,6 @@
 	text-decoration: underline;
 }
 
-
 #novaContent {
 	background: url("images/backgroundMain.png") no-repeat white;
 	padding-top: 170px;
diff --git a/support/index.php b/support/index.php
new file mode 100644
index 0000000..088a236
--- /dev/null
+++ b/support/index.php
@@ -0,0 +1,45 @@
+<?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());
+	
+/*******************************************************************************
+ * Copyright (c) 2009 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: Christopher Frost
+ *               Mike Keith
+ *    
+ *******************************************************************************/
+
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini DB Access - Support";
+	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, Support";
+	$pageAuthor		= "Mike Keith";
+		
+	ob_start();
+?>
+	
+	<div id="midcolumn">
+		<h2>Gemini DB Access Support</h2>
+		<p>
+			If you encounter any problems or issues with existing DB Access components please post to the <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153&">Gemini forum</a>.
+		</p>
+		<p>
+			You may also enter a bug against the DBAccess component of Gemini in <a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;order=Importance;classification=RT;product=Gemini">Bugzilla</a>.
+		</p>
+
+	</div>
+
+<?
+	$html = ob_get_clean();
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
