<?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'

$branding = <<<EOBRANDING
<div id="branding">
<img src="/dash/images/projectdash.jpg" alt="Dash">
</div>
EOBRANDING;
$Menu->setProjectBranding($branding);

ob_start();
?>		
<script>
function cellChange(cell,value)
{
  if (value==1)
  {
    cell.style.cssText = 'background: url(images/getmonkey-on.gif)';
  }
  if (value==2)
  {
    cell.style.cssText = 'background: url(images/getmonkey-off.gif)';
  }
}
function ga(o,e){if (document.getElementById){a=o.id.substring(1); p = "";r = "";g = e.target;if (g) { t = g.id;f = g.parentNode;if (f) {p = f.id;h = f.parentNode;if (h) r = h.id;}} else{h = e.srcElement;f = h.parentNode;if (f) p = f.id;t = h.id;}if (t==a || p==a || r==a) return true;location.href=document.getElementById(a).href}}
</script>

<div id="maincontent">
	<div id="midcolumn">

  <table border="0" cellpadding="3" cellspacing="3" align="center">
    <tr>
      <td id=taw1 style="cursor: hand; background-image: url('images/getmonkey-off.gif'); background-repeat: none; background-attachment: scroll; background-position: 0% 50%"
       onMouseOver="cellChange(this,1)" 
    onMouseOut="cellChange(this,2)" 
    onClick="ga(this,event)"
    width=300 height=100><a id=aw1 href="monkey-help.php?key=installing"></a></td>
    </tr>
  </table>


<h2>What is Project Dash?</h2><p>
Project Dash is a place where the community itself cancollaborate on tools for community awareness and collaboration in support of ourultimate objective of committer quality and cooperation.
This is very much a research project as we are notentirely sure what these tools will be. </p>

<h2>Things You Can Get And Use</h2>

<h3>Dashboard</h3>

<p>The dashboard is a set of web pages (and REST web APIs) that monitor the recent activity of all the
Eclipse projects and committers. The results are 
on <a href="http://dash.eclipse.org/dash/commits/">the dashboard pages</a> and
the code is slowly being moved into the Dash CVS repository.</p>

<h3>Eclipse Monkey</h3>

<p>Eclipse Monkey is a dynamicscripting tool for the automation of routine programming tasks. Monkey scriptsare little Javascript programs using either the Eclipse APIs or custom MonkeyDOMs. For details on how to download, how to use, and how to share, 
<a href="monkey-help.php?key=installing">see the Monkey Help page</a>.
</p>
<p>If you'd like to help with the development of Eclipse Monkey, you
can materialize all the relevant source components using 
<a href="/buckminster">Buckminster</a> 
(<a href="http://download.eclipse.org/technology/buckminster/updates">use their update site</a>).
Simply use File > Open File... > <code>http://www.eclipse.org/dash/monkey/monkey.cquery</code>
and choose <em>Resolve and Materialize</em>.
</p>

<!--
<h2>Dash Time</h2>
<p>Dash Time is a regular virtual gathering
 for talking about Dash or Eclipse processes or community or technology or anything else that matters. 
 This is in the spirit of <a href="http://en.wikipedia.org/wiki/Salon_%28gathering%29">salon</a> - a gathering of stimulating people to increase their knowledge 
 through conversations and readings. And, in that spirit, we promise that no action items will be assigned.
</p><p>
Tuesdays, 10am Pacific time (1pm Eastern time). We'll be using simultaneous conference call, 
irc, and wiki that are all described on the <a href="http://wiki.eclipse.org/index.php/DashTime">wiki page</a>. We'll also use the wiki page as a 
scratchpad and a trail of conversations that we'll keep as long as they are useful.
</p>
-->

	</div>
	
</div>

<div id="rightcolumn">
 <div class="sideitem">
   <h6>Incubation</h6>
   <div align="center"><a href="/projects/gazoo.php"><img 
        align="center" src="/images/gazoo-incubation.jpg" 
        border="0" /></a></div>
 </div>
</div>

<?php
	$html = ob_get_contents();
	ob_end_clean();

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
