<?php

/*******************************************************************************
 *	File : index.php
 *	Author : Diego Madruga Sandin (dmadruga)
 *	Date :	2008-03-12
 *	Description : This is the main page for the MTJ project.
 ******************************************************************************/

/* 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 		= "Mobile Tools for Java &nbsp; (MTJ) &nbsp; Home Page";
$pageKeywords	= "mobile, tools, Java, runtime, design, framework, ";
$pageAuthor		= "Diego Madruga Sandin";

/*
 * Add page-specific Nav bars here.
 * Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
 *
 * Examples:
 *   $Nav->addNavSeparator("My Page Links", 	"downloads.php");
 *   $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
 *   $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);
 */

/* Generate Events content according to the 2009 year */
$events = generateContent("2010","Events","homeitem");


/* 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>

<h2>Mission Statement</h2>
<p>
    The goal of the Mobile Tools for Java<sup><small>TM</small></sup> (MTJ) project is to extend existing Eclipse frameworks to support mobile 
    device Java application development.
</p>
			
<h2>Scope</h2>
<p>
	The scope of the Mobile Tools for the Java Platform (MTJ) project is to extend the Eclipse platform to enable developers 
	to develop, debug, and deploy mobile Java applications to emulators and real devices. The project will develop frameworks 
	that can be extended by tool vendors and tools that can be used by third-party developers. 
</p>
						
<h2>Next Steps</h2>
<p>
    For accessing future plans, next steps, roadmaps, features discussions, and 
    other documents, check the MTJ <a href="http://wiki.eclipse.org/index.php/DSDP/MTJ" style="font-weight: bold;">wiki</a>. 			
</p>

<div class="homeitem3col">

	<h3>Latest Versions</h3>
	<ul>
        <li><b>Latest Release:</b><br><br>
            <ul>
                <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/S-1.1.1RC1-201009031435/index.html">MTJ 1.1.1</a>&nbsp;&nbsp;
				[
				    <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/S-1.1.1RC1-201009031435/index.html">Download</a> 
				  | <a href="http://download.eclipse.org/dsdp/mtj/updates/1.1.1/stable">Update Site</a>
				]
                <li>
                    &nbsp;&nbsp;This is the official 1.1.1 release that is part of the Helios SR1.
                </li>
            </ul>
        </li>
        <br><br>
        <li><b>Previous Releases:</b>
                <br><br>
           <ul>
                <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.1-201006161022/index.html">MTJ 1.1.0</a>&nbsp;&nbsp;
				[
				    <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.1-201006161022/index.html">Download</a> 
				  | <a href="http://download.eclipse.org/dsdp/mtj/updates/1.1.0/stable">Update Site</a>
				]
                <li>
                    &nbsp;&nbsp;This is the official 1.1 release for MTJ.
                </li>
            </ul>
	            <ul>
	                <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.0.1-200909181641/">MTJ 1.0.1</a>&nbsp;&nbsp;
					[
					    <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.0.1-200909181641/">Download</a> 
					  | <a href="http://download.eclipse.org/dsdp/mtj/updates/1.0.1/stable">Update Site</a>
					  | <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.0.1-200909181641/buildNotes.php">Build notes</a>
					  | <a href="http://www.eclipse.org/dsdp/mtj/development/releasenotes/MTJ1.0.1/newsNoteworthy.php">New & Noteworthy</a>
					]
	                <li>
	                    &nbsp;&nbsp;This is the official 1.0.1 release for MTJ. Check out the New & Noteworthy for more details in what is new in this release.
	                </li>
	            </ul>
                
                    <ul><a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.0-200906121354/">MTJ 1.0</a></font>&nbsp;&nbsp;
                                [<a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.0-200906121354/">Download</a> 
                                | <a href="http://download.eclipse.org/dsdp/mtj/updates/1.0/stable">Update Site</a>
                                | <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.0-200906121354/buildNotes.php">Build notes</a>
                                | <a href="http://www.eclipse.org/dsdp/mtj/development/releasenotes/MTJ1.0/newsNoteworthy.php">New & Noteworthy</a>
                                ] 
                    <li>&nbsp;&nbsp;This is the official 1.0 release for MTJ. Check out the New & Noteworthy for more details in what is new in this release.</li>
                    </ul>
                <ul><a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9.1-200812231340/">MTJ 0.9.1</a>&nbsp;&nbsp;
                                [<a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9.1-200812231340/">Downloads</a> 
                                | <a href="http://download.eclipse.org/dsdp/mtj/updates/0.9/stable">Update Site</a>
                                | <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9.1-200812231340/buildNotes.php">Build notes</a>
                                ]
                        <li>&nbsp;&nbsp;This release has several improvements including: preprocessing enhancements, library support, JMUnit support and MIDlet localization tool; Plus several fix for major bugs of MTJ 0.9.</li>
                    </ul>
                    <ul><a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9-200810141345/">MTJ 0.9</a>&nbsp;&nbsp;
                                [<a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9-200810141345/">Downloads</a> 
                                | <a href="http://download.eclipse.org/dsdp/mtj/updates/0.9/stable">Update Site</a>
                                | <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9-200810141345/buildNotes.php">Build notes</a>
                                ]
                        <li>&nbsp;&nbsp;This release is a stable software that includes all features available on EclipseME plus several improvements and bug fix. </li> 
                    </ul>
                <br>
        </li> 
</ul>
</div>
			<div class="homeitem">
                <h3>Quick Links</h3>
                    <ul>
                    	<li>
                    		<a href="http://www.eclipse.org/forums/eclipse.dsdp.mtj">Forum</a> 
                    		|  For general questions and community discussions. 
						</li>
                    	<li>
                    		<a href="http://dev.eclipse.org/mailman/listinfo/dsdp-mtj-dev">
                    			Developer Mailing List
                    		</a> 
                    		| For project development discussions.
                    	</li>
                    	<li>
                    		<a href="http://wiki.eclipse.org/DSDP/MTJ">Wiki</a> 
                    		| We use the Wiki for collaboration, discussion, meeting minutes etc.
                    	</li>
                    	<li>
                    		View 
                        		<a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&classification=DSDP&product=mtj&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED">
                        			all bugs
                        		</a> 
                    		| Submit 
                        		<a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?assigned_to=dsdp.mtj-inbox%40eclipse.org&blocked=&bug_file_loc=http%3A%2F%2F&bug_severity=normal&bug_status=NEW&comment=Overview%3A%20(More%20detailed%20restatement%20of%20summary)%0D%0A%0D%0ASteps%20to%20Reproduce%3A%20(Minimized%2C%20easy-to-follow%20steps%20that%20will%20trigger%20the%20bug)%0D%0A%0D%0A%20%20%20%201)%0D%0A%20%20%20%202)%0D%0A%0D%0AActual%20Results%3A%20(What%20MTJ%20did%20after%20performing%20the%20above%20steps)%0D%0A%0D%0A%0D%0A%0D%0AExpected%20Results%3A%20(What%20MTJ%20should%20have%20done%2C%20were%20the%20bug%20not%20present)%0D%0A%0D%0A%0D%0A%0D%0ABuild%20Date%20%26%20Platform%3A%20(update%20with%20the%20correct%20values%20from%20your%20workspace)%0D%0A%20%0D%0A%20Installation%20%3A%20eclipse-SDK-3.4.0%20(I20080617-2000)%20%0D%0A%20MTJ%20install%20%20%3A%20Runtime%20|%20SDK%20|%20Examples%0D%0A%20java.runtime%20%3A%20Java(TM)%20SE%20Runtime%20Environment%20(build%201.6.0_07-b06)%0D%0A%20os.name%3A%20%20%20%20%20%3A%20Windows%20XP%20Professional%2C%20Service%20Pack%203%0D%0A%0D%0AAdditional%20Builds%20and%20Platforms%3A%20(Whether%20or%20not%20it%20occurs%20on%20other%20platforms)%0D%0A%0D%0A%0D%0A%0D%0AAdditional%20Information%3A%20(Any%20other%20useful%20information)%0D%0A%0D%0A%0D%0A&contenttypeentry=&contenttypemethod=autodetect&contenttypeselection=text%2Fplain&data=&dependson=&description=&flag_type-1=X&flag_type-2=X&flag_type-4=X&flag_type-6=X&flag_type-7=X&flag_type-8=X&form_name=enter_bug&keywords=&maketemplate=Remember%20values%20as%20bookmarkable%20template&op_sys=All&priority=P3&product=MTJ&qa_contact=&rep_platform=All&short_desc=&version=unspecified">
                        			a new bug
                        		</a> 
                        	| Request an 
                            	<a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=mtj&version=unspecified&component=unspecified&rep_platform=All&op_sys=All&priority=P3&bug_severity=enhancement&form_name=enter_bug">
                            		enhancement
                            	</a>
                            | See the <a href="/dsdp/mtj/development/bug_process.php">Bug Process Page</a> for more queries and information.
                        </li>
                    </ul>
			</div> <!-- homeitem - Quick Links -->

			{$events}<!-- List of events  -->

		</div> <!-- midcolumn -->
		
		<div id="rightcolumn">	
	        <div class="sideitem">
	            <h6>What's New</h6>
	            <ul>
                    <li>Jun 23th, 10: <a href="http://download.eclipse.org/dsdp/mtj/downloads/drops/R-1.1-201006161022/index.html">MTJ 1.1.0</a> is now available (Helios Release)</li>	            
	            </ul>
	        </div>
		</div> <!-- rightcolumn -->
		
	</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);
?>
