<?php

    /* Required eclipse basic classes */
    require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	
    /* Functions and modules related to Navbar objects */
    require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	
    /* Functions and modules related to the page top eclipse menu */
    require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	
    /* Functions used for display events */
    require_once($_SERVER['DOCUMENT_ROOT'] . "/dsdp/mtj/events.func.php");
    
    $App 	= new App();
    /* Left Navbar */	
    $Nav	= new Nav();	
    /*  Page top eclipse menu */
    $Menu 	= new Menu();

    /* Find the _projectCommon.php file and include it */
    include($App->getProjectCommon());

	
	/* Begin: page-specific settings. */ 
	$pageTitle 		= "DSDP&nbsp; - &nbsp;Mobile Tools for Java &nbsp; (MTJ) &nbsp; Contributing";
	$pageKeywords	= "contribute, mtj, developer, guide, mobile, tools, Java";
	$pageAuthor		= "Diego Madruga Sandin";
	
	/* End: page-specific settings */
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML
	<div id="maincontent">
	
		<div id="midcolumn"> 
		    <!-- Project description -->
			<h1>$pageTitle</h1>
			<br>
			<div class="homeitem3col">
    		<h3>Get involved</h3>
    		<p>
    		If you are interested in participating in the development of the MTJ, 
    		check out the developer's mailing list: <a href="https://dev.eclipse.org/mailman/listinfo/dsdp-mtj-dev">dsdp-mtj-dev</a>. 
    		Chat with people there about your problems and interests, and find out what you can do to help. 
    		</p>
    		<p>
    		To get started you can refer to the 
			<a href="/dsdp/mtj/development/">Developer tools</a> page to get information how to configure your <a href="/dsdp/mtj/development/svnsetup.php">development workspace</a>.
    		</p> 
    		</div>
    		<div class="homeitem3col">
            <h3>Exploring MTJ development</h3>
            <p>
            You may also want to check out the <a href="/dsdp/mtj/development/presentations/Exploring-MTJ.pdf">Exploring MTJ</a> presentation to see how to start contributing to MTJ.
            </p><center>
<p>
<div style="width:425px;text-align:left" id="__ss_1760772"><a style="font:14px Helvetica,Arial,Sans-serif;display:block;margin:12px 0 3px 0;text-decoration:underline;" href="http://www.slideshare.net/dpsmarques/exploring-mtj" title="Exploring MTJ">Exploring MTJ</a><object style="margin:0px" width="425" height="355"><param name="movie" value="http://static.slidesharecdn.com/swf/ssplayer2.swf?doc=exploring-mtj-090723144735-phpapp02&stripped_title=exploring-mtj" /><param name="allowFullScreen" value="true"/><param name="allowScriptAccess" value="always"/><embed src="http://static.slidesharecdn.com/swf/ssplayer2.swf?doc=exploring-mtj-090723144735-phpapp02&stripped_title=exploring-mtj" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="355"></embed></object><div style="font-size:11px;font-family:tahoma,arial;height:26px;padding-top:2px;">View more <a style="text-decoration:underline;" href="http://www.slideshare.net/">documents</a> from <a style="text-decoration:underline;" href="http://www.slideshare.net/dpsmarques">David Marques</a>.</div></div>
<!-- <iframe src="http://docs.google.com/present/embed?id=dfnh34p6_0d47mt7gt&loop=true&size=m" frameborder="0" width="555" height="451"></iframe> -->
</p>
            </center></div>
    		
    		
		</div> <!-- midcolumn -->
	</div> <!-- maincontent -->
	
<script type="text/javascript">var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));</script><script type="text/javascript">try {var pageTracker = _gat._getTracker("UA-9293663-1");pageTracker._trackPageview();} catch(err) {}</script>
	
EOHTML;

	/* Generate the web page */
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>